设计模式

设计模式目的

提升软件的维护性、通用性和扩展性，降低软件的复杂度。核心是七大设计原则。
设计模式有优点也有缺点，每种设计模式都有其适用的场景，不要为了使用设计模式而使用设计模式，切记防止“模式的滥用”。

设计模式分类

公认的是23种（即：GoF设计模式）。

模式的类型	包含的模式
创建型模式	单例模式、工厂模式、抽象工厂模式、原型模式、建造者模式
结构型模式	适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式
行为型模式	策略模式、模板方法模式、观察者模式、迭代器模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式

23种设计模式

1. 单例模式（Singleton Pattern）

定义：系统中只有一个类的唯一实例。

饿汉式（静态常量）

class A{
    private A(){}
    private static final A instance = new A();
    public static A getInstance(){
        return instance;
    }
}

饿汉式（静态代码块）

class A{
    private A(){}
    private static A instance;
    static {
        instance = new A();
    }
    public static A getInstance(){
        return instance;
    }
}

懒汉式（双重检查，Double-Check）

class A{
    private A(){}
    // volatile 保证内存可见性
    private static volatile A instance;
    public static A getInstance(){
        if (instance == null) {
            synchronized (A.class) {
                if (instance == null) {
                    instance = new A();
                }
            }
        }
        return instance;
    }
}

懒汉式（静态内部类）
静态内部类特点（懒加载）：静态内部类B在A类被装载时不会立即初始化；当getInstance()被调用时才会装载B，才会实例化。

class A{
    private A(){}
    private static class B {
        private static final A INSTANCE = new A();
    }
    public static A getInstance(){
        return B.INSTANCE;
    }
}

枚举
借助JDK1.5的枚举来实现单例模式，不仅避免多线程同步问题，而且还能防止反序列化重新创建对象。

public class Main {
    public static void main(String[] args){
        A a = A.INSTANCE;
        a.method1();
    }
}

enum A{
    INSTANCE;
    public void method1(){}
}

总结：

饿汉式只是有可能造成内存浪费（从头到尾没有使用该实例），但简单易懂，由JDK保证线程安全；所以使用不会有大问题。
懒汉式需要考虑到懒加载、线程安全、效率问题。

补充：java中创建类的方式

new关键字：单例模式解决这点。
反射：会破坏单例模式。
反序列化：会破坏单例模式，添加readResolve()方法解决。
克隆：会破坏单例模式。

2. 工厂模式

定义：定义一个创建产品对象的工厂接口，将产品对象的实际创建工作推迟到具体子工厂类当中。

概念：

产品：类。
抽象产品：抽象类、接口。
产品簇：是指由同一个工厂生产的，位于不同产品等级结构中的一组产品。
产品等级：产品等级结构即产品的继承结构。

产品簇与产品等级

简单工厂模式（Simple Factory Pattern，不属于23种设计模式之一）

简单工厂模式是工厂模式的一种，也叫“静态工厂模式”。

简单工厂模式

总结

优点：简单易懂。
缺点：工厂类单一，代码臃肿，违背高聚合原则。
缺点：新增一个产品，就要增加一个具体产品类，修改工厂逻辑；增加系统的复杂度，违背“开闭原则”。
结论：对于产品种类相对较少且趋于不变的情况，可以考虑使用。

工厂方法模式（Factory Pattern，这个对应GoF的工厂模式）

工厂方法模式

总结

优点：创建新产品只需多写一个相应的产品类、工厂类，无需修改之前的代码；完美符合“开闭原则”。
缺点：产品增多时，类会爆炸式增长；一个抽象工厂只能生产一种产品（抽象工厂模式解决）。
结论：只有一个产品等级且产品种类在一定数量内时，可以考虑使用。

抽象工厂模式（Abstract Factory Pattern）

抽象工厂模式

总结

优点：把工厂类的数量减少了。无论多少个产品等级，抽象工厂类就一个，工厂类就一套！
抽象工厂中，生产的多个产品之间必须有内在联系，即产品簇。
缺点：产品等级发生变化（增删），需要修改以前的所有工厂代码，违反了“开闭原则”。
结论：当产品等级比较固定时，可以考虑使用抽象工厂模式；如果产品等级经常变化，则不建议使用抽象工厂模式。

3. 原型模式（Prototype Pattern）

定义：用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。

浅拷贝

实现Cloneable接口。
重写Object的clone方法，修改访问权限修饰符为public。

public class ShallowClone implements Cloneable{
    private String name;
    private Date birthday; // 引用对象

    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

总结

优点：简单，能实现基本的拷贝。
缺点：拷贝对象与原对象中的引用对象指向同一个内存地址，任何一个副本修改引用对象中的属性都会影响其他副本。
结论：不推荐使用。

深拷贝（重写clone方法）
浅拷贝的基础上，在clone方法中处理引用对象的拷贝。

public class DeepClone implements Cloneable{
    private String name;
    private Date birthday;
    public void setBirthday(Date birthday) {this.birthday = birthday;}
    public Date getBirthday() {return birthday;}
    @Override
    public Object clone() throws CloneNotSupportedException {
        DeepClone cloneObj = (DeepClone)super.clone();
        Date copyDate = (Date)cloneObj.getBirthday().clone();
        cloneObj.setBirthday(copyDate);
        return cloneObj;
    }
}

总结

优点：解决了浅拷贝的问题。
缺点：当引用对象有很多层时（即引用对象里面还有引用对象），重写clone方法的工作量非常大！
结论：不推荐使用。

深拷贝（序列化）

实现Cloneable接口，Serializable接口。
重写Object的clone方法为：把当前对象写入到内存，然后从内存反序列化对象；修改访问权限修饰符为public。

public class DeepClone implements Cloneable, Serializable {
    @Override
    public Object clone() {
        try {
            // 对象写到内存
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(bos);
            oos.writeObject(this);
            oos.close();

            // 从内存中取数据
            byte[] bytes = bos.toByteArray();

            ByteArrayInputStream bis = new ByteArrayInputStream(bytes);
            ObjectInputStream ois = new ObjectInputStream(bis);
            Object cloneObj = ois.readObject();
            ois.close();
            return cloneObj;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}