---

前言

当你翻看相关书籍，看到多态的描述：就是多种形态，通俗点就是去完成某个行为，当不同对象去完成时会产生不同的状态。？？？？对于初学者得你可能会问这是圣魔？？接下来我问用一个宠物点的例子，说明白啥事多态，直接发车~~

---

一、多态是什么？

这两个方法

• 方法名一样
• 参数一样（数据类型 个数 顺序 ）
• 返回值相同
  这就构成的重写（重载的参数不相同）
  

重写的访问修饰限定符的权限限制

• public > protected > 包 >private
• 子类当前方法的限定符 >=父类的
• 被private，static，final修饰的成员不能被重写

二、 向上转型和向下转型

向上转型

实际就是创建⼀个⼦类对象，将其当成⽗类对象来使用。
语法格式：

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

• 直接赋值

public static void main(String[] args) { 
        //向上转型
        //直接赋值即可
        Animal animal = new Dog("旺财", 2);
        Animal animal1 = new Cat("胖咪", 3);
    }

• 参数传递

public static void func(Animal animal) {
        animal.eat();
    }
    
    public static void main(String[] args) {
        Dog dog = new Dog("旺财", 2);
        func(dog);
    }

• 返回值

/**
     * 创建一个新的Animal对象并返回。
     *
     * @return 一个新的Animal对象，其中名字为"旺财"，年龄为2。
     */
    public static Animal func2() {
   
        return new Animal("旺财", 2);
    }

动态绑定

• 在 Java 中，动态绑定（Dynamic Binding） 又称运行时绑定，是面向对象编程中多态性的核心机制之一。它指的是：程序在运行时才确定要调用的方法具体实现，而非在编译阶段。

多态的本质

• 多态的本质是：通过统一的接口（父类方法），实现不同对象的个性化行为。它让程序能像现实世界一样，用 “通用的动作” 应对 “多样的个体”，是面向对象编程中实现灵活设计的核心手段。理解多态的关键，就是记住那句通俗的话：
• “同一个方法，引用不同对象，不同结果”。
  
• 在代码中，多态主要通过 “父类引用指向子类对象”+“方法重写” 实现，具体表现为：
• 声明一个父类类型的变量，却可以指向它的任意子类对象；
• 调用这个变量的方法时，实际执行的是子类重写后的方法（而非父类的方法）。[在编译的时候是时无法确定方法的，只有在编译的时候才确定调用哪一个方法]

// 父类
class Animal {
    public void sound() {
        System.out.println("动物发出声音");
    }
}

// 子类1
class Dog extends Animal {
    @Override
    public void sound() { // 重写父类方法
        System.out.println("狗叫：汪汪");
    }
}

// 子类2
class Cat extends Animal {
    @Override
    public void sound() { // 重写父类方法
        System.out.println("猫叫：喵喵");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal animal1 = new Dog(); // 父类引用指向子类对象
        Animal animal2 = new Cat();
        
        animal1.sound(); // 运行时调用Dog的sound()，输出“狗叫：汪汪”
        animal2.sound(); // 运行时调用Cat的sound()，输出“猫叫：喵喵”
    }
}

向下转型

代码示例：

package demo731;

// 父类 Animal
class Animal {
    String name;
    int age;

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

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

    // Dog 特有的方法
    public void bark() {
        System.out.println(name + " (Dog) 汪汪叫！");
    }
}

// 子类 Cat
class Cat extends Animal {
    public Cat(String name, int age) {
        super(name, age);
    }

    // Cat 特有的方法
    public void meow() {
        System.out.println(name + " (Cat) 喵喵叫！");
    }
}

// 测试类
public class test2025731 {
    public static void main(String[] args) {
        // 父类引用指向 Dog 对象
        Animal a1 = new Dog("dog", 3); 

        // 向上转型（安全，Dog 是 Animal 的子类）
        Dog d1 = (Dog) a1;
        d1.bark(); // 输出: dog (Dog) 汪汪叫！

        System.out.println("==========");

        // 错误：向下转型，a1 实际是 Dog，无法转成 Cat
        Cat c1 = (Cat) a1; // 运行时抛出 ClassCastException
        c1.meow();
    }
}

• 向下转型⽤的⽐较少，⽽且不安全，万⼀转换失败，运⾏时就会抛异常。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();
}

多态的优缺点

• 多态的核心价值在于**通过抽象提升代码的灵活性和扩展性，是大型系统设计中不可或缺的特性。**但其缺点也提醒我们：需避免过度设计，保持类层次简洁，同时在调试和维护时关注实际运行时的类型逻辑。合理使用多态（结合封装和继承），能在 “灵活性” 与 “可维护性” 之间找到平衡。
  数据
  代码如下（示例）：

总结

如有问题，欢迎指正，共同进步！！

• 我是Dylan,下期见~