【设计模式】

设计模式

• 设计模式的六大原则
• 设计模式的分类
• • 创建型设计模式
  • 单例模式：
  • 简单工厂模式：
  • 抽象工厂模式
  • 建造者模式
  • 结构型设计模式
  • 行为型设计模式
  • 观察者模式

---

设计模式的六大原则

• 单一原则：就一个类而言，应该仅有一个引起它变化的原因
• 开放封闭原则：类、模块、函数等应该是可以拓展的，但是不可以修改
• 里氏替换原则：所有引用基类（父类）的地方必须能透明地使用其子类的对象
• 依赖倒置原则：高层模块不应该依赖底层模块，两者都应该依赖抽象。抽象不应该依赖细节，细节应该依赖抽象
• 迪米特原则：一个软件实体应当尽可能少地与其他实体发生相互作用
• 接口隔离原则：一个类对另一个类的依赖应该建立在最小的接口上

设计模式的分类 创建型设计模式 单例模式：

保证一个类仅有一个实例，并提供一个访问它的全局访问点

//双重检查模式（DCL）
public class Singleton {
    private static volatile Singleton instance;
    private Singleton(){
    }
    public static Singleton getInstance(){
        if (instance == null){
            synchronized (Singleton.class){
                if (instance == null){
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

//静态内部类单例模式
public class Singleton {
    private Singleton(){
    }
    public static Singleton getInstance(){
        return SingletonHolder.sInstance;
    }
    private static class SingletonHolder{
        private static final Singleton sInstance = new Singleton();
    }
}

简单工厂模式：

简单工厂模式属于创建型设计模式，其又被成为静态工厂模式，这是由一个工厂对象决定创建出哪一种产品类的实例

1. 抽象产品类：创建一个计算机的抽象类，其中有一个抽象方法用于启动计算机

public abstract class Computer {
    /**
     * 产品的抽象方法，由产品类实现
     */
    public abstract boolean start();
}

2. 具体产品类：创建各个品牌的计算机，其都继承了自己的父类Computer，并实现了父类的start方法

public class LenovoComputer extends Computer{
    @Override
    public void start() {
        System.out.println("联想计算机启动");
    }
}
public class HpComputer extends Computer{
    @Override
    public void start() {
        System.out.println("惠普计算机启动");
    }
}
public class AsusComputer extends Computer{
    @Override
    public void start() {
        System.out.println("华硕计算机启动");
    }
}

3. 工厂类：创建工厂类，它提供一个静态方法createComputer来生产计算机。你只需要传入自己想生产的计算机品牌，它就会实例化相应品牌的计算机对象

public class ComputerFactory {
    public static Computer createComputer(String type){
        Computer computer = null;
        switch (type){
            case "lenove":{
                computer = new LenovoComputer();
            }
            break;
            case "hp":{
                computer = new HpComputer();
            }
            break;
            case "asus":{
                computer = new AsusComputer();
            }
            break;
        }
        return computer;
    }
}

4. 使用工厂类创建生产出惠普计算机并调用其start方法

ComputerFactory.createComputer("hp").start();

抽象工厂模式

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

1. 抽象产品类：创建一个计算机的抽象类，其中有一个抽象方法用于启动计算机

public abstract class Computer {
    /**
     * 产品的抽象方法，由产品类实现
     */
    public abstract boolean start();
}

2. 具体产品类：创建各个品牌的计算机，其都继承了自己的父类Computer，并实现了父类的start方法

public class LenovoComputer extends Computer{
    @Override
    public void start() {
        System.out.println("联想计算机启动");
    }
}
public class HpComputer extends Computer{
    @Override
    public void start() {
        System.out.println("惠普计算机启动");
    }
}
public class AsusComputer extends Computer{
    @Override
    public void start() {
        System.out.println("华硕计算机启动");
    }
}

3. 抽象工厂类：抽象工厂类有一个createComputer方法，想生产哪个品牌的计算机就生产哪个品牌的

public abstract class ComputerFactory {
    public abstract <T extends Computer> T createComputer(Class<T> clz);
}

4. 具体工厂类：某某工厂是一个具体的工厂，其继承自抽象工厂，通过反射来生产不同厂家的计算机

public class MMComputerFactory extends ComputerFactory{
    @Override
    public <T extends Computer> T createComputer(Class<T> clz) {
        Computer computer = null;
        try {
            //通过反射来生产不同厂家的计算机
            computer = (Computer) Class.forName(clz.getName()).newInstance();
        }catch (Exception e){
            e.printStackTrace();
        }
        return (T) computer;
    }
}

5. 客户端使用：创建了一个MMComputerFactory，并分别生产了联想、华硕、惠普计算机

ComputerFactory computerFactory = new MMComputerFactory();
        LenovoComputer lenovoComputer = computerFactory.createComputer(LenovoComputer.class);
        lenovoComputer.start();
        HpComputer hpComputer = computerFactory.createComputer(HpComputer.class);
        hpComputer.start();
        AsusComputer asusComputer = computerFactory.createComputer(AsusComputer.class);
        asusComputer.start();

建造者模式

将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示

1. 创建产品类：我要组装一台计算机，计算机被抽象为Computer类，假设它有三个部件：CPU、主板、和内存，并在里面提供了3个方法分别用来设置CPU、主板和内存

 public class Computer {
    private String CPU = "";
    private String mainboard = "";
    private String ram = "";
    public void setCPU(String CPU) {
        this.CPU = CPU;
    }
    public void setMainboard(String mainboard) {
        this.mainboard = mainboard;
    }
    public void setRam(String ram) {
        this.ram = ram;
    }
}

2. 创建Builder类：商家组装计算机有一套组装方法的模版，就是一个抽象的Builder类，其里面提供了安装CPU、主板和内存的方法，以及组装计算机的create方法

public static abstract class Builder {
        public abstract void buildCPU(String cpu);
        public abstract void buildMainboard(String mainboard);
        public abstract void buildRam(String ram);
        public abstract Computer create();
    }

3. 实现抽象Builder类：某个商家实现抽象Builder类，用于组装计算机

public class MMBuilder extends Computer.Builder {
    private Computer computer = new Computer();
    @Override
    public void buildCPU(String cpu) {
        computer.setCPU(cpu);
    }
    @Override
    public void buildMainboard(String mainboard) {
        computer.setMainboard(mainboard);
    }
    @Override
    public void buildRam(String ram) {
        computer.setRam(ram);
    }
    @Override
    public Computer create() {
        return computer;
    }
}

4. 用导演类来统一组装过程：规范组装计算机的流程：先安装主板，再安装CPU，最后安装内存并组装成计算机

public class Director {
    Computer.Builder mBuilder = null;
    public Director(Computer.Builder mBuilder) {
        this.mBuilder = mBuilder;
    }
    public Computer CreateComputer(String cpu,String mainboard,String ram){
        this.mBuilder.buildMainboard(mainboard);
        this.mBuilder.buildCPU(cpu);
        this.mBuilder.buildRam(ram);
        return mBuilder.create();
    }
}

5. 客户端调用导演类：我只需要提供自己想要的CPU、主板和内存就可以得到一个计算机

Computer.Builder builder = new MMBuilder();
Director director = new Director(builder);
//组装计算机
director.CreateComputer("i7-6700","华擎玩家至尊","三星 DDR4");

原型模式

结构型设计模式

适配器模式
装饰模式
代理模式
外观模式
桥接模式
组合模式
享元模式

行为型设计模式

策略模式
模版方法模式
迭代器模式
责任链模式
命令模式
备忘录模式
状态模式
访问者模式
中介者模式
解释器模式

观察者模式

1. 抽象观察者

public interface Observer {
    public void update(String message);
}

2. 具体观察者

public class WeixinUser implements Observer{
    private String name;
    public WeixinUser(String name) {
        this.name = name;
    }
    @Override
    public void update(String message) {
        Log.e(name,"："+message);
    }
}

3. 抽象被观察者

public interface Subject {
    /**
     * 增加订阅者
     * @param observer
     */
    public void attact(Observer observer);
    /**
     * 删除订阅者
     * @param observer
     */
    public void detach(Observer observer);
    /**
     * 通知订阅者更新消息
     * @param message
     */
    public void notify(String message);
}

4. 具体被观察者

public class SubscriptionSubject implements Subject{
    //存储订阅公众号的微信用户
    private List<Observer> weixinUserList = new ArrayList<>();
    @Override
    public void attact(Observer observer) {
        weixinUserList.add(observer);
    }
    @Override
    public void detach(Observer observer) {
        weixinUserList.remove(observer);
    }
    @Override
    public void notify(String message) {
        for (Observer observer : weixinUserList){
            observer.update(message);
        }
    }
}

5. 客户端调用

SubscriptionSubject subscriptionSubject = new SubscriptionSubject();
//创建微信用户
WeixinUser user1 = new WeixinUser("扬影枫");
WeixinUser user2 = new WeixinUser("月眉儿");
WeixinUser user3 = new WeixinUser("紫轩");
//订阅公众号
subscriptionSubject.attact(user1);
subscriptionSubject.attact(user2);
subscriptionSubject.attact(user3);
//公众号更新，向订阅的微信用户发出消息
subscriptionSubject.notify("剑侠情缘的公众号更新了");