文章目录

• 一、多态是什么？
• 二、多态的必要条件
• • 2.1 初始多态
  • 2.2 多态的优缺点
  • 2.3 重写
• 三、转型
• • 3.1 向上转型
  • 3.2 向下转型
  • 3.3 避免在构造方法中调用重写方法.

一、多态是什么？

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

二、多态的必要条件

2.1 初始多态

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

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

class Shape {void draw() {}}class Square extends Shape {@Overridevoid draw() {System.out.println("画Square!");}}class Circle extends Shape {@Overridevoid draw() {System.out.println("画Circle!");}}class Triangle extends Shape {@Overridevoid 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);}}

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

2.2 多态的优缺点

优点:

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

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

2.3 重写

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

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

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

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

三、转型

3.1 向上转型

Shape shape = new Circle();

向上转型就是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.直接赋值:

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

2.方法传参:

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

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;}}

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

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;}}

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

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

class A {public A() {fun();}public void fun() {System.out.println("A:fun");}}class B extends A {int count = 10;@Overridepublic void fun() {System.out.println("B:fun"+count);}public static void main(String[] args) {B b = new B();}}

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

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