【Java】面向对象三大特性之多态

日夜无休时

已于 2023-07-11 09:28:34 修改

阅读量93

点赞数 1

分类专栏： Java 文章标签： java jvm 开发语言

于 2023-05-24 18:47:43 首次发布

本文链接：https://blog.csdn.net/m0_73075027/article/details/130853187

版权

Java 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

多态

文章目录

多态

在开始讲多态之前，我们需要理解下述五点，才能理解什么是多态？

向上转型
子类和父类有同名的覆盖/重写方法
通过父类对象调用父类和子类的重写方法
满足以上三点只能说明会发生动态绑定
什么是动态绑定？什么是静态绑定？

在我看来只有理解好上述几点，才能理解什么是多态，其实多态就是一种思想，但是很抽象。

好吧，我们开始来啃面向对象三大特性之多态！

01.多态的基本概念

相信各位都看过西游记吧，孙悟空七十二变大神通以及猪悟能三十六变，都可以随心所欲的变成任何形态。只需要喊一声“变”。

那么在Java中呢，多态其实就是一种能力——同一个行为具有不同的表现形式；

换句话说就是，执行一段代码，Java 在运行时能根据对象的不同产生不同的结果。和孙悟空、猪悟能都只需要喊一声“变”，然后就变了，并且每次变得还不一样；一个道理。

通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态。

举个例子：猫和狗都需要吃饭，但是猫吃猫粮，狗吃狗粮，这样应该就很清晰了吧

02.多态的实现条件

在java中要实现多态，必须要满足如下几个条件，缺一不可：
1. 必须在继承体系下
2. 子类必须要对父类中方法进行重写
3. 通过父类的引用调用重写的方法
多态体现：在代码运行时，当传递不同类对象时，会调用对应类中的方法。

下面是多态的具体例子：

import java.util.Date;

/**
 * @author 刘浩彬
 * @date 2023/5/24
 */

public class demo {
    public static void main(String[] args) {
        // 编译器在编译代码时，并不知道要调用Dog 还是 Cat 中eat的方法
        // 等程序运行起来后，形参a引用的具体对象确定后，才知道调用那个方法
        // 注意：此处的形参类型必须时父类类型才可以
        Animal dog = new Dog();
        dog.eat();
        Animal cat = new Cat();
        cat.eat();
    }
}
class Animal {
    public void eat() {
        System.out.println("吃饭");
    }
}
class Dog extends Animal {
    public String name;
    public void bark() {
        System.out.println("汪汪汪！");
    }
}
class Cat extends Animal {
    public void miaow() {
        System.out.println("喵喵喵！");
    }
}

解析一段代码：

再看一个代码：

import java.util.Date;

/**
 * @author 刘浩彬
 * @date 2023/5/22
 */

class Animal{
    public String name;
    public int age;

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

    public void eat(){
        System.out.println(name+"正在吃饭！");
    }

    @Override
    public String toString() {
        return "Animal{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
//---------------------------------------------------------
class Dog extends Animal{
    public Dog(String name,int age){
        super(name, age);
    }

    public void wangWang(){
        System.out.println(name+"正在汪汪！");
    }

    //提示、警告的作用
@Override
    public void eat(){
        System.out.println(name+"正在吃狗粮！");
    }
}
//-----------------------------------------------------------
class Bird extends Animal{
    public Bird(String name, int age){
        super(name, age);
    }

    public void fly(){
        System.out.println(name+"正在飞！");
    }
}
//------------------------------------------------------------
public class testDemo {
public static void main1(String[] args) {
        Dog dog = new Dog("小狗",20);
        dog.eat();
        dog.wangWang();
        System.out.println("===================");
        Animal animal = new Animal("animal",10);
        animal.eat();
        //animal.wangWang(); --->  没有 /只能访问Animal这个类当中 自己的方法
    }
}
//-----------------------------------------------------------
/**
     * 向上转型有三种方式可以发生
     * 1.直接赋值
     * 2.方法传参的方式
     * 3.返回值
     * @param args
     */
public static void main2(String[] args) {
        //向上转型
        /**
         *  Dog dog = new Dog("小狗",20);
         *
         *         Animal animal = dog;
         */
        //父类引用 引用了子类对象
       Animal animal = new Dog("小狗",10);
       Animal animal2 = new Bird("小鸟",20);

       Dog dog = new Dog("小狗",10);
       Bird bird = new Bird("小鸟",20);

       func1(dog);
       func1(bird);

       Animal animal1 = func2();

       Animal animal3 = func3();
    }

    public static Animal func2(){
        /**
         * Bird bird = new Bird("小鸟"，10)；
         * return bird;
         */
        return new Bird("小鸟",20);
    }

    public static Bird func3() {
        return new Bird("小鸟",20);

    }

        public static void func1(Animal animal){

    }

前言

这部分属于父类、子类，主要解析的是几个main方法里面的内容。

main1：

在main1方法里面，animal.wangWang();会报错

在这里插入图片描述

因为在animal中，他只能访问Animal这个类当中自己的方法

main2：

在main2方法里面，我们会介绍一下向上转型，什么是向上转型呢？

简单来说，就是父类引用变量指向子类对象后，只能使用父类已声明的方法，但方法如果被重写会执行子类的方法，如果方法未被重写那么将执行父类的方法。

用一张图来解释的话：

向上转型中有三种情形可以发生：

//1.直接赋值
Animal animal = new Dog("小狗",10);
Animal animal2 = new Bird("小鸟",20);
//2.方法传参的方式
func1(dog);
func1(bird);
//3.返回值
Animal animal1 = func2();
Animal animal3 = func3();
//--------------------------------
public static Animal func2(){
        /**
         * Bird bird = new Bird("小鸟"，10)；
         * return bird;
         */
        return new Bird("小鸟",20);
    }

//这个不推荐写
public static Bird func3() {
        return new Bird("小鸟",20);

    }

public static void func1(Animal animal){

    }

那么讲到这里，我们对向上转型做一下总结吧。

03.向上转型

向上转型：实际就是创建一个子类对象，将其当成父类对象来使用。

语法：父类类型对象名 = new 子类类型()

例如：

Animal animal = new Dog(“小狗”,10);

animal是父类类型，但可以引用一个子类对象，因为是从小范围向大范围的转换。

总结一下向上转型的特点：

可以调用父类的所有成员，但是需要遵守权限。
不能调用子类特有的成员、方法。因为在编译阶段，能调用哪些成员是由编译类型决定的
最终运行效果看子类的具体表现，即调用时从子类开始查找方法，然后调用。

向上转型的优点：让代码实现更简单灵活。
向上转型的缺陷：不能调用到子类特有的方法。

那既然讲了向上转型，不妨我们也来了解什么是向下转型吧~

04.向下转型

通过父类对象(大范围)实例化子类对象(小范围)，在书写上父类对象需要加括号()强制转换为子类类型。但父类引用变量实际引用必须是子类对象才能成功转型，这里也用一张图就能很好表示向下转型的逻辑：

语法：子类类型引用名 = （子类类型）父类引用

例如： Cat cat = （Cat） animal；

向上转型是在堆上创建一个子类的对象把地址赋给了父类的引用

向下转型就是这个父类的引用把开辟的子类的空间的地址回到了子类的引用，所以可以使用子类独有的方法。

将一个子类对象经过向上转型之后当成父类方法使用，再无法调用子类的方法，但有时候可能需要调用子类特有的方法，此时：将父类引用再还原为子类对象即可，即向下转换。

package test_5_24.typoraNoteTest;

/**
 * @author 刘浩彬
 * @date 2023/5/24
 */
public class TestAnimal {
    public static void main(String[] args) {
        Cat cat = new Cat("元宝",2);
        Dog dog = new Dog("小七", 1);
// 向上转型
        Animal animal = cat;
        animal.eat();
        animal = dog;
        animal.eat();
// 编译失败，编译时编译器将animal当成Animal对象处理
// 而Animal类中没有bark方法，因此编译失败
// animal.bark();
// 向上转型
// 程序可以通过编程，但运行时抛出异常---因为：animal实际指向的是狗
// 现在要强制还原为猫，无法正常还原，运行时抛出：ClassCastException
        cat = (Cat)animal;
        cat.mew();
// animal本来指向的就是狗，因此将animal还原为狗也是安全的
        dog = (Dog)animal;
        dog.bark();
    }
}

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

public class TestAnimal {

        public static void main(String[] args) {
            Cat cat = new Cat("元宝",2);
            Dog dog = new Dog("小七", 1);
// 向上转型
            Animal animal = cat;
                    animal.eat();
            animal = dog;
            animal.eat();
            if(animal instanceof Cat){
                cat = (Cat)animal;
                cat.mew();
            }
            if(animal instanceof Dog){
                dog = (Dog)animal;
                dog.bark();
            }
        }
    }

那么这里是关于instanceof 关键词官方介绍：Chapter 15. Expressions

`instanceof`关键字详解

Java为我们提供了一个关键字instanceof,它可以帮助我们避免出现ClassCastException这样的异常，

格式：

变量名  instanceof   数据类型

解释：

如果变量属于该数据类型或者其子类型，返回true
如果变量不属于该数据类或者其子类型，返回false

直接拿启动项来进行说明，

代码示例如下：

public class DemoApplication {
 
    public static void main(String[] args) {
 
        //向上转型
        //父类类型 对象 = new 子类类型（）
        Animal animal = new Cat();
        
        //向下转型
        //子类类型 子类变量名 = （子类类型） 父类变量名
        if ( animal instanceof Cat){
            Cat cat = (Cat) animal;
            cat.sleep();
        }else if(animal instanceof Dog){
            Dog dog = (Dog) animal;
            dog.walk();
        }
 
    }
}

在进行了向上转型之后，在向下转型的过程中利用if语句来进行判断，而判断条件正是向上转型产生的变量与子类之间的关系

控制台打印输出：

Cat类独有的方法

好了，到这也就介绍完向下转型了，接下来我们可以针对上述的向上转型的缺陷中作为一个引子，来了解了解方法重写。

05.方法重写

首先，我们可以通过下面代码来验证这句话向上转型的缺陷：不能调用到子类特有的方法。

class Animal{
    public String name;
    public int age;

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

    public void eat(){
        System.out.println(name+"正在吃饭！");
    }

    @Override
    public String toString() {
        return "Animal{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
//---------------------------------------------------------
class Dog extends Animal{
    public Dog(String name,int age){
        super(name, age);
    }

    public void wangWang(){
        System.out.println(name+"正在汪汪！");
    }

}

public class demo1 {

    public static void main(String[] args) {
        Animal animal1 = new Dog("小狗",10);
        animal1.eat();
    }
}

此时的运行结果为：

那当我们在Dog子类中添加这一串代码

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

    public void wangWang(){
        System.out.println(name+"正在汪汪！");
    }
-----------------------------------------------------
    //提示、警告的作用
    @Override
    public void eat(){
        System.out.println(name+"正在吃狗粮！");
    }
}

我们再来看看运行结果：

那为什么会出现这种情况呢？父类中的eat和子类中的eat有什么区别呢？

我们可以清晰地看到，这两者之间构成的关系是方法重写。

重写的介绍

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

我的理解，用比较通俗的话来说，Animal（父类）中都会有move()，但是Dog（子类）、Bird（子类）它们的移动方式各有特点，所以就需要重写。

重写的方法和被重写的方法，不仅方法名相同，参数也相同，只不过，方法体有所不同。

那么根据上面的例子，我们可以总结：

方法重写（覆盖、覆写）的规定

方法名必须相同
参数列表必须相同（类型、个数、顺序）
返回值必须相同

重写注意事项

被private修饰的方法不能重写

//我们将父类中的public void eat -> private void eat时会出现下面情况
被static修饰的方法不能进行重写

//我们将父类中的public void eat -> public static void eat时会出现下面情况
被final修饰的方法不能进行重写，有些书上会将其叫做密封方法

//我们将父类中的public void eat -> public final void eat时会出现下面情况
访问修饰限定符 private < 默认权限 < protected < public
方法返回值之前可以不同，但是必须是父子类关系，有些书叫做【协变类型】
构造方法不能发生重写

这其中我们可以用到@Override注释，作用是提示警告。

面试题

重写和重载的区别？

区别点	重载	重写
参数列表	必须修改	一定不能修改
返回类型	可以修改	一定不能修改
访问限定符	可以修改	一定不能做更严格的限制（可以降低限制）

方法的重载和重写都是实现多态的方式，区别在于前者实现的是编译时的多态性，而后者实现的是运行时的多态性。重载发生在一个类中，同名的方法如果有不同的参数列表（参数类型不同、参数个数不同或者二者都不同）则视为重载；重写发生在子类与父类之间，重写要求子类被重写方法与父类被重写方法有相同的参数列表，有兼容的返回类型，比父类被重写方法更好访问，不能比父类被重写方法声明更多的异常（里氏代换原则）。重载对返回类型没有特殊的要求，不能根据返回类型进行区分。

【重写的设计原则】

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

例如：若干年前的手机，只能打电话，发短信，来电显示只能显示号码，而今天的手机在来电显示的时候，不仅仅可以显示号码，还可以显示头像，地区等。在这个过程当中，我们不应该在原来老的类上进行修改，因为原来的类，可能还在有用户使用，正确做法是：新建一个新手机的类，对来电显示这个方法重写就好了，这样就达到了我们当今的需求了。

接下来我们来分析一下main方法中的这串代码

public static void main(String[] args) {
        Animal animal1 = new Dog("小狗",10);
        animal1.eat();
    }

其实上述的运行时绑定，也就是人们常说的多态的基础。

那么下面，我们就来介绍一下动态绑定以及静态绑定。

06.动态绑定、静态绑定

我们根据上面的代码，在其汇编语言中来分析

静态绑定：也称为前期绑定(早绑定)，即在编译时，根据用户所传递实参类型就确定了具体调用那个方法。典型代表函数重载。

动态绑定：也称为后期绑定(晚绑定)，即在编译时，不能确定方法的行为，需要等到程序运行时，才能够确定具体调用那个类的方法。

多态的优缺点

我们先引入这么一段代码

class Shape {
    //属性....
    public void draw() {
        System.out.println("画图形！");
    }
}
class Rect extends Shape{
    @Override
    public void draw() {
        System.out.println("♦");
    }
}
class Cycle extends Shape{
    @Override
    public void draw() {
        System.out.println("●");
    }
}
class Flower extends Shape{
    @Override
    public void draw() {
        System.out.println("❀");
    }
}

【使用多态的好处】

能够降低代码的 “圈复杂度”, 避免使用大量的 if - else

例如我们现在需要打印的不是一个形状了, 而是多个形状. 如果不基于多态, 实现代码如下：

public static void drawShapes() {
        Rect rect = new Rect();
        Cycle cycle = new Cycle();
        Flower flower = new Flower();
        String[] shapes = {"cycle", "rect", "cycle", "rect", "flower"};
        for (String shape : shapes) {
            if (shape.equals("cycle")) {
                cycle.draw();
            } else if (shape.equals("rect")) {
                rect.draw();
            } else if (shape.equals("flower")) {
                flower.draw();
            }
        }
    }

如果使用使用多态, 则不必写这么多的 if - else 分支语句, 代码更简单

public static void drawShapes() {
// 我们创建了一个 Shape 对象的数组.
    Shape[] shapes = {new Cycle(), new Rect(), new Cycle(),
    new Rect(), new Flower()};
    //遍历
    for (Shape shape : shapes) {
    shape.draw();
    }
}

可扩展能力更强
如果要新增一种新的形状, 使用多态的方式代码改动成本也比较低.

class Triangle extends Shape {
    @Override
    public void draw() {
    System.out.println("△");
    }
}

对于类的调用者来说(drawShapes方法), 只要创建一个新类的实例就可以了, 改动成本很低.
而对于不用多态的情况, 就要把 drawShapes 中的 if - else 进行一定的修改, 改动成本更高.

多态缺陷：

代码的运行效率降低。

属性没有多态性
当父类和子类都有同名属性的时候，通过父类引用，只能引用父类自己的成员属性
构造方法没有多态性

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

一段有坑的代码. 我们创建两个类, B 是父类, D 是子类. D 中重写 func 方法. 并且在 B 的构造方法中调用 func

class B {
  public B() {
    // do nothing
    func();
}

public void func() {
  System.out.println("B.func()");
  }
}

class D extends B {
  private int num = 1;

  @Override
  public void func() {
  System.out.println("D.func() " + num);

  }

}

public class Test {
  public static void main(String[] args) {
  D d = new D();
  }

}

// 执行结果
D.func() 0

构造 D 对象的同时, 会调用 B 的构造方法.

B 的构造方法中调用了 func 方法, 此时会触发动态绑定, 会调用到 D 中的 func

此时 D 对象自身还没有构造, 此时 num 处在未初始化的状态, 值为 0.

结论"用尽量简单的方式使对象进入可工作状态", 尽量不要在构造器中调用方法(如果这个方法被子类重写, 就会触

发动态绑定, 但是此时子类对象还没构造完成), 可能会出现一些隐藏的但是又极难发现的问题.

好了，到此为止， Java 的三大特性，封装继承多态全部介绍完了，后续我会将其汇总重新把他们梳理一下。