工厂模式

简单工厂模式

1. 目的 
        工厂模式就是专门负责将大量有共同接口的类实例化,而且不必事先知道每次是要实例化哪一个类的模式。它定义一个用于创建对象的接口，由子类决定实例化哪一个类。
2 . 简单工厂模式的结构 
 

3. 一个简单例子

// 产品接口 
  public   interface  Product  { 

      public   void  getName() ; 

}  
// 具体产品A 
  public   class  ProductA  implements  Product  { 

  public   void  getName()  { 
       System.out.println( "  I am ProductA  "  ); 
  }  

}  
// 具体产品B 
  public   class  ProductB  implements  Product  { 

    public   void  getName()  { 
         System.out.println( "  I am ProductB  "  ); 
  }  

}  
//  工厂类 
  public   class  ProductCreator  { 

public static Product createProduct(String type)  { 
      if  (  " A " .equals(type) )  { 
             return   new  ProductA(); 
    }  
     if  (  " B " .equals(type) )  { 
           return   new  ProductB(); 
   }  
    else  
          return   null ; 
}  

public   static   void  main(String[] args)  { 
      ProductCreator creator  =   new  ProductCreator(); 
      creator.createProduct( " A " ).getName(); 
      creator.createProduct( " B " ).getName(); 
  }  
}  

4. 小结工厂模式的适用范围
• 在编码时不能预见需要创建哪一种类的实例。
• 一个类使用它的子类来创建对象。
• 开发人员不希望创建了哪个类的实例以及如何创建实例的信息暴露给外部程序。 

 

 

抽象工厂模式

 

1. 抽象工厂模式可以说是简单工厂模式的扩展，它们主要的区别在于需要创建对象的复杂程度上。
在抽象工厂模式中，抽象产品可能是一个或多个，从而构成一个或多个产品族。 在只有一个产品族的情况下，抽象工厂模式实际上退化到工厂方法模式。
2. 抽象工厂模式的结构 

3. 一个简单例子

//  产品 Plant接口 
  public   interface  Plant  { 
}  
// 具体产品PlantA，PlantB 
  public   class  PlantA  implements  Plant  { 

   public  PlantA ()  { 
    System.out.println( " create PlantA ! " ); 
  }  

   public   void  doSomething()  { 
     System.out.println( "  PlantA do something  " ); 
  }  
}  
public   class  PlantB  implements  Plant  { 
   public  PlantB ()  { 
     System.out.println( " create PlantB ! " ); 
  }  

   public   void  doSomething()  { 
     System.out.println( "  PlantB do something  " ); 
  }  
}  
//  产品 Fruit接口 
  public   interface  Fruit  { 
}  
// 具体产品FruitA，FruitB 
  public   class  FruitA  implements  Fruit  { 
   public  FruitA()  { 
    System.out.println( " create FruitA ! " ); 
  }  
   public   void  doSomething()  { 
    System.out.println( "  FruitA do something  " ); 
  }  
}  
public   class  FruitB  implements  Fruit  { 
   public  FruitB()  { 
    System.out.println( " create FruitB ! " ); 
  }  
   public   void  doSomething()  { 
    System.out.println( "  FruitB do something  " ); 
  }  
}  
//  抽象工厂方法 
  public   interface  AbstractFactory  { 
   public  Plant createPlant(); 
   public  Fruit createFruit() ; 
}  
// 具体工厂方法 
  public   class  FactoryA  implements  AbstractFactory  { 
   public  Plant createPlant()  { 
     return   new  PlantA(); 
  }  
   public  Fruit createFruit()  { 
     return   new  FruitA(); 
  }  
}  
public   class  FactoryB  implements  AbstractFactory  { 
   public  Plant createPlant()  { 
     return   new  PlantB(); 
  }  
   public  Fruit createFruit()  { 
     return   new  FruitB(); 
  }  
}  

4. 小结
在以下情况下，应当考虑使用抽象工厂模式。
首先，一个系统应当不依赖于产品类实例被创立，组成，和表示的细节。这对于所有形态的工厂模式都是重要的。
其次，这个系统的产品有多于一个的产品族。
第三，同属于同一个产品族的产品是设计成在一起使用的。这一约束必须得在系统的设计中体现出来。
最后，不同的产品以一系列的接口的面貌出现，从而使系统不依赖于接口实现的细节。
其中第二丶第三个条件是我们选用抽象工厂模式而非其它形态的工厂模式的关键性条件。