一、多态是什么？

多态是同一个行为具有多个不同表现形式或形态的能力。
多态就是同一个接口，使用不同的实例而执行不同操作，如图所示：

二、多态的必要条件

2.1 初始多态

要实现多态，以下三大条件缺一不可:

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

class Shape {
    void draw() {

    }
}
class Square extends Shape {
    @Override
    void draw() {
        System.out.println("画Square!");
    }
}
class Circle extends Shape {
    @Override
    void draw() {
        System.out.println("画Circle!");
    }
}
class Triangle extends Shape {
    @Override
    void draw() {
        System.out.println("画Triangle!");
    }
}
public class Test {
    public static void draw(Shape shape) {
        shape.draw();
    }
    public static void main(String[] args) {
        Circle circle = new Circle();
        Square square = new Square();
        draw(circle);
        draw(square);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

在这里实现了同一个方法同一引用，因为传入对象的不同，产生了不同的效果，这种不同的体现就是多态的体现.

2.2 多态的优缺点

优点:

1. 消除类型之间的耦合关系
2. 可替换性
3. 可扩充性
4. 接口性
5. 灵活性
6. 简化性

缺点:
1.属性没有多态性
当父类和子类属性同名时，只能访问父类的
2.构造方法没有多态性.

2.3 重写

重写(override)：也称为覆盖。重写是子类对父类非静态、非private修饰，非final修饰，非构造方法等的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。 也就是说子类能够根据需要实现父类的方法。

在重写的时候可以加上@Override关键字，系统会默认帮我们检查重写的方法是否正确，如果父类没有此类方法，就会编译报错.

对于已经投入使用的类，尽量不要进行修改。最好的方式是：重新定义一个新的类，来重复利用其中共性的内容，
并且添加或者改动新的内容。

静态绑定：也称为前期绑定(早绑定)，即在编译时，根据用户所传递实参类型就确定了具体调用那个方法。典型代表函数重载。
动态绑定：也称为后期绑定(晚绑定)，即在编译时，不能确定方法的行为，需要等到程序运行时，才能够确定具体调用那个类的方法。

三、转型

3.1 向上转型

Shape shape = new Circle();
1

向上转型就是new 一个子类对象，让父类对象来使用

class Animal {
    String neme;
    int age;

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

    public void eat(){

   }
}

class Cat extends Animal {
    public Cat(String neme, int age) {
        super(neme, age);
    }

    public void eat() {
        System.out.println("吃鱼");
    }
    public void work() {
        System.out.println("抓老鼠");
    }
}

class Dog extends Animal {
    public Dog(String neme, int age) {
        super(neme, age);
    }

    public void eat() {
        System.out.println("吃骨头");
    }
    public void work() {
        System.out.println("看家");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

1.直接赋值:

public static void main(String[] args) {
        Animal cat = new Cat("咪咪",18);//直接将子类对象赋值给父类对象
    }
1
2
3

2.方法传参:

public static void eat(Animal animal) {
        //方法传参:形参为父类引用，可以接受子类对象
        animal.eat();
    }
1
2
3
4

3.方法返回:

public static Animal reAnimal(String type) {
        //返回一个子类对象
        if("狗".equals(type)) {
            return new Dog("旺财",18);
        }else if("猫".equals(type)) {
            return new Cat("咪咪",18);
        }else {
            return null;
        }
    }
1
2
3
4
5
6
7
8
9
10

向上转型可以让代码变得更加简单灵活，但无法访问子类特有的属性方法.

3.2 向下转型

在进行向上转型后，无法调用子类的方法，但有时可能需要调用子类方法，此时在还原为子类对象，成为向下转型.

放下转型具有不安全性

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

public static void main(String[] args) {
        Animal animal = new Dog("旺财",18);
        if(animal instanceof Cat) {
            Cat cat = (Cat)animal;
        }
        else if(animal instanceof Dog) {
            Dog dog = (Dog)animal;
        }
    }
1
2
3
4
5
6
7
8
9

通过向下转型后就可以正常的调用子类方法.

3.3 避免在构造方法中调用重写方法.

class A {
    public A() {
        fun();
    }
    public void fun() {
        System.out.println("A:fun");
    }
}
class B extends A {
    int count = 10;

    @Override
    public void fun() {
        System.out.println("B:fun"+count);
    }

    public static void main(String[] args) {
        B b = new B();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

这样的代码会出现很多问题.它先执行父类的构造方法，然后在构造方法中执行子类的重写方法，但因为子类还没有执行构造方法,子类的属性还没有被加载，所以这里输出的count不是10，而是默认值0.

结论: “用尽量简单的方式使对象进入可工作状态”, 尽量不要在构造器中调用方法(如果这个方法被子类重写, 就会触发动态绑定, 但是此时子类对象还没构造完成), 可能会出现一些隐藏的但是又极难发现的问题.