Java类和对象[二维数组生成与打印，类和对象的public，static，private与实例化]

二维定义

  public static void array_2D_define() {
    
    
        /**
         * C：可以省略行，由列推出行
         * Java：可以省略列，但不能省略行，否则编译器不知道行，列因为有不规则的二维数组存在因此无法推出
         */
        int[][] arr1 = {
    
    {
    
    1, 2, 3}, {
    
    4, 5, 6}};
        int[][] arr2 = new int[][]{
    
    {
    
    1, 2, 3}, {
    
    4, 5, 6}};//new int[][]括号中不能填写行列
        int[][] arr3 = new int[2][];//省略列，编译成功
//        int[][] arr4 = new int[][3];//省略行会报错
        int[][] arr5 = new int[2][3];//行列不省略
    }

二维数组打印

public static void array_2D_printout() {
    
    
        int[][] arr1 = {
    
    {
    
    1, 2, 3}, {
    
    4, 5, 6}};
        for (int i = 0; i < arr1.length; i++) {
    
    
            for (int j = 0; j < arr1[i].length; j++) {
    
    
                System.out.print(arr1[i][j] + " ");
            }
            System.out.println();
        }

        System.out.println(Arrays.toString(arr1));
        System.out.println(Arrays.deepToString(arr1));

        for (int[] tmp : arr1) {
    
    
            for (int val : tmp) {
    
    
                System.out.print(val + " ");
            }
            System.out.println();
        }
    }

不规则二维数组

   public static void irregular_array_2D() {
    
    
        /**
         * 不规则二维数组
         * 正应为不规则，所以不能像C一样省略行即可推导列；Java必须有行
         * 默认的0值
         */
        int[][] arr1 = new int[2][];
        arr1[0] = new int[3];
        arr1[1] = new int[2];
        System.out.println(Arrays.deepToString(arr1));
    }

public和static修饰的属性与方法如何访问与调用

/**
 * 访问修饰限定符
 * public：公开
 * private：私有
 * protected：受保护的
 * 什么都不写：默认权限[包访问权限]
 */
class Person {
    
    
    /**
     * 字段->成员变量：定义在方法的外边，内的里面
     * 对象在堆上，实例化变量在栈上。栈指向堆
     */
    //实例成员变量：对象里面
    public String name = "智能路障";
    public int age = 25;
    //静态成员变量 不属于对象，属于方法区: 和实例成员一样不初始化就默认 0 值
    public static int size;//无论new多少次，只有一份

    //方法->行为，不加static就是实例成员方法
    public void eat() {
    
    
        int a = 10;//局部变量
        System.out.println("eat()");
    }

    public void sleep() {
    
    
        System.out.println("sleep()");
        eat();//非静态可以访问非静态
    }

    public static void func1() {
    
    
        System.out.println("static func1()");
//        age = 99;//静态方法内部，不能访问非静态的数据成员
        size = 99;
    }

    public static void func2() {
    
    
        func1();
//        sleep();//静态方法内部不能访问非静态方法
        Person person1 = new Person();
        person1.sleep();//静态访问非静态必须使用实例化对象
    }

    public void show() {
    
    
        System.out.println("我是：" + name + "，今年" + age + "岁");
    }
}

private封装

/**
 * 封装: 用private修饰属性或者方法，一般属性都设置为private私有
 * this: 当前对象的 引用
 * get和set方法快捷键：alt+insert[control+return]: Get and Set生成对应方法     toString生成注解
 */
class Student {
    
    
    //有private修饰的属性只能在类内部访问，无法通过对象访问
    private String MyName;
    public int age;

    //提供一个公开的接口

    public String getMyName() {
    
    
        return MyName;
    }

    /*public void setMyName(String MyName) {
        MyName = MyName;//局部变量优先原则，自己给自己赋值
        this.MyName = MyName;
    }*/

    public void setMyName(String myName) {
    
    
        this.MyName = myName;
    }

    public void func1() {
    
    
        System.out.println("func1()");
    }

    /**
     * 重新是吸纳了一下Object类的toString()方法
     * Student@29453f44
     * 类型@地址的哈希值
     */
    @Override//注解：这个注解指的是 这个方法是重新写的
    public String toString() {
    
    
        return "Student{" +
                "MyName='" + MyName + '\'' +
                ", age=" + age +
                '}';
    }
}

总结

1. 打印二维数组
   System.out.println(Arrays.toString(arr));//打印行的地址 System.out.println(Arrays.deepToString(arr));//深度打印
for循环双层遍历打印
2. 二维数组定义

int[][] arr1 = {
    
    {
    
    1, 2, 3}, {
    
    4, 5, 6}};//两行三列。int[3][2] arr={1,2,3,4,5,6};会报错。类型中不可以申明行列，与C不同
        int[][] arr2 = new int[][]{
    
    {
    
    1, 2, 3}, {
    
    4, 5, 6}};//new int[][]中还是不可以填行列
        int[][] arr3 = new int[2][3];//不初始化可以选择行列

3. 不规则二维数组问题
   C：可以省略行，有了列就可以推导行
   java：行必须指定，列不可以推到行
   arr栈上指向堆中仅有的两个元素，堆中元素所指向的数据不知则为null，因此无法推出列

在这里插入代码片int[][] arr4=new int[2][];

        //不初始化默认值是0
        arr4[0] = new int[3];
        arr4[1] = new int[2];
        System.out.println(Arrays.deepToString(arr4));

        arr4[0] = new int[]{
    
    1,2,3};
        arr4[1] = new int[]{
    
    4,5};
        System.out.println(Arrays.deepToString(arr4));

4. 类和对象

• public：访问修饰限定符
• private：私有的
• protected：首保护的
• 什么都不写：默认权限–>包访问权限

5. 实例成员变量那些事

1.字段-->成员变量：定义在方法的外边；内的里边。
2.实例成员变量：在对象里。没有初始化则默认为对用的0值。3.引用类型为null，简单数值类型为0
char -> '\u0000' boolean -> false
4.静态成员变量不初始化也是默认的0值。不通过实例化的对象进行访问 类名 . 静态成员变量 [无论new多少次，结果都只有一份]
5.在静态方法内部无法访问非晶态方法成员

6. 实例方法那些事

  //方法-->行为：实例成员方法
    public void eat() {
    
    
        int a = 10;//局部变量
        System.out.println("eat()!");
    }
    public void sleep() {
    
    
        System.out.println("sleep()!");
    }
    //注意：static修饰的静态方法只能在内部访问或者外部用类名.方法的形式访问而与其它没有static修饰的函数可以通过实例化对象访问不同
    public static void func1(){
    
    
        System.out.println("static func1!");
    }
    public void show() {
    
    
        System.out.println("我是：" + name + ", 今年" + age + "岁");
    }

7. 封装private

封装：用private修饰属性或方法
this：当前对象的 引用[要习惯使用this
没有特殊要求，属性设置为private
快捷键设置set与get是alt+insert

class Student{
    
    
    public String name;
    public int age;
    private int id;
    public void func1(){
    
    
        System.out.println(id);//private修饰的属性在类的内部可以访问
    }
    //提供一个公开的接口
    public int getId(){
    
    
        return id;
    }

//    public void setId(int ID){
    
    
//        id = ID;
//    }

    /*public void setId(int id){
        id = id;
        自己给自己赋值，局部变量优先解决方案是this
    }*/
    public void setId(int id){
    
    
        this.id = id;
    }

    public void show(){
    
    
        System.out.println("我是"+this.name+"今年"+this.age+"岁，ID是"+this.id);
    }
}