什么是多态?-编程学习网

在这里插入图片描述

文章目录

一、多态是什么？
二、多态的必要条件
三、转型

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

2.1 初始多态

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

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

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.构造方法没有多态性.

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