设计模式菜鸟教程详细阐述

一、23种设计模式菜鸟教程

设计模式是解决软件开发过程中经常遇到的一些重复性问题的经验总结，可以提高代码的可重用性、可扩展性和可维护性。23种设计模式菜鸟教程对这些经验进行了归类总结，包括：

创建型模式：
1. 工厂模式
2. 抽象工厂模式
3. 单例模式
4. 建造者模式
5. 原型模式

结构型模式：
6. 适配器模式
7. 桥接模式
8. 组合模式
9. 装饰器模式
10. 外观模式
11. 享元模式
12. 代理模式

行为型模式：
13. 职责链模式
14. 命令模式
15. 解释器模式
16. 迭代器模式
17. 中介者模式
18. 备忘录模式
19. 观察者模式
20. 状态模式
21. 策略模式
22. 模板方法模式
23. 访问者模式

二、适配器模式菜鸟教程

适配器模式是将一个类的接口转换成客户希望的另外一个接口，让原本由于接口不兼容而不能一起工作的那些类可以一起工作。

适配器模式包含适配器接口、具体适配器和客户端。具体适配器实现适配器接口，并包含一个待适配的对象，在适配器接口的方法中调用待适配对象的方法，将其转换为客户端需要的形式。

interface Target {
    void request();
}

class Adaptee {
    void specificRequest() {
        System.out.println("Adaptee specificRequest.");
    }
}

class Adapter implements Target {
    private Adaptee adaptee;

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

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

public class Client {
    public static void main(String[] args) {
        Adaptee adaptee = new Adaptee();
        Target target = new Adapter(adaptee);
        target.request();
    }
}

三、单例模式菜鸟教程

单例模式是一种创建型模式，保证一个类只有一个实例，并且提供一个访问它的全局访问点。

单例模式有两种经典实现方式：懒汉式和饿汉式。

3.1 懒汉式

懒汉式指在使用到实例时才进行实例化，线程不安全的懒汉式实现代码如下：

public class Singleton {
    private static Singleton instance;

    private Singleton() {}

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

为了保证线程安全，可以使用双重检查锁定的方式实现懒汉式单例模式：

public class Singleton {
    private volatile static Singleton instance;

    private Singleton() {}

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

3.2 饿汉式

饿汉式指在类加载时就进行实例化，线程安全的饿汉式实现代码如下：

public class Singleton {
    private static final Singleton instance = new Singleton();

    private Singleton() {}

    public static Singleton getInstance() {
        return instance;
    }
}

四、建造者模式菜鸟教程

建造者模式是一种创建型模式，将一个复杂对象的构建和表示分离，使得同样的构建过程可以创建不同的表示。

建造者模式有四个角色：抽象建造者、具体建造者、产品和指挥者。抽象建造者和具体建造者负责定义和实现创建产品的各个组成部分的接口和实现，产品是要被创建的复杂对象，指挥者负责协调抽象建造者和具体建造者的工作，以及构建产品对象。

class Product {
    private List parts = new ArrayList<>();

    void add(String part) {
        parts.add(part);
    }

    void show() {
        for (String part : parts) {
            System.out.println(part);
        }
    }
}

abstract class Builder {
    abstract void buildPartA();

    abstract void buildPartB();

    abstract Product getResult();
}

class ConcreteBuilder extends Builder {
    private Product product = new Product();

    @Override
    void buildPartA() {
        product.add("PartA");
    }

    @Override
    void buildPartB() {
        product.add("PartB");
    }

    @Override
    Product getResult() {
        return product;
    }
}

class Director {
    void construct(Builder builder) {
        builder.buildPartA();
        builder.buildPartB();
    }
}

public class Client {
    public static void main(String[] args) {
        Builder builder = new ConcreteBuilder();
        Director director = new Director();
        director.construct(builder);
        Product product = builder.getResult();
        product.show();
    }
}

  

五、责任链模式菜鸟教程

责任链模式是一种行为型模式，将请求的发送者和接收者解耦，并且请求沿着链传递，直到有一个对象处理该请求。

责任链模式有两个关键角色：抽象处理者和具体处理者。抽象处理者定义处理请求的接口，具体处理者实现处理请求的方法，并指定其后继处理者。使用责任链模式，请求发送者并不知道哪个对象最终会处理请求，并且每个对象也只负责自己的部分。

abstract class Handler {
    private Handler successor;

    void setSuccessor(Handler successor) {
        this.successor = successor;
    }

    abstract void handleRequest(int request);

    void next(int request) {
        if (successor != null) {
            successor.handleRequest(request);
        }
    }
}

class ConcreteHandler1 extends Handler {
    @Override
    void handleRequest(int request) {
        if (request > 0 && request <= 10) {
            System.out.println("ConcreteHandler1 handleRequest: " + request);
        } else {
            next(request);
        }
    }
}

class ConcreteHandler2 extends Handler {
    @Override
    void handleRequest(int request) {
        if (request > 10 && request <= 20) {
            System.out.println("ConcreteHandler2 handleRequest: " + request);
        } else {
            next(request);
        }
    }
}

class ConcreteHandler3 extends Handler {
    @Override
    void handleRequest(int request) {
        if (request > 20 && request <= 30) {
            System.out.println("ConcreteHandler3 handleRequest: " + request);
        } else {
            next(request);
        }
    }
}

public class Client {
    public static void main(String[] args) {
        Handler handler1 = new ConcreteHandler1();
        Handler handler2 = new ConcreteHandler2();
        Handler handler3 = new ConcreteHandler3();
        handler1.setSuccessor(handler2);
        handler2.setSuccessor(handler3);

        handler1.handleRequest(5);
        handler1.handleRequest(15);
        handler1.handleRequest(25);
        handler1.handleRequest(35);
    }
}