java 23种设计模式

Java 23种设计模式

简介

设计模式是一套被广泛应用于软件开发领域的最佳实践方法，它们能够提供可重用、可靠和灵活的解决方案。Java 23种设计模式分为三个大类：创建型模式、结构型模式和行为型模式。本文将介绍如何使用Java实现这些设计模式。

流程

下面的表格展示了实现“Java 23种设计模式”的整个流程：

journey
    title Java 23种设计模式实现流程

    section 创建型模式
    创建SimpleFactory类
    创建Factory接口
    创建具体的Product类

    section 结构型模式
    创建Adapter类
    创建Bridge类
    创建Decorator类

    section 行为型模式
    创建Observer类
    创建Strategy类
    创建Command类

创建型模式

Simple Factory

首先，我们来实现Simple Factory（简单工厂）模式。这个模式提供了一个简单的工厂类，它根据不同的条件创建不同的对象。

public class SimpleFactory {
    public static Product createProduct(String type) {
        if (type.equals("A")) {
            return new ConcreteProductA();
        } else if (type.equals("B")) {
            return new ConcreteProductB();
        }
        return null;
    }
}

public interface Product {
    void doSomething();
}

public class ConcreteProductA implements Product {
    @Override
    public void doSomething() {
        System.out.println("Doing something in ConcreteProductA");
    }
}

public class ConcreteProductB implements Product {
    @Override
    public void doSomething() {
        System.out.println("Doing something in ConcreteProductB");
    }
}

Factory Method

接下来，我们实现Factory Method（工厂方法）模式。这个模式定义了一个创建对象的接口，但由子类决定实例化哪个类。

public interface Factory {
    Product createProduct();
}

public class ConcreteFactoryA implements Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProductA();
    }
}

public class ConcreteFactoryB implements Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProductB();
    }
}

Abstract Factory

下面是Abstract Factory（抽象工厂）模式的实现。这个模式提供了一个创建一系列相关或相互依赖对象的接口，而无需指定它们的具体类。

public interface AbstractFactory {
    ProductA createProductA();
    ProductB createProductB();
}

public interface ProductA {
    void doSomething();
}

public interface ProductB {
    void doSomething();
}

public class ConcreteFactory1 implements AbstractFactory {
    @Override
    public ProductA createProductA() {
        return new ConcreteProductA1();
    }

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

public class ConcreteFactory2 implements AbstractFactory {
    @Override
    public ProductA createProductA() {
        return new ConcreteProductA2();
    }

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

结构型模式

Adapter

接下来，我们来实现Adapter（适配器）模式。这个模式将一个类的接口转换成客户希望的另一个接口。

public interface Target {
    void request();
}

public class Adaptee {
    public void specificRequest() {
        System.out.println("Specific request in Adaptee");
    }
}

public class Adapter implements Target {
    private Adaptee adaptee;

    public Adapter(Adaptee adaptee) {
        this.adaptee = adaptee;
    }

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

Bridge

下面是Bridge（桥接）模式的实现。这个模式将抽象与实现分离，使它们可以独立地变化。

public interface Implementor {
    void operationImpl();
}

public class ConcreteImplementorA implements Implementor {
    @Override
    public void operationImpl() {
        System.out.println("Implementation A");
    }
}

public class ConcreteImplementorB implements Implementor {
    @Override
    public void operationImpl() {
        System.out.println("Implementation B");
    }
}

public abstract class Abstraction {
    protected Implementor implementor;

    public Abstraction(Implementor implementor) {
        this.implementor = implement