什么是设计模式

设计模式是在软件实践过程中，程序猿们总结出来的良好编程方法，设计模式代表了最佳的实践。

为什么要使用设计模式

合理的使用设计模式，可以提高系统的健壮性，易修改性和可扩展性

六大设计原则

1. 单一原则：类或方法应该只有有单一的职责
2. 里氏替换原则：任何能使用基类的地方，都应该可以使用其子实现替换
3. 开闭原则：对扩展开放，对修改禁止
4. 依赖倒置：应该依赖接口而不是依赖具体实现，即面向接口编程，应该对外暴露接口
5. 接口隔离原则：每个接口应该有自己独立的功能，不要在一个接口中定义多个功能。类要实现多个功能需要实现不同功能的接口。对外暴露接口的时候，也要做到最小化接口
6. 迪米特法则：也叫最小知道法则，即要尽量避免与其他类的交流，应该只与内部变量，方法输入与输出中的类交流

创建型（五种）：

==简单工厂模式（不属于23中设计模式）==：

根据不同的入参创建不同的对象
每次增加新的对象都需要修改代码

spring中的BeanFactory就是用的简单工厂模式, 通过传入的唯一标识，返回需要的bean实例

==工厂模式==：

为每一个产品创建一个工厂类，通过不同的工厂实例来创建不同的产品
方便增加同一等级的不同产品

spring中的FactoryBean接口采用了工厂方法模式，当注入相关bean时，Spring会先获取FactoryBean的实例，再调用用户实现的getObject方法返回对应的bean

==抽象工厂模式==：

为每一产品类创建一个工厂类，通过不同的工厂类来创建一类产品
方便扩展产品类，但不方便在产品类中添加新的产品

简单工厂模式、工厂方法模式、抽象工厂模式，是一个由简到繁，根据需求的不断复杂化多样化而诞生的过程，工厂模式其实就是根据工厂创建对象，只不过有的是小作坊，有的是大车间

Demo：

// 定义产品
public interface Phone {}
public interface PC {}
public class MiPhone implements Phone {}
public class MiPC implements PC {}
public class IPhone implements Phone{}
public class Mac implements PC {}

简单工厂

public class SimpleFactory {
    public static <T extends Phone> T makePhone(String type) {
        if ("mi".equals(type)) {
            return (T) new MiPhone();
        } else if ("apple".equals(type)) {
            return (T) new IPhone();
        } else {
            return null;
        }
    }
}

public class Client {
    public static void main(String[] args) {
        MiPhone miPhone = SimpleFactory.makePhone("mi");
    }
}

工厂模式

public interface AbstractFactory {
    Phone makePhone();
}

public class MiFactory implements AbstractFactory {
    @Override
    public Phone makePhone() {
        return new MiPhone();
    }
}

public class AppleFactory implements AbstractFactory {
    @Override
    public Phone makePhone() {
        return new IPhone();
    }
}

public class Client {
    public static void main(String[] args) {
        AbstractFactory miFactory = new MiFactory();
        AbstractFactory appleFactory = new AppleFactory();
        MiPhone miPhone = (MiPhone) miFactory.makePhone();
        IPhone iPhone = (IPhone) appleFactory.makePhone();
    }
}

抽象工厂模式

public interface AbstractFactory {
    Phone makePhone();
    PC makePC();
}

public class MiFactory implements AbstractFactory {
    @Override
    public Phone makePhone() {
        return new MiPhone();
    }
    @Override
    public PC makePC() {
        return new MiPC();
    }
}

public class AppleFactory implements AbstractFactory {
    @Override
    public Phone makePhone() {
        return new IPhone();
    }
    @Override
    public PC makePC() {
        return new Mac();
    }
}

public class Client {
    public static void main(String[] args) {
        AbstractFactory miFactory = new MiFactory();
        AbstractFactory appleFactory = new AppleFactory();
        miFactory.makePhone();
        miFactory.makePC();
        appleFactory.makePhone();
        appleFactory.makePC();
    }
}

==单例模式==：

保证全局仅有一个对象实例，并提供一个对外的实例访问点
违背了单一职责原则

单例的几种实现方式：

1. 饿汉式：

优点：线程安全
缺点：不用的话，实力也会创建，浪费资源，由于在启动时就会创建，会导致启动变慢

public class SingletonClass {
    public static final SingletonClass INSTANCE = new SingletonClass();
    private SingletonClass {}
}

2. 懒汉式：

优点：使用时才加载，节约系统资源
缺点：处理线程安全问题麻烦

DCL1.0 该实现方式存在缺陷, JMM设计原因导致

public class SingletonClass {
    private static SingletonClass instance = null;
    private SingletonClass {}

    public static SingletonClass getInstance() {
        if (instance == null) {
            synchronized (this) {
                if (instance == null) {
                    instance = new SingletonClass();
                }
            }
        }
        return instance;
    }
}

DLC2.0

public class SingletonClass {
    private static volatile SingletonClass instance = null;
    private SingletonClass {}

    public static SingletonClass getInstance() {
        if (instance == null) {
            synchronized (this) {
                if (instance == null) {
                    instance = new SingletonClass();
                }
            }
        }
        return instance;
    }
}

3. Holder模式

优点，兼具饿汉和懒汉模式优点，线程安全，不使用不会加载，节约资源

public class SingletonClass {
    private static class SingletonClassHolder {
        private static final SingletonClass INSTANCE = new SingletonClass();
    }
    private SingletonClass {}

    public static SingletonClass getInstance() {
        return SingletonClassHolder.INSTANCE;
    }
}

==思考一下，上述的几种实现方式是否有办法破坏，tips：java反射，java序列化==

4. 枚举模式

优点：安全，简单，无多线程问题
缺点：见饿汉模式

public enum SingletonClass {
    INSTANCE;

    public void doSomthing() {
        // TODO
    }
}

原型模式：

用于创建重复的对象，同时还能保证性能。
通过实现Cloneable接口的clone方法来实现原型模式。

public class PrototypeClass implements Cloneable {

    @Override
    public Object clone() {
        Object clone = null;
        try {
            clone = super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return clone;
    }
}

创建者模式：

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

MultipartBody body = new MultipartBody.Builder()
                .setType(MultipartBody.FORM)
                .addFormDataPart("fileData", "a.pdf", fileBody)
                .addFormDataPart("meta", "{\"thresh\":0.7}")
                .addFormDataPart("token", pdfAddrToken)
                .build();

Request request = new Request.Builder()
                .header("Content-Type", "multipart/form-data")
                .post(body)
                .url(addRess)
                .build();

结构型：未完待续...

行为型：未完待续...