设计模式之工厂模式

工厂设计模式分为三种模式：简单工厂模式、工厂方法模式和抽象工厂模式。

什么是简单工厂模式？
举个例子：假设现在有一个造纸的工厂，我不管你是怎么生产的，只要我向这个工厂要A4纸，这个工厂就能给我A4纸，我要B5类型的纸，你就给我B5类型的纸；
这种将类的实例化交给工厂来实现，客户端不用关心实现细节的方式就是简单工厂模式；

我们用个类图来说明一下这个简单工厂模式：

代码实现：

  import java.util.Scanner;           
    //抽象产品类
  interface Paper {              
       void creatPaper();                    
	   }     
	   //具体产品类   
  class A4Paper implements Paper {             
    @Override             
	   public void creatPaper() {                  
	       System.out.println("A4 纸");                
		   }              
		  } 
   class B5Paper implements Paper {                  
    @Override                   
	   public void creatPaper() {                    
	       System.out.println("B5 纸");                  
		   }                
		  } 
	//工厂类
   class PaperFactory {              
       public static Paper getInstance(String type){                 
	       Paper paper = null;                    
		   if(type.equals("A4")){                      
		     paper = new A4Paper();                     
			 }else if(type.equals("B5")){                       
			   paper = new B5Paper();                     
			   }                   
		   return paper;                   
		   }                 
		  }     
	//客户端
   public class Client {           
       public void buyPaper(Paper paper){             
	    paper.creatPaper();               
		 } 
       public static void main(String[] args) {         
	      Client client = new Client();         
		  Scanner scanner = new Scanner(System.in);         
		  System.out.println("请您输入您想要的纸的类型：");         
		  String type = scanner.nextLine();         
		  client.buyPaper( PaperFactory.getInstance(type));             
		  }          
		} 

什么是工厂方法模式？
工厂方法模式相比简单工厂模式就是将工厂抽象，有多个具体的工厂类来实现这个抽象工厂，客户端想要哪个产品，抽象工厂就去该工厂去要这个产品，比如说，现在有A4型的造纸厂，还有B5型的造纸厂，客户端要A4纸的时候，抽象工厂就去向A4造纸厂去要A4纸，然后由A4工厂造A4纸；

类图：

代码实现：

    //抽象产品类
 interface Paper {       
    void creatPaper();       
	}   
	//具体产品类  
  class A4Paper implements Paper {     
    @Override     
	  public void creatPaper() {         
	   System.out.println("A4 纸");    
	   } 
   }    
  class B5Paper implements Paper {    
    @Override     
	  public void creatPaper() {         
	    System.out.println("B5 纸");     
		}  
	}     
	//抽象工厂类
  interface PaperFactory{     
     Paper createFactory(); 
	 } 
	 //具体工厂类
  class A4Factory implements PaperFactory {     
    @Override     
	 public Paper createFactory() {
	   return new A4Paper();     
	   } 
	  }
  class B5Factory implements PaperFactory {
	 @Override     
	 public Paper createFactory() {         
	    return new B5Paper();     
		} 
	}    
	//客户端
	 public class Client {     
	   public void buyPaper(Paper paper){        
  	   paper.creatPaper();
	   } 
     public static void main(String[] args) {         
	   Client client = new Client();         
	   client.buyPaper(new A4Factory().createFactory());     
	   } 
	  }

再说什么是抽象工厂模式：
抽象工厂模式就是说有多个抽象产品类，比如说，我想要一辆装有宝马发动机的奔驰，这样的产品实现的时候就可以将发动机再抽象出来，有多个类型的发动机来实现这个发动机产品类，每个工厂制造一种车，比如说，有一个专门造带有宝马发动机的奔驰车，这种的就是抽象工厂模式；

类图：
代码实现：

//抽象产品类
 interface  Product{     
    public void method(); 
	} 
 //具体产品类
  class A implements Product{ 
    @Override
	 public void method() {         
	   System.out.println("这是 A");    
	   } 
	 } 
  class B implements Product{ 
    @Override     
	public void method() {
	   System.out.println("这是 B");
	   } 
	 } 
	//抽象产品类
  interface Product2 {    
    void method1(); 
	} 
	//具体产品类
  class C implements Product2 { 
    @Override     
	public void method1() {
	  System.out.println("这是 A 的姊妹产业 C");     
	  }
	} 
   class D implements Product2 { 
    @Override     
	public void method1() {         
	  System.out.println("这是 B 的姊妹产业 D");     
	  } 
	 } 
	//抽象工厂类
   interface Factory {    
     Product creat();    
 	 Product2  recreat(); 
	 } 
	 //具体工厂类
   class Factory1 implements Factory{ 
    @Override    
      public Product creat() {         
	    return new A();    
		} 
    @Override    
	  public Product2 recreat() {         
	    return new C();    
		} 
	} 
   class Factory2 implements Factory { 
    @Override    
      public Product creat() {         
	    return new B();     
		} 
    @Override
	  public Product2 recreat() {        
        return new D();     
		} 
	 }
	 //客户端
   public class Client {
      public void buyProduct(Product  product ){        
    	  product.method();
		  }    
	  public void buyProduct2(Product2  product2 ){        
     	  product2 .method1();     
		  } 

接下来我们看一看这三种模式的优缺点：

这就是这三种工厂模式啦。