Java基础-多态

向阳花自开

已于 2024-08-13 13:54:40 修改

阅读量958

点赞数 10

分类专栏： Java学习文章标签： java 开发语言多态

于 2024-08-13 13:50:34 首次发布

本文链接：https://blog.csdn.net/m0_55477902/article/details/141162063

版权

Java学习专栏收录该内容

5 篇文章 0 订阅

订阅专栏

Java 中的多态是面向对象编程（OOP）的一个核心概念，它允许对象以不同的形式表现。用通俗易懂的话来说，多态就像是一种“多种形态的能力”。

例子：

想象一下，动物类（Animal）是一个父类，而猫（Cat）和狗（Dog）是动物的子类。现在，虽然猫和狗都是动物，但它们的行为方式不同，比如叫声不同（猫“喵喵叫”，狗“汪汪叫”）。通过多态，我们可以创建一个动物的变量，然后在运行时决定它是猫还是狗，并调用相应的叫声方法。

代码示例：

class Animal {
    void makeSound() {
        System.out.println("Some generic animal sound");
    }
}

class Cat extends Animal {
    @Override
    void makeSound() {
        System.out.println("Meow");
    }
}

class Dog extends Animal {
    @Override
    void makeSound() {
        System.out.println("Woof");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal myAnimal = new Dog(); // 这里创建的是一个狗，但类型是Animal
        myAnimal.makeSound(); // 输出: Woof

        myAnimal = new Cat(); // 这里创建的是一只猫，但类型仍然是Animal
        myAnimal.makeSound(); // 输出: Meow
    }
}

通俗解释：

在这个例子中，myAnimal 是一个动物类型的变量，但它可以代表不同的子类（猫或狗）。尽管它的类型是 Animal，但它在不同情况下可以表现出不同的行为（多态），即根据它实际的类型来调用对应的 makeSound() 方法。

多态的好处：

代码复用：可以编写更通用、更灵活的代码。
可扩展性：在不改变现有代码的情况下，添加新的子类时，只需实现特定的行为方法即可。
减少耦合：让代码更加模块化，减少了不同类之间的依赖。

总结来说，Java 的多态性让同一个对象在不同的上下文中展现出不同的行为，这使得程序更加灵活和易于维护。

更多典型多态案例

Java 多态是面向对象编程中的一个强大工具，它允许同一个方法在不同的对象上表现出不同的行为。以下是一些典型的 Java 多态例子：

1. 通过继承实现多态

例子：动物叫声

class Animal {
    void makeSound() {
        System.out.println("Some generic animal sound");
    }
}

class Cat extends Animal {
    @Override
    void makeSound() {
        System.out.println("Meow");
    }
}

class Dog extends Animal {
    @Override
    void makeSound() {
        System.out.println("Woof");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal myAnimal = new Dog();
        myAnimal.makeSound(); // 输出: Woof

        myAnimal = new Cat();
        myAnimal.makeSound(); // 输出: Meow
    }
}

解释：在这个例子中，虽然 myAnimal 是 Animal 类型的变量，但它可以引用 Dog 或 Cat 对象，并在运行时表现出不同的行为（不同的叫声）。

2. 通过接口实现多态

例子：支付系统

interface Payment {
    void pay(double amount);
}

class CreditCardPayment implements Payment {
    @Override
    public void pay(double amount) {
        System.out.println("Paid " + amount + " using Credit Card.");
    }
}

class PayPalPayment implements Payment {
    @Override
    public void pay(double amount) {
        System.out.println("Paid " + amount + " using PayPal.");
    }
}

public class Main {
    public static void main(String[] args) {
        Payment payment = new CreditCardPayment();
        payment.pay(100.00); // 输出: Paid 100.0 using Credit Card.

        payment = new PayPalPayment();
        payment.pay(200.00); // 输出: Paid 200.0 using PayPal.
    }
}

解释：这里的 Payment 接口定义了一个 pay() 方法，不同的支付方式（信用卡、PayPal）实现了这个接口。通过多态，payment 可以在不同的支付方式之间切换，而不需要修改调用代码。

3. 方法重载（编译时多态）

例子：不同方式的打印

class Printer {
    void print(String text) {
        System.out.println("Printing text: " + text);
    }

    void print(int number) {
        System.out.println("Printing number: " + number);
    }

    void print(double decimal) {
        System.out.println("Printing decimal: " + decimal);
    }
}

public class Main {
    public static void main(String[] args) {
        Printer printer = new Printer();
        printer.print("Hello World");  // 输出: Printing text: Hello World
        printer.print(123);            // 输出: Printing number: 123
        printer.print(45.67);          // 输出: Printing decimal: 45.67
    }
}

解释：这是方法重载的例子。虽然 print() 方法名字相同，但它可以根据不同的参数类型表现出不同的行为。这种形式的多态是在编译时决定的。

4. 方法重写（运行时多态）

例子：员工薪资计算

class Employee {
    double calculateSalary() {
        return 40000; // base salary
    }
}

class Manager extends Employee {
    @Override
    double calculateSalary() {
        return 60000; // manager's salary
    }
}

class Developer extends Employee {
    @Override
    double calculateSalary() {
        return 50000; // developer's salary
    }
}

public class Main {
    public static void main(String[] args) {
        Employee emp1 = new Manager();
        Employee emp2 = new Developer();

        System.out.println("Manager's Salary: " + emp1.calculateSalary()); // 输出: Manager's Salary: 60000
        System.out.println("Developer's Salary: " + emp2.calculateSalary()); // 输出: Developer's Salary: 50000
    }
}

解释：在这个例子中，calculateSalary() 方法在 Manager 和 Developer 类中被重写，因此当我们调用 emp1 和 emp2 的 calculateSalary() 方法时，它们表现出了不同的行为。

5. 通过抽象类实现多态

例子：几何图形面积计算

abstract class Shape {
    abstract double calculateArea();
}

class Circle extends Shape {
    private double radius;

    Circle(double radius) {
        this.radius = radius;
    }

    @Override
    double calculateArea() {
        return Math.PI * radius * radius;
    }
}

class Rectangle extends Shape {
    private double length;
    private double width;

    Rectangle(double length, double width) {
        this.length = length;
        this.width = width;
    }

    @Override
    double calculateArea() {
        return length * width;
    }
}

public class Main {
    public static void main(String[] args) {
        Shape shape1 = new Circle(5.0);
        Shape shape2 = new Rectangle(4.0, 6.0);

        System.out.println("Area of Circle: " + shape1.calculateArea()); // 输出: Area of Circle: 78.54
        System.out.println("Area of Rectangle: " + shape2.calculateArea()); // 输出: Area of Rectangle: 24.0
    }
}