什么是多态?

简介: 什么是多态?

@TOC

一、多态是什么?

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

二、多态的必要条件

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.
在这里插入图片描述
在这里插入图片描述

结论: "用尽量简单的方式使对象进入可工作状态", 尽量不要在构造器中调用方法(如果这个方法被子类重写, 就会触发动态绑定, 但是此时子类对象还没构造完成), 可能会出现一些隐藏的但是又极难发现的问题.
目录
相关文章
|
7月前
|
C++
c++多态
c++多态
54 0
|
6月前
|
编译器 C++ p3c
【c++】多态
【c++】多态
26 0
什么是多态?
什么是多态?
57 0
|
7月前
|
C++
|
7月前
|
存储 编译器 C++
|
7月前
|
编译器 C++
【C++】:多态
【C++】:多态
61 0
|
存储 设计模式 编译器
多态【C++】
多态【C++】
66 0
|
大数据 编译器 C++
|
Java
多态理解
多态理解
42 0
|
编译器
多态的初识
多态的初识