复习JavaDay04

多维数组取值

//取出二维数组的所有值
int[][] arr = {{2, 2}, {3, 4}, {5, 6}};
​
//数组长度
for (int i = 0; i < arr.length; i++) {
    for (int j = 0; j < arr[i].length; j++) {
        System.out.println(arr[i][j]);
    }
}
//--------------------------------------------
//取出二维数组中的下标为2的元素的第二个值
System.out.println(arr[2][1]);

冒泡排序

  //初识冒泡排序，按最小数排到最大
    int[] a = {11, 31, 22, 9, 15, 222, 1, 2, 3};
    System.out.println(Arrays.toString(test(a)));
}
​
public static int[] test(int array[]) {
    //临时变量
    int a = 0;
    //判断要循环多少次，即下标有多少个
    for (int i = 0; i < array.length - 1; i++) {
        //判断两个数，如果第一个数小于第二个数，则交换位置
        for (int j = 0; j < array.length - 1 - i; j++) {
            if (array[j + 1] < array[j]) {
                a = array[j];
                array[j] = array[j + 1];
                array[j + 1] = a;
            }
        }
    }
    return array;

什么是面向对象？

面向对象编程的本质就是：以类的方式组织代码，以对象的形式（封装）数据。

面向对象的三大特性：封装，继承，多态。

Java中的值传递和引用传递

  int a = 1;
    System.out.println(a);
​
    //这里调用的是本类中的change（改变）方法
    //但是该没有做任何的操作，在这里调用时把main方法中的a的值传递给了change方法，所以值还是1
    Test7.change(a);
    System.out.println(a);
}
​
public static void change(int a){
    a = 10;
}

构造器

构造方法为有参构造和无参构造两种。构造器的作用有两种。

1.使用new关键字，本质是在调用构造方法

2.初始化值。

构造器的两个特点：1.与类名相同。2.没有返回值。

注意：定义了有参构造就必须重写一个无参，不然会报错。

 

类是一个抽象模板，对象是一个具体实例。

未理解

冒泡排序的算法

封装，继承，多态

封装：

该露的露，改藏的藏，我们程序设计要追求”高内聚，低耦合“，高内聚就是类的内部数据操作细节自己完成

不允许外部干涉，低耦合：近暴露少量的方法给外部使用。

通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。

记住这句话就够了：属性私有get/set。 有时候set方法中会写一些安全性的判断。

封装的意义在于： 1.提高程序的安全性，保护数据

2.隐藏代码的实现细节。

3.统一接口，提升代码的规范。

4.增加系统可维护性

继承：

继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。

extends的意思是”扩展“，子类是父类的扩展。

Java中类只有单继承，没有多继承。

自我总结：父类可以被多个子类继承，继承父类的子类拥有父类所有属性和方法

如需访问父类方法，则使用super.方法名()即可。

如需访问父类属性，则使用super.get属性名即可。

被private修饰过的方法子类无法使用。

在Java中，所有的类都默认直接或者间接继承了Object类

super注意点：

1.super调用父类的构造方法，必须在构造方法的第一个。

2.super只能出现在构造方法或者子类的方法中。

3.super和this不能同时调用构造方法。

重写：需要有继承关系，子类重写了父类的方法。

1.方法名必须相同。

2.参数列表必须相同。

3.修饰符可以扩大。例如（private变成public）

4.抛出的异常：范围可以被缩小，但是不能扩大。

子类的方法和必须要和父类一致，但是方法体不同。重写的好处在于 子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。 重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。 例如： 父类的一个方法申明了一个检查异常 IOException，但是在重写这个方法的时候不能抛出 Exception 异常，因为 Exception 是 IOException 的父类，只能抛出 IOException 的子类异常。 在面向对象原则里，重写意味着可以重写任何现有方法。

多态

定义一个父类类型的引用指向一个子类的对象既可以使用子类强大的功能，又可以抽取父类的共性。. 所以，父类类型的引用可以调用父类中定义的所有属性和方法，而对于子类中定义而父类中没有的方法，它是无可奈何的；. 对于父类中定义的方法，如果子类中重写了该方法，那么父类类型的引用将会调用子类中的这个方法，这就是动态连接。

1.多态是方法的多态，属性没有多态。

2.父类和子类，一定是有关联的，不然会出现异常。（ClassCostException）

3.存在条件，继承关系，子类需要重写父类的方法，父类引用指向子类对象。

需要注意

static修饰过的方法不能被重写，因为被static修饰过的方法会和类一同被加载，会导致结果异常。

final修饰过不能重写。

privcte私有的也不能被重写。