Java (多态)

前沿

多态：通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象

去完成时会产生出不同的状态。同一种行为，不同的子类呈现出来的状态是不

同的。

PS：多态跟属性无关，多态指的是方法的多态，而不是属性的多态

 

多态（Polymorphism）是面向对象编程（OOP）的一个基本概念，
它允许对象以不同的形式表现自己。在 Java 中，多态分为两种：编译时多态（静态多态）和运行时多态（动态多态）。

1. 编译时多态（静态多态）：

   • 通过方法重载（Overloading）实现。
   • 方法重载是指在同一个类中，多个方法具有相同的名称但参数列表不同。
   • 编译时多态在编译时确定调用哪个方法。

2. 运行时多态（动态多态）：

   • 通过方法重写（Overriding）和接口实现实现。
   • 方法重写是指子类重写父类的方法。
   • 运行时多态在运行时通过动态绑定（Dynamic Binding）决定调用哪个方法。

多态的核心是对象的实际类型在运行时确定，而不是在编译时。这使得代码更加灵活和可扩展。

 

编译时多态示例

class MathUtils {
    // 方法重载：相同的方法名，不同的参数列表
    public int add(int a, int b) {
        return a + b;
    }

    public double add(double a, double b) {
        return a + b;
    }

    public int add(int a, int b, int c) {
        return a + b + c;
    }
}

public class Main {
    public static void main(String[] args) {
        MathUtils utils = new MathUtils();

        System.out.println(utils.add(2, 3));          // 输出 5
        System.out.println(utils.add(2.5, 3.5));      // 输出 6.0
        System.out.println(utils.add(1, 2, 3));       // 输出 6
    }
}

运行时多态示例

// 父类
class Animal {
    public void makeSound() {
        System.out.println("Animal makes a sound");
    }
}

// 子类
class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Dog barks");
    }
}

class Cat extends Animal {
    @Override
    // 方法重新写 不满意父类的方法自己写
    public void makeSound() {
        System.out.println("Cat meows");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal myDog = new Dog();  // 使用父类引用指向子类对象
        Animal myCat = new Cat();  // 使用父类引用指向子类对象

        myDog.makeSound();  // 输出 Dog barks
        myCat.makeSound();  // 输出 Cat meows
    }
}

接口实现的多态

// 接口
interface Shape {
    void draw();
}

// 实现接口的类
class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a circle");
    }
}

class Rectangle implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a rectangle");
    }
}

public class Main {
    public static void main(String[] args) {
        Shape myCircle = new Circle();
        Shape myRectangle = new Rectangle();

        myCircle.draw();        // 输出 Drawing a circle
        myRectangle.draw();     // 输出 Drawing a rectangle
    }
}

运行时多态的好处

代码可扩展性：可以轻松扩展新类而不修改现有代码。
代码可维护性：方法调用和实际执行的代码相分离，易于维护。
接口驱动设计：通过接口编程而不是具体实现，可以降低代码的耦合度。