Java 4种设计模式

装饰器模式

定义：可以在不改变原有对象的情况下扩展其功能。

使用场景：装饰器模式通过组合代替继承来扩展原始类的功能，在一些继承关系比较复杂的场景更加使用。（如IO场景各种类的继承）

1. 装饰器模式与继承的区别：

继承：直接继承类，重写父类方法或者增加新的方法。

// 基础图形类
class Shape {
    void draw() {
        System.out.println("Drawing a shape");
    }
}

// 派生的矩形类
class Rectangle extends Shape {
    void draw() {
        System.out.println("Drawing a rectangle");
    }
    
    void drawWithBorder() {
        System.out.println("Drawing a rectangle with border");
    }
}

public class InheritanceExample {
    public static void main(String[] args) {
        Shape shape = new Rectangle();
        shape.draw();  // 调用的是 Rectangle 类的 draw 方法
        // shape.drawWithBorder();  // 错误，Shape 类无法调用 Rectangle 类的独有方法
    }
}

装饰器：

• 装饰器类没有直接继承基础咖啡类；

• 在构造器中将接口类作为参数引用，在基础方法上，对方法的执行效果直接进行扩充，没有重写方法。

• 装饰器类可以嵌套连续使用多个，前提是基础类与装饰器类继承自相同的抽象类或实现相同的接口。

// 基础咖啡接口
interface Coffee {
    String getDescription();
    double getCost();
}

// 基础咖啡类
class SimpleCoffee implements Coffee {
    public String getDescription() {
        return "Simple Coffee";
    }

    public double getCost() {
        return 2.0;
    }
}

// 牛奶装饰器 装饰器直接继承interface直接操作了，没有继承基础咖啡类
class MilkDecorator implements Coffee {
    private final Coffee decoratedCoffee; //用final关键字修饰

    public MilkDecorator(Coffee coffee) {//Coffee作为一个参数进行输入
        this.decoratedCoffee = coffee;
    }

    public String getDescription() {
        return decoratedCoffee.getDescription() + ", Milk";
    }

    public double getCost() {
        return decoratedCoffee.getCost() + 1.0;
    }
}

// 糖装饰器
class SugarDecorator implements Coffee {
    private final Coffee decoratedCoffee;

    public SugarDecorator(Coffee coffee) {
        this.decoratedCoffee = coffee;
    }

    public String getDescription() {
        return decoratedCoffee.getDescription() + ", Sugar";
    }

    public double getCost() {
        return decoratedCoffee.getCost() + 0.5;
    }
}

public class DecoratorPatternExample {
    public static void main(String[] args) {
        Coffee coffee = new SimpleCoffee();
        System.out.println("Simple Coffee: " + coffee.getDescription() + ", Cost: $" + coffee.getCost());

        // 使用装饰器添加牛奶和糖
        Coffee milkCoffee = new MilkDecorator(coffee);
        Coffee milkSugarCoffee = new SugarDecorator(milkCoffee);
        System.out.println("Coffee with Milk and Sugar: " + milkSugarCoffee.getDescription() + ", Cost: $" + milkSugarCoffee.getCost());
    }
}

适配器模式

1. 定义与作用

• 主要用于接口互不兼容的类的协调工作。联想：电源适配器。
• 相关内容：
  • 适配者（Adaptee）：被适配的对象或类；
  • 适配器(Adapter)：作用域适配者的对象或类。
    • 对象适配器：利用组合关系来实现
    • 类适配器：利用继承关系来实现

2. 使用示例

2.1 类适配器

// 目标接口
interface Target {
    void request();
}

// 需要适配的类（被适配者）
class Adaptee {
    void specificRequest() {
        System.out.println("Specific request");
    }
}

// 类适配器
class ClassAdapter extends Adaptee implements Target {//使用继承的方式
    @Override
    public void request() {
        specificRequest();
    }
}

public class ClassAdapterExample {
    public static void main(String[] args) {
        Target target = new ClassAdapter();
        target.request();  // 调用的是适配器的 request 方法，实际上是调用了被适配者的 specificRequest 方法
    }
}

2.2 对象适配器

// 目标接口
interface Target {
    void request();
}

// 需要适配的类（被适配者）
class Adaptee {
    void specificRequest() {
        System.out.println("Specific request");
    }
}

// 对象适配器
class ObjectAdapter implements Target {
    private final Adaptee adaptee;

    public ObjectAdapter(Adaptee adaptee) { //使用组合的方式
        this.adaptee = adaptee;
    }

    @Override
    public void request() {
        adaptee.specificRequest();
    }
}

public class ObjectAdapterExample {
    public static void main(String[] args) {
        Adaptee adaptee = new Adaptee();
        Target target = new ObjectAdapter(adaptee);
        target.request();  // 调用的是适配器的 request 方法，实际上是调用了被适配者的 specificRequest 方法
    }
}

工厂模式

1. 定义

工厂模式是一种创建型设计模式，它提供了一种创建对象的最佳方式，而无需指定创建对象的具体类。工厂模式通过将实际创建对象的细节推迟到子类或工厂类中，以实现对代码的解耦合和更好的扩展性。

2. 分类

常见的工厂模式：简单工厂模式、工厂方法模式和抽象工厂模式。

2.1 简单工厂模式

通过一个工厂类负责创建多个类的实例。

// 抽象产品
interface Product {
    void display();
}

// 具体产品A
class ConcreteProductA implements Product {
    @Override
    public void display() {
        System.out.println("Product A");
    }
}

// 具体产品B
class ConcreteProductB implements Product {
    @Override
    public void display() {
        System.out.println("Product B");
    }
}

// 简单工厂类 在工厂中将所有的具体类集合在一起，通过不同的type进行调用
class SimpleFactory {
    public static Product createProduct(String type) {
        if ("A".equals(type)) {
            return new ConcreteProductA();
        } else if ("B".equals(type)) {
            return new ConcreteProductB();
        }
        return null;
    }
}

public class SimpleFactoryExample {
    public static void main(String[] args) {
        Product productA = SimpleFactory.createProduct("A");
        productA.display();  // 输出：Product A

        Product productB = SimpleFactory.createProduct("B");
        productB.display();  // 输出：Product B
    }
}

2.2 工厂方法模式

工厂方法模式将实际创建对象的工作推迟到工厂子类中，每个子类都实现了工厂接口并负责创建一个具体的产品。

// 抽象产品
interface Product {
    void display();
}

// 具体产品A
class ConcreteProductA implements Product {
    @Override
    public void display() {
        System.out.println("Product A");
    }
}

// 具体产品B
class ConcreteProductB implements Product {
    @Override
    public void display() {
        System.out.println("Product B");
    }
}

// 抽象工厂 抽象工厂仅提供接口，不做逻辑处理
interface Factory {
    Product createProduct();
}

// 具体工厂A  具体的工厂仅针对具体的方法进行实施
class ConcreteFactoryA implements Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProductA();
    }
}

// 具体工厂B
class ConcreteFactoryB implements Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProductB();
    }
}

public class FactoryMethodExample {
    public static void main(String[] args) {
        Factory factoryA = new ConcreteFactoryA(); //具体的工厂
        Product productA = factoryA.createProduct();//一个具体的工厂对应一个具体的产品
        productA.display();  // 输出：Product A

        Factory factoryB = new ConcreteFactoryB();
        Product productB = factoryB.createProduct();
        productB.display();  // 输出：Product B
    }
}

2.3 抽象工厂模式

抽象工厂模式提供了一个创建一系列相关或相互依赖对象的接口，而无需指定它们的具体类。

// 抽象产品A
interface ProductA {
    void display();
}

// 具体产品A1
class ConcreteProductA1 implements ProductA {
    @Override
    public void display() {
        System.out.println("Product A1");
    }
}

// 具体产品A2
class ConcreteProductA2 implements ProductA {
    @Override
    public void display() {
        System.out.println("Product A2");
    }
}

// 抽象产品B
interface ProductB {
    void display();
}

// 具体产品B1
class ConcreteProductB1 implements ProductB {
    @Override
    public void display() {
        System.out.println("Product B1");
    }
}

// 具体产品B2
class ConcreteProductB2 implements ProductB {
    @Override
    public void display() {
        System.out.println("Product B2");
    }
}

// 抽象工厂
interface AbstractFactory {
    ProductA createProductA();
    ProductB createProductB();
}

// 具体工厂1
class ConcreteFactory1 implements AbstractFactory {
    @Override
    public ProductA createProductA() {
        return new ConcreteProductA1();
    }

    @Override
    public ProductB createProductB() {
        return new ConcreteProductB1();
    }
}

// 具体工厂2
class ConcreteFactory2 implements AbstractFactory { //一个具体工厂对应多个产品
    @Override
    public ProductA createProductA() {
        return new ConcreteProductA2();
    }

    @Override
    public ProductB createProductB() {
        return new ConcreteProductB2();
    }
}

public class AbstractFactoryExample {
    public static void main(String[] args) {
        AbstractFactory factory1 = new ConcreteFactory1();
        ProductA productA1 = factory1.createProductA();
        ProductB productB1 = factory1.createProductB();
        productA1.doSomething(); // Output: Product A1 does something.
        productB1.doSomething(); // Output: Product B1 does something.

        AbstractFactory factory2 = new ConcreteFactory2();
        ProductA productA2 = factory2.createProductA();
        ProductB productB2 = factory2.createProductB();
        productA2.doSomething(); // Output: Product A2 does something.
        productB2.doSomething(); // Output: Product B2 does something.
    }
}

观察者模式

1. 定义

观察者模式是一种行为型设计模式，其中一个对象（称为主题）维护其依赖项（称为观察者）的列表，当主题的状态发生变化时，通知所有观察者。这种模式通常用于实现分布式事件处理系统。

两个角色：主题，观察者

2. 使用示例

主题接口和观察者接口：

javaCopy codeimport java.util.ArrayList;
import java.util.List;

// 主题接口
interface Subject {
    void addObserver(Observer observer);
    void removeObserver(Observer observer);
    void notifyObservers();
}

// 观察者接口
interface Observer {
    void update(String message);
}

具体主题类：

javaCopy code// 具体主题类
class ConcreteSubject implements Subject {
    private List<Observer> observers = new ArrayList<>(); //观察者列表，会在状态发生变化时通知所有观察者
    private String state;

    public void setState(String state) {
        this.state = state;
        notifyObservers(); //改变状态时，就会通知观察者
    }

    @Override
    public void addObserver(Observer observer) {
        observers.add(observer);
    }

    @Override
    public void removeObserver(Observer observer) {
        observers.remove(observer);
    }

    @Override
    public void notifyObservers() {
        for (Observer observer : observers) {
            observer.update(state);
        }
    }
}

具体观察者类：

javaCopy code// 具体观察者类
class ConcreteObserver implements Observer {//实现了 Observer 接口，可以接收并处理主题状态的变化
    private String observerName;

    public ConcreteObserver(String observerName) {
        this.observerName = observerName;
    }

    @Override
    public void update(String message) {
        System.out.println(observerName + " received message: " + message);
    }
}

使用示例：

javaCopy codepublic class ObserverPatternExample {
    public static void main(String[] args) {
        ConcreteSubject subject = new ConcreteSubject();

        Observer observer1 = new ConcreteObserver("Observer 1");
        Observer observer2 = new ConcreteObserver("Observer 2");

        subject.addObserver(observer1);
        subject.addObserver(observer2);

        // 主题状态改变，通知观察者
        subject.setState("New State");
    }
}