创建型设计模式

设计模式分为总的来说分为三大类
创建型模式：五种，工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式
结构型模式：七种，适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式
行为模式：十一种，策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介模式、解释器模式

首先介绍创建模式，创建模式主要是在创建对象时运用到的设计模式
****************************工厂方法模式，顾名思义就是像工厂一样创建出大量的对象***********************
//普通工厂模式//
//产品接口1
public interface IProduce{  
    public void Make();  
}  
//产品1实现类：
public class CProduce1 implements IProduce {     
    public void Make() {  
        System.out.println("this is produce1!");  
    }  
}  
//产品2实现类：
public class CProduce2 implements IProduce {     
    public void Make() {  
        System.out.println("this is produce2!");  
    }  
} 
//建工厂类:
public class ProduceFactory {  
  
    public IProduce produce(int type) {  
        if (type == 1) {  
            return new CProduce1();  
        } else if (type == 2) {  
            return new CProduce2();  
        } else {  
            System.out.println("请输入正确的类型!");  
            return null;  
        }  
    }  
}  
//测试类：
public class FactoryTest {    
    public static void main(String[] args) {  
        ProduceFactory factory = new ProduceFactory();  
        IProduce produce = factory.produce(1);  
        produce.Make();  
    }  
}  

多种产品继承产品接口，然后通过产品工厂根据需要的类型返回对应的产品

//多个工厂方法模式//

//建工厂类:产品1的工厂
public class ProduceFactory1 {  
  
    public IProduce produce() {       
            return new CProduce1();         
    }  
}  
//建工厂类:产品2的工厂
public class ProduceFactory2 {  
  
    public IProduce produce() {       
            return new CProduce2();         
    }  
} 
//测试类：
public class FactoryTest {    
    public static void main(String[] args) {  
        ProduceFactory2 factory = new ProduceFactory2();  
        IProduce produce = factory.produce();  
        produce.Make();  
    }  
}  
多个工厂方法模式即一种产品对应一个工厂，分开生产
//静态工厂模式//
//建工厂类:
public class ProduceFactory {  
  
    public static IProduce produce(int type) {  
        if (type == 1) {  
            return new CProduce1();  
        } else if (type == 2) {  
            return new CProduce2();  
        } else {  
            System.out.println("请输入正确的类型!");  
            return null;  
        }  
    }  
}  
//测试类：
public class FactoryTest {    
    public static void main(String[] args) {          
        IProduce produce = ProduceFactory.produce(1);  
        produce.Make();  
    }  
}  

静态工厂方法就是将工厂的创建方法设置为静态，可以不用每次生产时都创建工厂类，直接用静态方法调用，减少工厂类构造与析构的开销

 

****************************抽象工厂模式***********************
当产品中设计到多种分类时，不是继承同一个接口，多种产品就得用到抽象工厂，建立多个工厂类，简单工厂中也有一种多个工厂方法模式，但是他是只有一条产品线都是继承IProduce,抽象工厂有多种产品基类
//产品接口1
public interface IProduce{  
    public void Make();  
}  
//产品1实现类：
public class CProduce1 implements IProduce {     
    public void Make() {  
        System.out.println("this is produce1!");  
    }  
}  
//产品接口2
public interface IProduce2{  
    public void Make();  
} 
//产品2实现类：
public class CProduce2 implements IProduce2 {     
    public void Make() {  
        System.out.println("this is produce2!");  
    }  
} 
//建产品1工厂类:
public class ProduceFactory {    
    public IProduce produce() {  
           return new CProduce1();       
    }  
}  
//建产品2工厂类:
public class ProduceFactory2 {    
    public IProduce2 produce() {  
           return new CProduce2();       
    }  
}
//测试类：
public class FactoryTest {    
    public static void main(String[] args) {  
        ProduceFactory factory = new ProduceFactory();  
        IProduce produce = factory.produce();  
        produce.Make();  
    }  
}  
****************************单例模式***********************
单例模式即保证该对象只有一个实例存在，不用频繁的创建与销毁对象
public class Singleton {      
    private static Singleton instance = null;    
    /* 私有构造方法，防止被实例化 */  
    private Singleton() {  
    }    
    /* 静态方法，创建实例 */  
    public static Singleton getInstance() {  
        if (instance == null) {  
            instance = new Singleton();  //此处创建时非线程安全，在多线程中使用的加上锁
        }  
        return instance;  
    }       

}   

****************************建造者模式***********************
当一个实例需要多个组件组成，即将多种功能集中到一个类中，可以使用建造者模式
//建造者类
public class Builder {        
    private List<IProduce> list = new ArrayList<IProduce>();        
    public void produce1(int count){  
        for(int i=0; i<count; i++){  
            list.add(new CProduce1());  
        }  
    }        
    public void produce2(int count){  
        for(int i=0; i<count; i++){  
            list.add(new CProduce2());  
        }  
    }  
} 
 
//测试类:
public class Test {    
    public static void main(String[] args) {  
        Builder builder = new Builder();  
        builder.produce1(10);  
    }  
}  


***************************原型模式***********************
即拷贝一个对象，拷贝分为浅拷贝与深拷贝，浅拷贝的引用类型与指针没有重新构建新的内存空间，指向原来的地址，深拷贝则有新的地址空间指向新的地址
//拷贝接口
public interface IClone{  
    public IClone clone();  
}

//实现类
public class CClone{  
    public IClone clone(){
return new CClone();} 
}