1. 向上转型

我们来看看以下程序

class Animal {
    public String name;
    public int age;
    public void eat() {
        System.out.println("父类的方法");
    }
}
class Cat extends Animal {
    public String hire;
    public void mew() {
        System.out.println(this.name + "：喵喵");
    }
    public Cat() {
        super();
        System.out.println("子类构造方法");
    }
}

public class Test1 {
    public static void main(String[] args) {
        Animal animal = new Cat();//通过父类引用 引用子类对象
        animal.name = "凉凉";
        animal.age = 3;
        animal.eat();
    }
}

通过以上程序我们可以看到在实例化对象时，通过父类引用 引用子类进行实例化对象。
所以向上转型就是：父类引用 引用子类对象。

注意：

1. 发生向上转型时，父类对象 animal 只能访问自己特有的属性和方法，不能访问子类的成员变量和成员方法，当访问子类成员时将会报错。

2. 发生向上转型时，子类的构造方法也会被调用。我们执行一下上面的程序。

2. 重写

class Animal {
    public String name;
    public int age;
    public void eat() {
        System.out.println(this.name + "正在吃饭");
    }
}
class Cat extends Animal {
    public String hire;
    public void mew() {
        System.out.println(this.name + "：喵喵");
    }
    public void eat() {
        System.out.println(this.name+ "正在吃猫粮");
    }
}
public class Test1 {
    public static void main(String[] args) {
        Animal animal = new Cat();//向上转型
        animal.name = "凉凉";
        animal.eat();
    }
}

当我们运行上面代码看看结果是什么。

这时我们就有疑惑了，发生向上转型时父类引用不是不能访问子类的成员方法吗，这里为什么是访问子类的成员方法呢？

这时因为发生了动态绑定，子类重写了 eat() 方法，此时用的是子类的 eat() 方法。

1. 先来分析编译阶段:
   对于编译器来说，编译器只知道 animal 的类型是Animal,所以编译器在检查语法的时候，会去Animal.class字节码文件中找eat()方法，找到了，绑定上 eat() 方法，编译通过，静态绑定成功。（编译阶段属于静态绑定)

2. 再来分析运行阶段:
   运行阶段的时候，实际上在堆内存中创建的 java 对象是 Cat 对象，所以当我们子类重写了 eat() 的时候，真正参与 eat() 的对象是Cat，所以运行阶段会动态执行 Cat 对象的 eat() 方法。这个过程属于运行阶段绑定。(运行阶段绑定属于动态绑定)

1. 总的来说就说编译时还是 Animal 的 eat() 方法，但是运行时变为子类的 eat() 方法，这叫运行时绑定，也叫动态绑定。

2. 当发生向上转型时，看子类有没有重写父类的方法，有的话则调用子类方法，没有则调用父类的。

我们可以看到在编译时还是 Animal 的 eat() 方法。

重写时是动态绑定
重载时是静态绑定

那么怎么样才能发生重写呢？

静态的方法不能发生重写

那有的人就会说我这么写呢：

重写规则：

• 子类在重写父类的方法时，一般必须与父类方法原型一致：修饰符 返回值类型 方法名(参数列表) 要完全一致
• 访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类方法被public修饰，则子类中重写该方 法就不能声明为 protected
• 父类被static、private修饰的方法、构造方法都不能被重写。
• 子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为private 和 final 的方法。
• 重写的方法, 可以使用 @Override 注解来显式指定. 有了这个注解能帮我们进行一些合法性校验. 例如不小心将方法名字拼写错了 (比如写成 aet), 那么此时编译器就会发现父类中没有 aet 方法, 就会编译报错, 提示无法构成重写.

3. 多态

在java中要实现多态，必须要满足如下几个条件，缺一不可：

1. 必须在继承体系下。
2. 子类必须要对父类中方法进行重写。
3. 通过父类的引用调用重写的方法 ，即父类引用 引用子类对象，通过该对象访问重写的方法。

多态体现：在代码运行时，当传递不同类对象时，会调用对应类中的方法。

//动物类
class Animal {
    public String name;
    public int age;
    public void eat() {
        System.out.println("正在吃饭");
    }

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
}
//猫类
class Cat extends Animal {
    public void mew() {
        System.out.println(this.name + "喵喵叫");
    }

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

    @Override
    public void eat() {
        System.out.println(this.name + "正在吃猫粮");
    }

}
//狗类
class Dog extends Animal {
    public void bark() {
        System.out.println(this.name + "汪汪叫");
    }

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

    @Override
    public void eat() {
        System.out.println(this.name + "正在吃狗粮");
    }

}

public class Test1 {
    public static void main(String[] args) {
        Animal animal1 = new Cat("猫", 2);
        Animal animal2 = new Dog("狗",3);
        animal1.eat();
        animal2.eat();
    }
}

像这样，动物有许多，但是它们吃的东西可能是不一样的，猫吃猫粮，狗吃狗粮。Animal 类可以有多个子类，当发生向上转型时，父类引用 引用不同子类的对象时，展现出不同的行为，这就是多态的思想。

例如：上面的父类引用 分别引用 Dog 对象 和 Cat 对象，当利用这些父类引用去访问 eat() 方法时展现出不同的行为（猫吃猫粮，狗吃狗粮）。

具体点就是去完成某个行为，当不同的对象去完成时会产生出不同 的状态。

多态:就是一个父类可以有多个子类，多个子类中分别重写了父类的同一个方法，当不同对象(即不同子类对象)去调用这个方法时表现出不同的行为

4. 向下转型

将一个子类对象经过向上转型之后当成父类方法使用，再无法调用子类的方法，但有时候可能需要调用子类特有的方法，此时：将父类引用再还原为子类对象即可，即向下转换。

class Animal {
    public String name;
    public int age;
    public void eat() {
        System.out.println("正在吃饭");
    }
}
//鸟类
class Bird extends Animal {
    @Override
    public void eat() {
        System.out.println(this.name + "正在吃虫子");
    }
    public void fly() {
        System.out.println(this.name + "正在飞");
    }
}
public class Test1 {
    public static void main(String[] args) {
        Animal animal = new Bird();
        Bird bird = (Bird)animal;	//向下转型
        bird.fly();	//向下转型后调用子类特有的方法
    }
}

但向下转型有时并不安全。

如上，当我们用animal引用 引用 Cat 对象，animal 实例不是 Bird 的对象，所以运行时会报异常

向下转型用的比较少，而且不安全，万一转换失败，运行时就会抛异常。Java中为了提高向下转型的安全性，引入了 instanceof ，如果该表达式为true，则可以安全转换。

5. 抽象类

//图形类
class Shape {

    public void draw() {
        System.out.println("画图形");
    }
}
//圆形类
class Circle extends Shape{
    @Override
    public void draw() {
        System.out.println("⚪");
    }
}
//菱形类
class Rhombus extends Shape{
    @Override
    public void draw() {
        System.out.println("◆");
    }
}
//三角形类
class Triangle extends Shape {
    @Override
    public void draw() {
        System.out.println("🔺");
    }
}
public class Test1 {
    
    public static void draw(Shape shape) {
        shape.draw();
    }
    public static void main(String[] args) {
        Shape circle = new Circle();
        Shape rhombus = new Rhombus();
        Shape triangle = new Triangle();
        draw(circle );
        draw(rhombus);
        draw(triangle);
    }
}

当我们这么写时，那么父类中的draw方法中的东西是不是多余的，那么我们可不可以不写？

1. 抽象类概念

在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。

在打印图形例子中, 我们发现, 父类 Shape 中的 draw 方法好像并没有什么实际工作, 主要的绘制图形都是由 Shape的各种子类的 draw 方法来完成的. 像这种没有实际工作的方法, 我们可以把它设计成一个 抽像方法(abstract method), 包含抽象方法的类我们称为 抽象类(abstract class).

有了抽象类我们就可以由上面的父类中的方法变为下面的样子。

• 被 abstract 修饰的方法叫抽象类，方法被修饰后可以不写具体的操作。当然一个类中有了抽象方法后，这个类就必须定义成一个抽象类。

2. 抽象类不能进行实例化

3. 抽象类的成员变量和方法都是和普通类是一样的，只不过就是不能通过自身进行实例化了。

//图形类
abstract class Shape {
    public String name; //名字
    public double size; //大小

    public void method() {
        System.out.println("普通成员方法");
    }
    public static void method1() {
        System.out.println("静态成员方法");
    }
    //使用 abstract 修饰的方法叫抽象类，方法被修饰后可以不写具体的操作
    public abstract void draw();
}

4. 当一个类继承抽象类时，如果抽象类有抽象方法必须重写父类的所有抽象类方法

不重写报错

重写后没报错

5. 当抽象类 A 继承抽象类 B，抽象类 A 可以不重写抽象类 B 的抽象方法

抽象类继承抽象类，该子类抽象类可以不重写父类抽象类

6. 当一个普通类继承抽象类A,而抽象类A继承抽象类Shape,此时该普通类必须重写shape和A的抽象方法,不重写会报错

7. final不能修饰抽象类和抽象方法

final 和 abstract 是天敌，final 是使一个类不能被继承，而使用 abstract 抽象类 是为了使这个类被继承。

• 抽象类本身不能被实例化, 要想使用, 只能创建该抽象类的子类. 然后让子类重写抽象类中的抽象方法.
• 有些同学可能会说了, 普通的类也可以被继承呀, 普通的方法也可以被重写呀, 为啥非得用抽象类和抽象方法呢?
  确实如此， 但是使用抽象类相当于多了一重编译器的校验.

总结：使用抽象类的目的是对子类的一种校验。

如实际工作不应该由父类完成, 而应由子类完成.那么此时如果不小心误用成父类了, 使用普通类编译器是不会报错的,但是父类是抽象类就会在实例化的时候提示错误, 让我们尽早发现问题。

好的，到这里本章节就结束了，如发现有错误，请各位大佬及时指出。