1）动态初始化:先声明，再赋值
int [][]arr=new int[2][2];//也可以是int[2][],将“列数”省略掉是可以的，不能将行数省略
arr[0][1]=1;
System.out.println(arr[0][1]);
2）静态初始化：再声明的同时直接赋值
int [][]arr=new int[][]{{1,2,3},{1,2}};//[][]中一定不能写数字
System.out.println(arr[0][1]);
3）java数组的特别之处--动态的
int [][]arr=new int [3][]; arr[0]=new int[3];//arr数组第0行有三列 arr[1]=new int[2];//第1行有两列 arr[2]=new int[1];//第2行有一列 System.out.println(Arrays.toString(arr[0]));//Arrays.toString 是将数组的整形转化成字符串 System.out.println(Arrays.toString(arr[1])); System.out.println(Arrays.toString(arr[2]));
运行的结果是
int [][]arr=new int [3][3];
System.out.println(Arrays.toString(arr[0]));
System.out.println(Arrays.toString(arr[1]));
System.out.println(Arrays.toString(arr[2]));
运行的结果是
2.数组的操作：1）数组的初始化（如上）
2）数组的长度：System.out.println(a.length);
3）数组的遍历：for(int i=0;i
}
for-each 循环：for(int k:a){
System.out.println(k);
}
4) 数组的排序：Arrays.sort()，括号中传入一个一维数组
int []a=new int[]{111,23,10};
Arrays.sort(a);
System.out.println(Arrays.toString(a));
二、输入与输出
1.输入：
1）需要import引用 java 包中的scanner类
import java.util.Scanner;（当然IDEA 中是会自己生成的，eclipse是不会这么做的）
2）nextInt()是接收整形，nextLine()和next()是接收字符串,nextfloat()浮点型
2.输出：1）换行输出System.out.println(）
2）单个输出System.out.print()
3）格式化输出System.out.printf("输出为%d",i)
Scanner in =new Scanner(System.in);
int s=in.nextInt();
System.out.printf("输入的s为 %d",s);
三、面对对象开发的三大特征* 1.封装
通过 private，defoult，protected，public 等关键字完成属性和方法的封装。
class text{
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
public class Main {
public static void main(String[] args) {
// write your code here
text s=new text();
s.setName("xiaozhang");
String username;
username=s.getName();
System.out.println(s);
}
}
*private封装的属性或变量要用”get“和”set"来访问*
2.继承 --extends关键字实现继承 3.多态 四、 对象与类 1.实例化（对对象进行创建）：使用new关键字进行创建Scanner in=new Scanner（System.in);
2.类的组成成员1）属性
2）private 属性 后要有set和get方法
3）构造函数（有无参）
4）方法和主方法
五、继承 1.object类：是万物的父类
2.extends关键字 3.父类的重写就是在子类里面有与父类中同名的方法，就叫做重写父类
六、封装使用private关键字对类中的属性进行修饰，将属性隐藏起来，要用get，set方法进行控制和调用
class demo {
private int i;
private String s;
public int getI(){
return i;
}
public String getS(){
return s;
}
public void setI(int i){
this.i=i;
}
public void setS(String i){
this.s=s;
}
}
七、构造方法
class text{
private String name;
private int age;
public text(String name){
this.name=name;
}
public text(int age){
this.age=age;
}
public text(){}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge(){return age;}
public void setAge(int age){this.age=age;}
}
public class Main {
public static void main(String[] args) {
// write your code here
text demo=new text(123);
text demo1=new text("zhang");
text demo2=new text();
}
}
八、方法
1.方法的生成格式
<访问权限修饰符><返回形式声明><方法名>(参数列表){
封装的逻辑方法
return 返回值；
}
2.方法的重载1）必须是在一个类当中
2）方法名相同
3）方法的类型，个数或顺序不同
4）与方法的修饰符和返回值无关
3.方法的重写1）只出现在子类和父类当中
2）子类中出现和父类中一模一样的方法（包括名字，返回类型，参数列表）
九、this 关键字和 super 关键字1.this关键字：
主要存在于类当中，用来代替所创建的对象，不能在static修饰的静态方法中使用
2.super关键字：
主要存在于子类当中，用于引用子类对象的父类对象，可以访问父类的属性，函数以及构造函数。
class paretent{
public int a=134;
public void getname(){
System.out.println("我是父类") ;
}
}
public class Main extends paretent{
public void put(){
System.out.println(super.a);
}
public void putname(){
super.getname();
}
public static void main(String[] args) {
// write your code here
Main a=new Main();
a.put();
}
}
十、static 关键字和 final 关键字
1.static
1）被static 修饰的变量就是静态变量，被static修饰的方法就是静态方法
2）静态代码块
static {
int a=1;
}
在类中存在，静态代码块里面的东西，会在类被生成之前，提前被生成
3）修饰成静态的便捷之处：可以不用new一个新的对象来调用类里面的属性或方法，
可以直接用类名引用
class mypartent{
static int a=9;
public static void test(){
System.out.println("我是静态方法");
}
}
public class Main {
public static void main(String[] args) {
// write your code here
System.out.println(mypartent.a);
mypartent.test();
}
}
2.final关键字
1）final 修饰的类，不能被继承
2）final 修饰的方法，不能被重写，但是子类可以使用父类中的final方法
3）final修饰的变量，不可变
