继承、重载、重写、多态、抽象类、接口、Static (五)

一、继承

继承：你继承谁你就是谁，继承是一种严格的父子关系（Student继承Person，那么Student就是人）
NOTE：Java是单继承，就是一个类只能继承extends(inherit)一个类，而java这中面向对象的语言就是对现实世界的描述，现实世界中是存在很多多继承，但是java里面是支持实现多个接口。
Object是所有类的父类（这个父类不一定是直接父类）

访问修饰符：

提高代码复用性。
将所有子类共有的属性和方法抽取到父类里面，子类继承父类，那么父类里面的属性和方法相当于子类里面也有。

二、重载

在同一个类里面，允许存在一个以上同名方法，只要他们参数类型和参数个数不同即可。
构造方法重载（无参构造方法、有参构造方法也是一种重载）
方法重载特点：与返回值无关，只看参数列表（参数个数和参数类型）。
例子：

void show(int a, char b, double c){}

1、void show(int x, char y, double z){}   不是重载，是同一个方法 
2、int show(int a, double c, char b){}      是重载，顺序不一样也是重载
3、void  show(int a, double c, char b){}   是重载
4、boolean show(int c, char b){}           是重载
5、void show(double c){ }                     是重载
6、double show(int x, char y, double z){}  不是重载

三、重写

note：

1、子类覆盖父类，必须保证子类权限大于父类权限才可以覆盖，否则会编译失败。
2、如果父类是private的方法，子类是默认方法，那么子类是不知道这个方法的，不是覆盖。

重载（Overload）：同一个类中看同名方法的参数列表。（构造方法重载）
重写（Override）：父子类方法要一模一样

四、抽象类

note：
1.抽象方法必须是抽象类
2.抽象方法没有方法体
3.如果一个类是抽象那么这个类不能被实例化
4.不管方法是不是抽象方法，子类里都能重写

抽象方法：在父类创建一个标准，让子类实现

抽象类：
1、抽象方法是没有方法体，如果这个类里面有抽象方法，这个类必须变成抽象类。
2、如果这个类是抽象类，并不要求这个类一定要有抽象方法
3、抽象类里面可以有普通方法，也可以有抽象方法。
4、如果一个类是抽象类，那么这个类就不能被new实例化，只能被其他类继承。
5、抽象方法可以理解为父类（抽象类）定义的一个模板或者规范（自己本身不实现），
子类必须实现这个抽象方法。如果子类不想实现这个方法，那么这个子类也必须要变成抽象类。

五、接口interface

1.接口

接口是一个纯粹的抽象类（接口里面所有的方法都是抽象方法）
接口就是一个规范，他没有提供任何是实现，具体的功能由实现接口的子类去实现。

接口中定义
变量，默认为public final int 类型；
//UML ----- 斜体代表抽象类

2.接口和抽象类异同。

相同：接口和抽象类都不能被实例化
不同：接口就是一个规范，他没有提供任何是实现，具体的功能由实现接口的子类去实现。
抽象类里面可以有普通方法，也可以有抽象方法
抽象方法可以理解为父类（抽象类）定义的一个模板或者规范（自己本身不实现），
子类必须实现这个抽象方法。如果子类不想实现这个方法，那么这个子类也必须要变成抽象类。

3.什么时候用接口什么时候用继承？

严格的父子关系，所有的子类都有父类的功能----用继承
不是所有的子类都有这个功能，看子类具不具备这个功能----用接口

继承是严格的父子关系，你继承什么你就是什么：鸽子就是鸟。
父类是抽取了所有子类的共同特征，父类里面的属性和方法是所有子类所共有的属性和方法。
接口是一个标准，一般用在能不能具有某个功能。
把能不能飞定义称为一个接口IFly，实现了这个接口的类就具有了这个功能。

4.final

final:最终的意思
final变量：这个变量就不能被修改，常量 public static final double PI = 3.1415;
final类：这个类就不能被继承
final方法：这个方法就不能被重写

六、静态属性、静态方法：

1.比喻理解

小区里面业主的房子可以看成一个一个的对象，这些都是属于特定的业主所独有。
但是小区里面也有一些公共设施（健身器材、绿地），这些公共设施是属于这个小区的。
但是是可以被所有的业主对象所使用的。
java类里面定义的静态变量和静态方法是属于这个类的，不属于new出来的Student对象，
但是可以被所有的对象所使用。

2.使用的时候注意

1、静态的方法只能访问静态的方法和静态的属性（因为当前对象的实例可以没有创建，
所以静态的方法是没办法调用非静态的方法和属性的）
2、静态的方法中不能写this、super关键字(因为当前的对象实例可能还没有创建，
代表当前类对象的this还有代表父类对象的super可能都还没有创建)

非静态的属性和方法（实例属性和方法）必须通过new对象访问，而静态的属性和方法
是属于类的，在类加载到内存中就可以访问，被所有对象所共享。

静态 类似于 小区中的公共设施不在对象之中，但是能被对象所使用
建议使用类名.属性方式与实力属性区分

3.静态特点

1、在内存中存放位置不同 所有带static修饰符的属性或者方法都存放在内存中的方法区 而非静态属性存放在内存中的堆区
2、出现时机不同 静态属性或方法在没创建对象之前就已经存在 而非静态属性在创建对象之后才存在
3、静态属性是在某个类中的所有对象是共享的
4、生命周期不同 静态属性在类消失之后才销毁 而非晶态属性在对象销毁之后才销毁

练习

自己写一个工具类类似于工具类：Math
类名：ArrayUtil

public class ArrayUtil {
    private ArrayUtil(){

    }
    public static int max(int[] array){
        int max = array[0];
        for (int i = 1; i <array.length ; i++) {
            if(max < array[i]){
                max = array[i];
            }
        }
        return max;
    }

    public static int min(int[] array){
        int min = array[0];
        for (int i = 1; i < array.length; i++) {
            if (min > array[i]){
                min = array[i];
            }
        }
        return min;
    }

    public static void bubbleSort(int[] array){
        for (int i = 1; i <= array.length-1; i++) {
            for (int j = 0; j <array.length-i ; j++) {
                    if (array[j]>array[j+1]){
                        int temp;
                        temp = array[j];
                        array[j] = array[j+1];
                        array[j+1] = temp;
                    }
            }
        }
    }

}

public class Demo {
    public static void main(String[] args) {
        int[] array = {12,123,456,456,873,743};
        int max = ArrayUtil.max(array);
        System.out.println(max);

        int min = ArrayUtil.min(array);
        System.out.println(min);

        ArrayUtil.bubbleSort(array);
        for (int i = 0; i < array.length; i++) {

            System.out.println(array[i]);
        }
    }
}