设计模式理解创建模式

创建模式分为：工厂方法模式、抽象工厂模式、建造者模式、单例模式、原型模式。

1.工厂模式基础：简单工厂模式：

    简单工厂模式的产品是抽象的

   1）先定义产品接口：

public interface Product {
    public void displayProduct();//用于显示产品
}

　2）创建简单工厂类：

public class SimpleFactory {
    public Product produce(String type){
        if( type.equals("A") ) {
            return new AProduct();
        } else if( type.equals("B") ) {
            return new BProduct();
        } else {
            return null;
        }
    }
}

    3）定义一个产品：

public class AProduct implements Product{
    @Override
    public void displayProduct() {
        System.out.println("product A");
    }
}

    4）使用

public class EasyFactoryMode {
    public static void main(String[] args) {
        //创建工厂类
        SimpleFactory simpleFactory = new SimpleFactory();
        //生产产品A
        Product a = simpleFactory.produce("A");
        //显示        
        a.displayProduct();
    }
}

如果要添加一个新产品，需要修改工厂类，修改已有代码，不好。

2.工厂方法模式

    工厂方法模式的产品和工厂都是抽象的，实例化以后，一个实例化工厂对应一个实例化产品

　　1）产品接口

public interface Product {
    public void displayProduct();//用于显示产品
}

　　2) 工厂接口

public interface Factory {
    public Product produce();//生产产品的接口
}

　　3）实例化一个产品

public class AProduct implements Product{
    @Override
    public void displayProduct() {
        System.out.println("A product");
    }
}

　　4）实例化相对应的工厂

public class AFactory implements Factory{
    @Override
    public Product produce() {
        return new AProduct();
    }
}

　　5）使用

public class Main {
    public static void main(String[] args) {
        Factory aFactory = new AFactory();//创建工厂A
        Product aProduct = aFactory.produce();//生产产品A
        aProduct.displayProduct();//显示产品A
    }
}

如果想生产另一种产品，则实例化一个新的产品类和相对应的工厂类即可，不需要修改已有代码。

3.抽象工厂模式

　　当工厂方法模式的抽象产品不是一个，而是多个的时候，就变成了抽象工厂模式。

　　1）产品A的接口

public interface ProductA {
    public void displayProductA();//用于显示产品
}

　　2）产品B的接口

public interface ProductB {
    public void displayProductB();//用于显示产品
}

　　3）工厂的接口

public interface Factory {
    public ProductA produceA();
    public ProductB produceB();
}

　　4）产品A的实例

public class ProductA_Model1 implements ProductA{
    @Override
    public void displayProductA() {
        System.out.println("ProductA_Model1");
    }
}

　　5）产品B的实例

public class ProductB_Model1 implements ProductB{
    @Override
    public void displayProductB() {
        System.out.println("ProductB_Model1");
    }
}

　　6）生产model1的工厂实例

public class FactoryModel1 implements Factory{

    @Override
    public ProductA produceA() {
        return new ProductA_Model1();
    }

    @Override
    public ProductB produceB() {
        return new ProductB_Model1();
    }

}

　　7）使用

public class Main {
    public static void main(String [] args){
        Factory model1 = new FactoryModel1();
        ProductA a = model1.produceA();
        a.displayProductA();
        ProductB b = model1.produceB();
        b.displayProductB();
    }
}

如果想加入一个新型号model2，则只需添加工厂model2实例，产品A和B的model2的实例即可，不需要修改已有代码。

4.建造者模式

　　抽象方法模式的引申：

　　　　1.当产品很多的时候，抽象工厂方法对于使用者来说就过于繁琐了；

　　　　2.当产品生产需要有先后顺序的要求的时候，抽象方法的使用者要知道的东西太多了。

　　所以需要一个建造者来专门管生产。

　　1）再建立一个产品接口C并实例化

public interface ProductC {
    public void displayProduceC();//用于显示产品
}

public class ProductC_Model1 implements ProductC{
    @Override
    public void displayProduceC() {
        System.out.println("ProductC_Model1");
    }
}

　　2）factory接口要增加生产C产品，并实例化

public interface Factory {
    public ProductA produceA();
    public ProductB produceB();
    public ProductC productC();
}

public class FactoryModel1 implements Factory{

    @Override
    public ProductA produceA() {
        return new ProductA_Model1();
    }

    @Override
    public ProductB produceB() {
        return new ProductB_Model1();
    }

    @Override
    public ProductC productC() {
        return new ProductC_Model1();
    }

}

　　3）builder实现，有生产的个数num，并且有生产顺序 A->C->B

public class BuilderModel1 {
    public void produceModel1(int num){
        Factory f1 = new FactoryModel1();
        for( int i=0; i<num; i++ ) {
            ProductA a = f1.produceA();
            a.displayProductA();
            
            ProductC c = f1.productC();
            c.displayProduceC();
            
            ProductB b = f1.produceB();
            b.displayProductB();
        }
    }
}

　　4）使用

public class Main {
    public static void main(String [] args){
        BuilderModel1 builderModel1 = new BuilderModel1();
        builderModel1.produceModel1(10);
    }
}

这样对于使用者来说只需要找相应的builder即可，当创建的因素多的时候，有必要抽象出一个builder接口出来。

5.单例模式

单例模式是让类自身保存自己的唯一实例.有以下几种:

　　1)懒汉模式

    public class Singleton {  
        private static Singleton instance;  
        private Singleton (){}  
      
        public static Singleton getInstance() {  
        if (instance == null) {  
            instance = new Singleton();  //延时加载,是在需要的时候才创建对象,所以叫懒汉模式
        }  
        return instance;  
        }  
    }  

由于没有同步,在多线程情况下是不安全的.

　　2)饿汉模式

    public class Singleton {  
        private static Singleton instance = new Singleton();  //在虚拟机启动的时候就会创建,和懒汉模式的区别
        private Singleton (){}  
        public static Singleton getInstance() {  
        　　return instance;  
        }  
    }  

基于classloder机制避免了多线程的同步问题

6.原型模式, 就像是现实生活中的复印

原型模式主要用于对象的复制,通过拷贝创建对象。分为深拷贝与浅拷贝。

Object类的clone方法只会拷贝对象中的基本的数据类型，对于数组、容器对象、引用对象等都不会拷贝，这就是浅拷贝。

如果要实现深拷贝，必须将原型模式中的数组、容器对象、引用对象等另行拷贝。