设计模式

　　设计模式：一类问题在特定环境下重复出现时的一种成熟的解决方案的核心设计。

　　可分为：创建类（不再直接实例化对象）、结构类（将多个对象组织成更大的结构）、行为类（对象间通信以及控制流程）。

1. 单例模式

　　单例模式：一个类只生产一个实例。

　　为保证该类只生成一个实例，程序不再自由创建该类实例，使用private修饰该类的构造器，将该类的构造器隐藏起来。

　　为提供访问接口，需创建一个public方法，并且用static修饰，以便用类名直接调用。

　　此外，为缓存已创建的对象，需使用一个静态属性来保存已创建的对象实例。

class Singleton{
    // 使用一个类变量缓存已创建的实例
    private static Singleton instance;
    // 将构造器使用private修饰，使其隐藏
    private Singleton(){}
    // 该方法可以假如自定义的控制，保证只生成一个Singleton对象
    public static Singleton getInstance(){
        // 如果instance==null，表明未创建实例，如果instance!=null不会执行，将会返回已创建实例。
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

public class SingletonTest{
    public static void main(String[] args){
        Singleton s1 = Singleton.getInstance();
        Singleton s2 = Singleton.getInstance();
        System.out.println(s1 == s2);
    }
}

 2. 简单工厂

 　　A对象直接调用B对象方法，为A依赖B（硬编码耦合），在代码重构：A不再直接调用B，而是调用C对象方法时，如果应用中很多类的对象都这么调用，修改量巨大。

　　优化：被调用对象类B和C统一实现对外接口，其实现方法统一由工厂类提供，A仅和接口类实现耦合，当系统重构时仅需修改工厂类实现方法即可。

class Good1 {
    public String buy() {
        return "buy good1"; // 购买商品1
    }
}
class Good2 {
    public String buy() {
        return "buy good2"; // 购买商品1
    }
}
public class Test {
    public static void main(String[] args) {
        // 直接调用对象方法
        // Good1 good = new Good1();
        Good2 good = new Good2();
        System.out.println(good.buy());
    }
}

 　　使用简单工厂模式：

class Good1 implements Goods {
    public String buy() {
        return "buy good1"; // 购买商品1
    }
}
class Good2 implements Goods {
    public String buy() {
        return "buy good2"; // 购买商品1
    }
}
interface Goods {
    String buy(); // 实例方法统一接口
}
class SimpleFactory {
    public static Goods getGoods() {
        // 对象实例的生产工厂
        // return new Good1();
        return new Good2();
    }
}

public class SimpleFactoryTest {
    static Goods good;
    SimpleFactoryTest(Goods good) {
        this.good = good;
    }
    public static void main(String[] args) {
        SimpleFactoryTest simFac = new SimpleFactoryTest(SimpleFactory.getGoods());
        System.out.println(good.buy());
    }
}

2. 抽象工厂模式

 　　在简单工厂模式中，在被调用对象发生变化时，需要修改工厂类中实现方法，当创建实例逻辑比较复杂时，修改起来效率不高。

　　优化：将简单工厂类修改为接口，向下耦合具体类B和C时，先为该接口实现两个实现类工厂，分别负责创建对应类的实例。但这样在调用工厂类接口时，需要实现其实现工厂类，使得代码与工厂实现类耦合。为进一步封装，再增加一个工厂生产类，调用哪种工厂类通过参数实现。

class Good1 implements Goods {
    public String buy() {
        return "buy good1"; // 购买商品1
    }
}
class Good2 implements Goods {
    public String buy() {
        return "buy good2"; // 购买商品1
    }
}
interface Goods {
    String buy(); // 实例方法统一接口
}
class Good1Factory implements Factory {
    public Goods getGoods() {
        return new Good1(); // 创建Good1
    }
}
class Good2Factory implements Factory {
    public Goods getGoods() {
        return new Good2(); // 创建Good2
    }
}
interface Factory {
    Goods getGoods(); // 实例创建统一接口
}

public class FactoryTest {
    static Goods good;
    FactoryTest(Goods good) {
        this.good = good;
    }
    public static void main(String[] args) {
        // Factory factory = new Good1Factory();
        Factory factory = new Good2Factory();
        FactoryTest abst = new FactoryTest(factory.getGoods());
        System.out.println(good.buy());
    }
}

　　使用抽象工厂模式：

class Good1 implements Goods {
    public String buy() { return "buy good1"; } // 购买商品1 
}
class Good2 implements Goods {
    public String buy() { return "buy good2"; } // 购买商品1 
}
class Good1Factory implements Factory {
    public Goods getGoods() { return new Good1(); } // 创建Good1
}
class Good2Factory implements Factory {
    public Goods getGoods() { return new Good2(); } // 创建Good2
}
interface Goods { String buy(); } // 实例方法统一接口
interface Factory { Goods getGoods(); } // 实例创建统一接口

class AbstractFactory{
    public static Factory getFactory(String flag){
        if ("Good1".equals(flag)) {
            return new Good1Factory();
        } else {
            return new Good1Factory();
        }
    }
}
public class AbstractFactoryTest {
    Goods good;
    AbstractFactoryTest(Goods good) { this.good = good; }
    public static void main(String[] args) {
        Factory factory = AbstractFactory.getFactory("Good2");
        AbstractFactoryTest test = new AbstractFactoryTest(factory.getGoods());
        System.out.println(test.good.buy());
    }
}

2. 抽象工厂模式