Java Subclass 子类设计模式应用

在Java中，子类（Subclass）是面向对象编程的一个重要概念，它允许我们基于已有的类（父类或超类）创建一个新的类，从而继承父类的属性和方法。子类可以添加新的属性和方法，也可以重写（Override）父类的方法以实现不同的功能。这种设计模式在Java中非常常见，因为它提供了代码复用和扩展性的优势。

以下是一些常见的子类设计模式应用：

1. 继承与扩展

子类可以继承父类的所有非私有属性和方法，并且可以添加新的属性和方法，或者重写父类的方法。

class Animal {
    void eat() {
        System.out.println("Eating...");
    }
}

class Dog extends Animal {
    void bark() {
        System.out.println("Barking...");
    }

    @Override
    void eat() {
        System.out.println("Dog is eating...");
    }
}

2. 模板方法模式

模板方法模式是一种行为设计模式，它定义了一个算法的骨架，但将一些步骤延迟到子类中实现。

abstract class AbstractClass {
    final void templateMethod() {
        primitiveOperation1();
        concreteOperation();
        primitiveOperation2();
    }

    abstract void primitiveOperation1();
    abstract void concreteOperation();
    void primitiveOperation2() {
        System.out.println("Default implementation");
    }
}

class ConcreteClass extends AbstractClass {
    @Override
    void primitiveOperation1() {
        System.out.println("ConcreteClass: Primitive Operation 1");
    }

    @Override
    void concreteOperation() {
        System.out.println("ConcreteClass: Concrete Operation");
    }
}

3. 策略模式

策略模式是一种行为设计模式，它定义了一系列算法，并将每个算法封装起来，使它们可以互换。

interface Strategy {
    void execute();
}

class ConcreteStrategyA implements Strategy {
    @Override
    public void execute() {
        System.out.println("Executing strategy A");
    }
}

class ConcreteStrategyB implements Strategy {
    @Override
    public void execute() {
        System.out.println("Executing strategy B");
    }
}

class Context {
    private Strategy strategy;

    public void setStrategy(Strategy strategy) {
        this.strategy = strategy;
    }

    public void executeStrategy() {
        strategy.execute();
    }
}

4. 装饰器模式

装饰器模式是一种结构设计模式，它允许你通过将对象放入包含行为的特殊封装对象中来为原对象绑定新的行为。

interface Component {
    void operation();
}

class ConcreteComponent implements Component {
    @Override
    public void operation() {
        System.out.println("ConcreteComponent operation");
    }
}

class Decorator implements Component {
    private Component component;

    public Decorator(Component component) {
        this.component = component;
    }

    @Override
    public void operation() {
        component.operation();
    }
}

class ConcreteDecoratorA extends Decorator {
    public ConcreteDecoratorA(Component component) {
        super(component);
    }

    @Override
    public void operation() {
        super.operation();
        addedBehavior();
    }

    private void addedBehavior() {
        System.out.println("Added behavior A");
    }
}

5. 工厂方法模式

工厂方法模式是一种创建型设计模式，它提供了一种创建对象的接口，但由子类决定实例化哪一个类。

interface Product {
    void use();
}

class ConcreteProductA implements Product {
    @Override
    public void use() {
        System.out.println("Using product A");
    }
}

class ConcreteProductB implements Product {
    @Override
    public void use() {
        System.out.println("Using product B");
    }
}

abstract class Creator {
    abstract Product factoryMethod();

    void someOperation() {
        Product product = factoryMethod();
        product.use();
    }
}

class ConcreteCreatorA extends Creator {
    @Override
    Product factoryMethod() {
        return new ConcreteProductA();
    }
}

class ConcreteCreatorB extends Creator {
    @Override
    Product factoryMethod() {
        return new ConcreteProductB();
    }
}

这些设计模式在Java中非常常见，并且在实际开发中有着广泛的应用。通过合理地使用子类和其他设计模式，可以提高代码的可维护性和扩展性。