文章目录

• 一、多态是什么？
• 二、多态的必要条件
• • 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 {    @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);    }}

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

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;    @Override    public void fun() {        System.out.println("B:fun"+count);    }    public static void main(String[] args) {        B b = new B();    }}

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

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

来源地址：https://blog.csdn.net/buhuisuanfa/article/details/126328356