Java中的多态详解：从入门到精通

一、多态的基本概念

多态是面向对象编程的核心概念之一，它允许不同的对象对同一消息做出响应。在Java中，多态通过方法重写（Override）实现，允许子类提供与父类方法同名但实现不同的方法。

（一）多态的定义与特点

多态允许父类的引用指向子类的对象，通过父类的引用调用子类的方法。这种机制提高了代码的灵活性和扩展性。

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

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

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

public class PolymorphismExample {
    public static void main(String[] args) {
        Animal dog = new Dog();
        Animal cat = new Cat();

        dog.makeSound(); // 输出：Dog barks
        cat.makeSound(); // 输出：Cat meows
    }
}

（二）多态的优势

• 代码复用：通过多态，可以编写通用的代码，减少重复。
• 扩展性：可以轻松添加新的子类，而无需修改现有代码。
• 灵活性：允许在运行时决定调用哪个方法，提高代码的动态性。

二、多态的实现机制

（一）方法重写（Override）

方法重写是多态实现的基础。子类通过重写父类的方法，提供特定的实现。

class Parent {
    void display() {
        System.out.println("Parent class method");
    }
}

class Child extends Parent {
    @Override
    void display() {
        System.out.println("Child class method");
    }
}

public class OverrideExample {
    public static void main(String[] args) {
        Parent obj1 = new Parent();
        Parent obj2 = new Child();

        obj1.display(); // 输出：Parent class method
        obj2.display(); // 输出：Child class method
    }
}

（二）接口与多态

接口是多态的另一种实现方式。一个类可以实现多个接口，通过接口引用调用实现类的方法。

interface Drawable {
    void draw();
}

class Circle implements Drawable {
    @Override
    public void draw() {
        System.out.println("Drawing a circle");
    }
}

class Square implements Drawable {
    @Override
    public void draw() {
        System.out.println("Drawing a square");
    }
}

public class InterfacePolymorphismExample {
    public static void main(String[] args) {
        Drawable[] shapes = {new Circle(), new Square()};

        for (Drawable shape : shapes) {
            shape.draw();
        }
    }
}

（三）抽象类与多态

抽象类提供了多态的另一种实现方式。抽象类中的抽象方法必须由子类实现，通过多态调用这些方法。

abstract class Vehicle {
    abstract void start();
}

class Car extends Vehicle {
    @Override
    void start() {
        System.out.println("Car engine started");
    }
}

class Bike extends Vehicle {
    @Override
    void start() {
        System.out.println("Bike engine started");
    }
}

public class AbstractClassPolymorphismExample {
    public static void main(String[] args) {
        Vehicle vehicle1 = new Car();
        Vehicle vehicle2 = new Bike();

        vehicle1.start(); // 输出：Car engine started
        vehicle2.start(); // 输出：Bike engine started
    }
}

三、多态的高级应用

（一）组合与继承

多态可以与组合和继承结合使用，创建灵活的设计模式。

class Engine {
    void start() {
        System.out.println("Engine started");
    }
}

class Car {
    private Engine engine;

    public Car() {
        engine = new Engine();
    }

    void startCar() {
        engine.start();
        System.out.println("Car is moving");
    }
}

public class CompositionExample {
    public static void main(String[] args) {
        Car myCar = new Car();
        myCar.startCar();
    }
}

（二）策略模式

策略模式是一种行为设计模式，它允许在运行时选择算法或行为。多态是实现策略模式的关键。

interface PaymentStrategy {
    void pay(int amount);
}

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

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

class ShoppingCart {
    private List<Item> items;
    private PaymentStrategy paymentStrategy;

    public void setPaymentStrategy(PaymentStrategy paymentStrategy) {
        this.paymentStrategy = paymentStrategy;
    }

    public void checkout() {
        int totalAmount = calculateTotal();
        paymentStrategy.pay(totalAmount);
    }

    private int calculateTotal() {
        // 计算购物车中所有商品的总价
        return 100;
    }
}

public class StrategyPatternExample {
    public static void main(String[] args) {
        ShoppingCart cart = new ShoppingCart();
        cart.setPaymentStrategy(new CreditCardPayment());
        cart.checkout(); // 输出：Paid 100 using Credit Card.

        cart.setPaymentStrategy(new PayPalPayment());
        cart.checkout(); // 输出：Paid 100 using PayPal.
    }
}

四、总结

多态是Java编程中不可或缺的概念，它通过方法重写和接口实现，提供了代码的灵活性和扩展性。通过合理利用多态，可以设计出更加灵活、可维护和可扩展的系统。希望本文的示例和讲解对您有所帮助，如果您在使用多态时有任何疑问，欢迎随时交流探讨！