继承

继承：

​ 可以让子类继承父类，这样子类会继承父类所有的属性和方法。然而在Java中是不允许有多继承的，即一个子类只能继承一个父类，不能同时继承多个父类。如果一个类还需要另外一个类的方法，可以让父类去继承需要的类。但Java中支持多重继承，即一个子类也可以做为其他类的父类。

Object类：

​ 是Java中的祖宗类，当一个类在代码层面没有去继承任何的父类，那这个类默认会继承object类。
​ 继承的重写（覆盖）：子类继承父类以后，可以获取到父类的所有方法（包含被private修饰的方法，只是访问不到），如果父类的方法功能不能满足子类的需求，那么子类可以根据需求对这个方法进行重写。

Super关键字：

​ 子类继承父类后，子类可以通过super关键字去指向父类的元素（属性，构造方法，普通方法）。
​ 如果是指向父类的构造方法：super()
​ 如果是指向子类的构造方法：this()
​ 注：像super(),this()这样的表达式只能存在于构造方法中，且只能出现一次。
​ 如果是指向父类的普通方法：super.方法名称()
​ 如果是指向父类的属性：super.属性名称()

构造方法的继承：

​ 在继承时，当子类用到默认的无参构造方法时，父类必须要有无参构造方法，不然子类的构造方法就会报错。因为子类继承父类之后，获取到了父类的内容（属性/字段），而这些内容在使用之前必须先初始化，子类如果在没有自定义构造方法的情况下默认会有一个无参构造方法，其中第一行默认会有一个super()，所以必须先调用父类的构造函数进行内容的初始化。所以父类必须要有一个无参构造方法。
子类直接继承得到的属性无法直接获取，可以通过父类的get和set方法来获取和修改属性。

public class Animal {
private String name;
private int age;
private String hobby;

public Animal(){
    
}
 public Animal(String name, int age, String hobby) {
        this.name = name;
        this.age = age;
        this.hobby = hobby;
    }
}

public class Dog extends Animal {

    public Dog(String name, int age, String hobby) {
        super(name, age, hobby);
    }
}

方法重写与方法重载的区别：

​ 方法重写override：方法重写是指子类在继承了父类之后需要对父类的一些方法进行修改，以适应程序需求，因此在子类中重写父类中原有的方法。

​ 方法重载overload：方法重载是指同一个类中的不同方法，方法名称相同，但是参数列表不同。

多态

多态：

​ 多态是面向对象特征之一，也是最重要的一个特征，在完成项目的过程中，也会有很多多态的体现。在做开发的时候目的是为了解除类与类之间的耦合（模块与模块之间的耦合），不能面向具体（过程）编程，而是面向抽象（接口）编程。首先多态必须要有父子关系的体现（继承、实现），是在不同时刻展现不同的状态。用父类的引用来接收子类的对象。

​ 父类的引用接收子类对象（向上转型）、或者是从父到子，父类引用转为子类对象（向下转型）都是多态的体现。

​ 多态在程序执行时分为编译阶段和运行阶段。
成员访问特点：
​ ●成员变量
​ 编译看左边， 运行看左边
​ ●成员方法
​ 编译看左边，运行看右边
​ ●静态方法
​ 编译看左边，运行看左边
​ 所以静态方法不能算方法的重写

编译阶段看左边：编译要检测调用的方法在父类中是否存在
运行阶段看右边：实际new出来的是子类对象，所以执行的方法应该是子类的方法

public class PolyTest01 {

    public static void main(String[] args) {
        //通过多态机制创建猫的实例  向上转型
        Animal animal=new Cat();
        animal.eat();

        //引用数据类型的强转也是多态的一种
        Animal animal1=(Animal)cat;
        animal1.eat();
    }
}

​ 不能将Animal对象强转成Cat，即不能直接将父类对象强转为子类对象

Animal animal2=new Animal();
Cat cat1=(Cat)animal2;
cat1.eat();

​ 但是当父类对象是用某一子类new出来的时候，是可以强转为对应子类对象的

Animal animal=new Cat();
Cat cat=(Cat)animal;

父类对象接收子类Rabbit实例，然后再把父类对象强转为另一子类Cat 这是不允许的 ClassCastException， 但是编译会通过，因为在编译阶段向下转型只要是父子关系就不会报错。

Animal animal2=new Rabbit();
Cat cat2=(Cat)animal2;
cat2.eat();

​ 因此这里我们可以用instanceof关键字来做判断，这样可以避免运行报错。

if(animal2 instanceof Cat)
{
    Cat cat2=(Cat)animal2;
    cat2.eat();
}
else System.out.println("不能进行强转！");

多态的实际运用：

​ 主人喂养宠物案例：有一个主人喜欢喂养宠物，有猫，狗，兔子，小鸟，随着时间推移，主人会喂养越来越多的宠物。

public class Master {

    /*public void feed(Rabbit rabbit)
    {
        rabbit.eat();
    }*/
    //喂养的方法
     public void feed(Pet pet)//父类的引用接收所有子类的对象 多态的体现
     {
         pet.eat();
     }
}

​ 可以看出多态的主要运用就是在于此，不止是喂养兔子，而是所有宠物。因此不采用多态，那么需要给每种宠物都写一个对应的喂养方法。然而，采用了多态，就可以把参数设置成为父类，即宠物。那么只需要在调用的时候传递不同的参数即可，在函数具体实现的时候用一个公共的父类宠物类来接收。即是父类的引用接收子类的对象。

​ 如果按照传统的方式进行开发（不使用多态），在程序迭代的过程中，需要不断的去修改主人类（需要在原有的代码基础之上修改），这样做违背了设计模式中的开闭原则（OCP原则：对扩展开放，对修改关闭）：在写程序的时候，尽量避免在原有的代码上进行修改，这样的话修改的部分容易对类别的类（或者说别的模块）造成影响。

抽象类

格式：

​ 抽象类：abstract class 类名{}

​ 抽象方法：public abstract void def();

​ 抽象类是java中最顶层的一种表现形式，接下来是类，在接下来就是对象，抽象类abstract > 类class > new 对象
​ 如果要创建对象的话，只能是通过类class去创建，抽象类是不能创建对象的，因为抽象类的下一级是类

​ 1、抽象类指的是类class (本身就是抽象的事物）往上继续抽象就得到了抽象类
​ 2、抽象类用abstract关键字进行修饰
​ 3、抽象类中可以有普通方法，可以有抽象方法
​ 4、抽象方法一定存在于抽象类中
​ 5、抽象类是不能实例化对象的,因为抽象类的下一级是class
​ 6、抽象类的作用就是用来被子类继承的
​ 7、抽象类中也可以定义普通的成员变量、静态变量、普通方法，静态方法
​ 8、抽象方法是没有方法体的，不用提供具体的实现，当子类继承了抽象类后，抽象类中的所有抽象方法必须要重写

final关键字：

​ 可以修饰类、成员变量、局部变量、方法（静态方法、实例方法)
​ 1、被final修饰的类不能用来被继承
​ 2、被final修饰的属性，若是基本数据类型，则必须在定义变量的时候初始化，不能再重新赋值。若是引用数据类型，在程序运行过程中，变量的引用不能指向别的内存地址。
​ 3、被final修饰的方法，不能被子类重写

​ final关键字不能修饰抽象类：因为抽象类本身就是用来被继承的，而final关键字修饰过的类不能被继承，所以抽象类是不能用final来修饰的。