大神详解，这么详细的Java设计模式不收藏可惜了("Java设计模式详解珍藏版：大神带你深入理解，不容错过！")

原创

ithorizon 6个月前 (10-20) 阅读数 33 #后端开发

Java设计模式详解珍藏版：大神带你深入明白，不容错过！

一、Java设计模式简介

Java设计模式是一套被反复使用的、多数人知晓、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人明白、保证代码可靠性。下面将详细介绍一些常用的Java设计模式。

二、创建型模式

1. 单例模式（Singleton）

单例模式确保一个类只有一个实例，并提供一个全局访问点。


public class Singleton {
    private static Singleton instance;
    private Singleton() {}
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

2. 工厂方法模式（Factory Method）

工厂方法模式定义一个接口用于创建对象，但让子类决定实例化哪个类。工厂方法使一个类的实例化延迟到其子类。


public abstract class Creator {
    public abstract Product factoryMethod();
}
public class ConcreteCreatorA extends Creator {
    public Product factoryMethod() {
        return new ConcreteProductA();
    }
}
public class ConcreteCreatorB extends Creator {
    public Product factoryMethod() {
        return new ConcreteProductB();
    }
}
public abstract class Product {
}
public class ConcreteProductA extends Product {
}
public class ConcreteProductB extends Product {
}

3. 抽象工厂模式（Abstract Factory）

抽象工厂模式提供一个接口，用于创建相关或依赖性对象的家族，而不需要明确指定具体类。


public abstract class AbstractFactory {
    public abstract ProductA createProductA();
    public abstract ProductB createProductB();
}
public class ConcreteFactory1 extends AbstractFactory {
    public ProductA createProductA() {
        return new ConcreteProductA1();
    }
    public ProductB createProductB() {
        return new ConcreteProductB1();
    }
}
public class ConcreteFactory2 extends AbstractFactory {
    public ProductA createProductA() {
        return new ConcreteProductA2();
    }
    public ProductB createProductB() {
        return new ConcreteProductB2();
    }
}
public abstract class ProductA {
}
public abstract class ProductB {
}
public class ConcreteProductA1 extends ProductA {
}
public class ConcreteProductA2 extends ProductA {
}
public class ConcreteProductB1 extends ProductB {
}
public class ConcreteProductB2 extends ProductB {
}

4. 建造者模式（Builder）

建造者模式将一个繁复对象的构建与其即分离，促使同样的构建过程可以创建不同的即。


public abstract class Builder {
    public abstract void buildPartA();
    public abstract void buildPartB();
    public abstract Product getResult();
}
public class ConcreteBuilder1 extends Builder {
    private Product product = new Product();
    @Override
    public void buildPartA() {
        product.addPart("PartA1");
    }
    @Override
    public void buildPartB() {
        product.addPart("PartB1");
    }
    @Override
    public Product getResult() {
        return product;
    }
}
public class ConcreteBuilder2 extends Builder {
    private Product product = new Product();
    @Override
    public void buildPartA() {
        product.addPart("PartA2");
    }
    @Override
    public void buildPartB() {
        product.addPart("PartB2");
    }
    @Override
    public Product getResult() {
        return product;
    }
}
public class Director {
    private Builder builder;
    public Director(Builder builder) {
        this.builder = builder;
    }
    public void construct() {
        builder.buildPartA();
        builder.buildPartB();
    }
}
public class Product {
    private List parts = new ArrayList<>();
    public void addPart(String part) {
        parts.add(part);
    }
    public String show() {
        return String.join(", ", parts);
    }
}

三、结构型模式

1. 适配器模式（Adapter）

适配器模式允许将一个类的接口转换成客户期望的另一个接口。适配器让原本接口不兼容的类可以团结无间。


public interface Target {
    void request();
}
public class Adapter implements Target {
    private Adaptee adaptee;
    public Adapter(Adaptee adaptee) {
        this.adaptee = adaptee;
    }
    @Override
    public void request() {
        adaptee.specificRequest();
    }
}
public class Adaptee {
    public void specificRequest() {
        System.out.println("Specific request.");
    }
}
public class Client {
    public static void main(String[] args) {
        Target target = new Adapter(new Adaptee());
        target.request();
    }
}

2. 桥接模式（Bridge）

桥接模式将抽象部分与实现部分分离，使它们可以自由地变化。


public abstract class Abstraction {
    protected Implementor implementor;
    public Abstraction(Implementor implementor) {
        this.implementor = implementor;
    }
    public abstract void operation();
}
public class RefinedAbstraction extends Abstraction {
    public RefinedAbstraction(Implementor implementor) {
        super(implementor);
    }
    @Override
    public void operation() {
        implementor.implementOperation();
        // Other operations...
    }
}
public abstract class Implementor {
    public abstract void implementOperation();
}
public class ConcreteImplementorA extends Implementor {
    @Override
    public void implementOperation() {
        System.out.println("ConcreteImplementorA operation.");
    }
}
public class ConcreteImplementorB extends Implementor {
    @Override
    public void implementOperation() {
        System.out.println("ConcreteImplementorB operation.");
    }
}
public class Client {
    public static void main(String[] args) {
        Abstraction abstraction = new RefinedAbstraction(new ConcreteImplementorA());
        abstraction.operation();
        abstraction = new RefinedAbstraction(new ConcreteImplementorB());
        abstraction.operation();
    }
}

3. 组合模式（Composite）

组合模式将对象组合成树形结构以即“部分-整体”的层次结构。组合模式使用户对单个对象和组合对象的使用具有一致性。


public abstract class Component {
    public abstract void operation();
}
public class Leaf extends Component {
    @Override
    public void operation() {
        System.out.println("Leaf operation.");
    }
}
public class Composite extends Component {
    private List components = new ArrayList<>();
    @Override
    public void operation() {
        for (Component component : components) {
            component.operation();
        }
    }
    public void add(Component component) {
        components.add(component);
    }
    public void remove(Component component) {
        components.remove(component);
    }
}
public class Client {
    public static void main(String[] args) {
        Composite composite = new Composite();
        composite.add(new Leaf());
        composite.add(new Leaf());
        Composite subComposite = new Composite();
        subComposite.add(new Leaf());
        composite.add(subComposite);
        composite.operation();
    }
}

4. 装饰器模式（Decorator）

装饰器模式动态地给一个对象添加一些额外的职责，而不改变其接口。


public abstract class Component {
    public abstract void operation();
}
public class ConcreteComponent extends Component {
    @Override
    public void operation() {
        System.out.println("ConcreteComponent operation.");
    }
}
public abstract class Decorator extends Component {
    protected Component component;
    public Decorator(Component component) {
        this.component = component;
    }
    @Override
    public void operation() {
        component.operation();
    }
}
public class ConcreteDecoratorA extends Decorator {
    public ConcreteDecoratorA(Component component) {
        super(component);
    }
    @Override
    public void operation() {
        super.operation();
        System.out.println("ConcreteDecoratorA operation.");
    }
}
public class ConcreteDecoratorB extends Decorator {
    public ConcreteDecoratorB(Component component) {
        super(component);
    }
    @Override
    public void operation() {
        super.operation();
        System.out.println("ConcreteDecoratorB operation.");
    }
}
public class Client {
    public static void main(String[] args) {
        Component component = new ConcreteComponent();
        component = new ConcreteDecoratorA(component);
        component = new ConcreteDecoratorB(component);
        component.operation();
    }
}

四、行为型模式

1. 策略模式（Strategy）

策略模式定义一系列算法，将每一个算法封装起来，并使它们可以互相替换。策略模式让算法的变化自由于使用算法的客户。


public interface Strategy {
    void execute();
}
public class ConcreteStrategyA implements Strategy {
    @Override
    public void execute() {
        System.out.println("ConcreteStrategyA execute.");
    }
}
public class ConcreteStrategyB implements Strategy {
    @Override
    public void execute() {
        System.out.println("ConcreteStrategyB execute.");
    }
}
public class Context {
    private Strategy strategy;
    public Context(Strategy strategy) {
        this.strategy = strategy;
    }
    public void setStrategy(Strategy strategy) {
        this.strategy = strategy;
    }
    public void executeStrategy() {
        strategy.execute();
    }
}
public class Client {
    public static void main(String[] args) {
        Context context = new Context(new ConcreteStrategyA());
        context.executeStrategy();
        context.setStrategy(new ConcreteStrategyB());
        context.executeStrategy();
    }
}

2. 观察者模式（Observer）

观察者模式定义了一种一对多的依赖性关系，当一个对象改变状态时，所有依赖性于它的对象都会得到通知并自动更新。


public interface Observer {
    void update();
}
public class ConcreteObserverA implements Observer {
    private int state;
    @Override
    public void update() {
        System.out.println("ConcreteObserverA update with state: " + state);
    }
    public void setState(int state) {
        this.state = state;
    }
    public int getState() {
        return state;
    }
}
public class ConcreteObserverB implements Observer {
    private int state;
    @Override
    public void update() {
        System.out.println("ConcreteObserverB update with state: " + state);
    }
    public void setState(int state) {
        this.state = state;
    }
    public int getState() {
        return state;
    }
}
public class Subject {
    private List observers = new ArrayList<>();
    private int state;
    public void attach(Observer observer) {
        observers.add(observer);
    }
    public void detach(Observer observer) {
        observers.remove(observer);
    }
    public void notifyObservers() {
        for (Observer observer : observers) {
            observer.update();
        }
    }
    public void setState(int state) {
        this.state = state;
        notifyObservers();
    }
    public int getState() {
        return state;
    }
}
public class Client {
    public static void main(String[] args) {
        Subject subject = new Subject();
        Observer observerA = new ConcreteObserverA();
        Observer observerB = new ConcreteObserverB();
        subject.attach(observerA);
        subject.attach(observerB);
        subject.setState(1);
        subject.setState(2);
    }
}

3. 命令模式（Command）

命令模式将请求封装为一个对象，从而可以使用不同的请求、队列或日志来参数化其他对象。命令模式也赞成可撤销的操作。


public interface Command {
    void execute();
}
public class Light {
    public void turnOn() {
        System.out.println("Light is on.");
    }
    public void turnOff() {
        System.out.println("Light is off.");
    }
}
public class LightOnCommand implements Command {
    private Light light;
    public LightOnCommand(Light light) {
        this.light = light;
    }
    @Override
    public void execute() {
        light.turnOn();
    }
}
public class LightOffCommand implements Command {
    private Light light;
    public LightOffCommand(Light light) {
        this.light = light;
    }
    @Override
    public void execute() {
        light.turnOff();
    }
}
public class RemoteControl {
    private Command command;
    public void setCommand(Command command) {
        this.command = command;
    }
    public void pressButton() {
        command.execute();
    }
}
public class Client {
    public static void main(String[] args) {
        Light light = new Light();
        Command lightOnCommand = new LightOnCommand(light);
        Command lightOffCommand = new LightOffCommand(light);
        RemoteControl remoteControl = new RemoteControl();
        remoteControl.setCommand(lightOnCommand);
        remoteControl.pressButton();
        remoteControl.setCommand(lightOffCommand);
        remoteControl.pressButton();
    }
}

4. 责任链模式（Chain of Responsibility）

责任链模式使多个对象都有机会处理请求，从而避免了请求发送者和接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递请求，直到有一个对象处理它为止。


public abstract class Handler {
    protected Handler successor;
    public void setSuccessor(Handler successor) {
        this.successor = successor;
    }
    public abstract void handleRequest(int request);
}
public class ConcreteHandlerA extends Handler {
    @Override
    public void handleRequest(int request) {
        if (request >= 0 && request < 10) {
            System.out.println("ConcreteHandlerA handles request " + request);
        } else if (successor != null) {
            successor.handleRequest(request);
        }
    }
}
public class ConcreteHandlerB extends Handler {
    @Override
    public void handleRequest(int request) {
        if (request >= 10 && request < 20) {
            System.out.println("ConcreteHandlerB handles request " + request);
        } else if (successor != null) {
            successor.handleRequest(request);
        }
    }
}
public class Client {
    public static void main(String[] args) {
        Handler handlerA = new ConcreteHandlerA();
        Handler handlerB = new ConcreteHandlerB();
        handlerA.setSuccessor(handlerB);
        handlerA.handleRequest(5);
        handlerA.handleRequest(15);
    }
}