设计模式-工厂模式

一，简单工厂模式

简单工厂模式就是由一个工厂类根据传入的参数决定创建哪一种的产品类。
http://blog.sina.com.cn/s/blog_6271df6f0101bdyq.html

public interface people{
      public void say();
}
public class chinese implements people{
      public void say(){
           System.out.println("说中国话");
     }
}
public class american implements people{
      public void say(){
           System.out.println("speak english");
     }
}
public class peopleFactory{
      public static people create(int type){
           if(type==1){
                  return new chinese();
           }else if(type==2){
                 return new american();
           }
     }
 }
public class test{
      public static void main(String []args){
           people p=peopleFactory.create(1);
           p.say();
           p=peopleFactory.create(2);
            p.say();
     }
 }

二，工厂方法模式

工厂方法模式是简单工厂模式的衍生，解决了许多简单工厂模式的问题。
首先完全实现‘开－闭 原则’，实现了可扩展。其次更复杂的层次结构，可以应用于产品结果复杂的场合。 　　
工厂方法模式的对简单工厂模式进行了抽象。有一个抽象的Factory类（可以是抽象类和接口），这个类将不在负责具体的产品生产，而是只制定一些规范，具体的生产工作由其子类去完成。在这个模式中，工厂类和产品类往往可以依次对应。即一个抽象工厂对应一个抽象产品，一个具体工厂对应一个具体产品，这个具体的工厂就负责生产对应的产品。 　　
工厂方法模式(Factory Method pattern)是最典型的模板方法模式(Templete Method pattern)应用。
基于面向接口编程的原理，创建部分成为抽象工厂与实体工厂，创建出的对象成为抽象产品与实体产品。你可能知道为什么它能解决上面的问题了：多了一个新对象，只需添加一套对应的工厂和产品就可以了，不需要修改原代码，或只需进行少量的修改。

public interface Icar{
           public void docar();
} 
public class bwm implements Icar{
          public void docar(){
               System.out.println("我是宝马，别摸我");
          }
}
public class buick implements Icar{
          public void docar(){
               System.out.println("我是别克，很酷");
          }
}
public interface Icarfactory{
          public Icar createCar();
} 
public class bmwFactory implements Icarfactory{
          public Icar createCar(){
                   return new bwm();
          }
} 
public class buickFactory implements Icarfactory{
          public Icar createCar(){
                   return new buick();
          }
} 
public class test{
      public static void main(String []args){
           Icarfactory factory=new bmwFactory();
           Icar bwm= factory.createCar(); 
           bwm.docar();

           factory=new buickFactory();
           Icar buick= factory.createCar(); 
           buick.docar();

     }
 }

三，抽象工厂模式

为创建一组相关或相互依赖的对象提供一个接口，而且无需指定他们的具体类。

interface IProduct1 {  
    public void show();  
}  
interface IProduct2 {  
    public void show();  
}  
class Product1 implements IProduct1 {  
    public void show() {  
        System.out.println("这是1型产品");  
    }  
}  
class Product2 implements IProduct2 {  
    public void show() {  
        System.out.println("这是2型产品");  
    }  
}  
interface IFactory {  
    public IProduct1 createProduct1();  
    public IProduct2 createProduct2();  
}  
class Factory implements IFactory{  
    public IProduct1 createProduct1() {  
        return new Product1();  
    }  
    public IProduct2 createProduct2() {  
        return new Product2();  
    }  
}  
public class Client {  
    public static void main(String[] args){  
        IFactory factory = new Factory();  
        factory.createProduct1().show();  
        factory.createProduct2().show();  
    }  
}  

工厂方法模式：一个抽象产品类，可以派生出多个具体产品类。 　　
一个抽象工厂类，可以派生出多个具体工厂类。
每个具体工厂类只能创建一个具体产品类的实例。

抽象工厂模式：多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。
一个抽象工厂类，可以派生出多个具体工厂类。
每个具体工厂类可以创建多个具体产品类的实例。

区别：工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个。
工厂方法模式的具体工厂类只能创建一个具体产品类的实例，而抽象工厂模式可以创建多个。