Java多态：多态多态，多种形态

• 👑专栏内容：Java
• ⛪个人主页：子夜的星的主页
• 💕座右铭：前路未远，步履不停

---

---

嗨！在学习Java的继承之后，让我们进一步深入了解多态的概念吧。多态多态，多么变态。哦不，多态，多态，多种形态。

在继承的基础上，多态通过允许一个对象以多种形态呈现，使得我们可以使用父类的引用来引用子类的对象。这样一来，同样的方法调用可能会在不同的对象上产生不同的行为，具体执行的方法取决于实际对象的类型。通过多态，我们可以编写更加通用、灵活的代码，减少重复性的工作，并且更容易适应未来的需求变化。在实践中，多态常常与抽象类和接口一起使用，以达到更高的代码可复用性和扩展性。

让我们一起深入学习多态的原理和应用，进一步提升我们在Java编程中的技能吧！

一、重写

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

1、重写的规则

● 子类在重写父类的方法时，一般必须与父类方法原型一致： 返回值类型 方法名 (参数列表) 要完全一致
● 被重写的方法返回值类型可以不同，但是必须是具有父子关系的
● 访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类方法被public修饰，则子类中重写该方法就不能声明为 protected
● 父类被static、private修饰的方法、构造方法都不能被重写。
● 重写的方法, 可以使用 @Override 注解来显式指定。有了这个注解能帮我们进行一些合法性校验。例如不小心将方法名字拼写错了 (比如写成aet)，那么此时编译器就会发现父类中没有 aet 方法，就会编译报错，提示无法构成重写。

2、重写与重载的区别

方法重载是一个类的多态性表现，而方法重写是子类与父类的一种多态性表现。

特点	重写（Override）	重载（Overload）
参数列表	一定不能修改	必须修改
返回类型	一定不能修改（除非可以构成父子类关系）	可以修改
访问限定符	一定不能做更严格的限制（可以降低限制）	可以修改

二、多态

1、多态的概念

多态，多态，多种形态。具体点说就是，当不同的对象被用于执行某个特定行为时，由于它们具有不同的实现，这将导致产生不同的状态。 简单点说就是，同一件事情，发生在不同对象身上，就会产生不同的结果。

我们可以举个举个简单的例子，同样是动物吃饭这个动作。对于小猫来说，就是吃猫粮，对于小狗来说，就是吃狗粮。

2、多态的实现

在Java中要实现多态，必须要满足如下几个条件，缺一不可：

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

多态体现：在代码运行时，当传递不同类对象时，会调用对应类中的方法。

public class Animal { // 定义动物类
  String name; // 动物名
  int age; // 年龄

  public Animal(String name, int age){ // 构造方法，传入动物名和年龄
    this.name = name;
    this.age = age;
  }

  public void eat(){ // 动物吃饭方法
    System.out.println(name + "吃饭");
  }
}

public class Cat extends Animal{ // 猫类继承于动物类
  public Cat(String name, int age){ // 构造方法，传入猫名和年龄，并调用父类的构造方法
    super(name, age);
  }

  @Override // 重写父类的吃饭方法
  public void eat(){
    System.out.println(name+"吃鱼~~~");
  }
}

public class Dog extends Animal { // 狗类继承于动物类
  public Dog(String name, int age){ // 构造方法，传入狗名和年龄，并调用父类的构造方法
    super(name, age);
  }

  @Override // 重写父类的吃饭方法
  public void eat(){
    System.out.println(name+"吃骨头~~~");
  }
}

public class Main {
    // 定义一个静态方法,接收 Animal 类型的形参
    // 编译时并不知道形参引用的具体子类对象，只有运行时才知道
    // 形参类型必须是 Animal，因为 Cat 和 Dog 都是 Animal 的子类
    public static void eat (Animal animal){
        animal.eat();
    }
    // 调用 Animal 类中的 eat 方法，此处的 eat 方法被定义为了 abstract，子类必须实现它
    // 编译时使用形参类型，运行时使用具体对象类型
    public static void main(String[] args) {
    // 创建 Cat 和 Dog 的实例
        Cat cat = new Cat("来福",3);
        Dog dog = new Dog("旺财",9);
    // 调用 eat 方法传入 Cat 和 Dog 类型的实例
    // 编译时根据传入的实例类型推断调用哪个 eat 方法，运行时再调用具体的 eat 方法
        eat(cat);
        eat(dog);
    }
}

3、向上转移和向下转型

Ⅰ、向上转型

向上转型是指将一个子类类型的对象引用赋值给一个父类类型的引用变量。这种转型可以在继承关系中进行，其中子类是父类的一个特殊类型。通过向上转型，你可以使用父类的引用来引用子类的对象，从而以一种通用的方式处理不同类型的对象。

简单点说，就是创建一个子类对象，将其当成父类对象来使用。其语法格式：父类类型 对象名 = new 子类类型()

例如：

Animal animal = new Cat("元宝",2);

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

使用场景：直接赋值、方法传参、方法返回

public class TestAnimal {
    // 2. 方法传参：形参为父类型引用，可以接收任意子类的对象
    public static void eatFood(Animal a){
    	a.eat();
    }
    // 3. 作返回值：返回任意子类对象
    public static Animal buyAnimal(String var){
    if("狗".equals(var) ){
    	return new Dog("狗狗",1);
    }else if("猫" .equals(var)){
    	return new Cat("猫猫", 1);
    }else{
    	return null;
    	}
    }
    public static void main(String[] args) {
        Animal cat = new Cat("元宝",2); // 1. 直接赋值：子类对象赋值给父类对象
        Dog dog = new Dog("小七", 1);
        
        eatFood(cat);
        eatFood(dog);
        
        Animal animal = buyAnimal("狗");
        animal.eat();
        
        animal = buyAnimal("猫");
        animal.eat();
    }
}

向上转型的优点：让代码实现更简单灵活。

向上转型的缺陷：不能调用到子类特有的方法。

Ⅱ、向下转型

向下转型是指将一个父类类型的对象引用转换为一个子类类型的引用。这种转型通常在已经进行了向上转型后，需要重新获取原始子类类型的引用时使用。向下转型通常在以下场景中使用：

• 已经进行了向上转型，需要再次使用原始子类的特定方法。
• 在某些情况下，需要访问子类特有的属性或方法。

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

4、多态的优缺点

Ⅰ、多态的优点

多态最大的优点就是，能够降低代码的“圈复杂度”避免使用大量的 if - else。

什么叫 “圈复杂度” ?

圈复杂度是一种描述一段代码复杂程度的方式。 一段代码如果平铺直叙, 那么就比较简单容易理解。而如果有很多的条件分支或者循环语句，就认为理解起来更复杂，因此我们可以简单粗暴的计算一段代码中条件语句和循环语句出现的个数, 这个个数就称为"圈复杂度".如果一个方法的圈复杂度太高, 就需要考虑重构，不同公司对于代码的圈复杂度的规范不一样，一般不会超过 10

例如我们现在需要打印多个形状，如果不基于多态实现代码如下：

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

Ⅱ、多态的缺点

代码运行效率降低，多态性可能引入性能开销，因为在运行时需要进行动态绑定。相比于直接调用一个已知的方法，通过父类引用调用子类对象的方法可能会更加耗时。

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