前情提要    

        在上篇文章中介紹了面向物件程式設計的七個基本原則，分別是單一職責，裡式替換、依賴注入、介面分離、迪米特原則、開閉原則、優先使用組合而不是繼承原則。

    本文重點

1.  工廠模式
2. 單例模式
3. 建造者模式

    工廠模式，工廠模式又分為簡單工廠、工廠方法、抽象工廠。工廠模式要實現的是將使用者與具體實現分離。

    1.簡單工廠

     角色：使用者，例項工廠（或者靜態工廠），抽象產品和產品實現。類圖如下

實現程式碼：

public class CarFactory{
public Car createCar(String name){
if("BMW".equals()){
return new BMW("BMW");
}
if("BENZ".equals()){
return new BENZ("BENZ");
}
}
}


public interface Car{
void run();
}


public class BMW implements Car{
private String name;
public BMW(String name){
this.name = name;
}

public void run(){
System.out.println(name + "開始行駛了...");
}
}


public class BENZ implements Car{
private String name;
public BENZ(String name){
this.name = name;
}
public void run(){
System.out.println(name + "開始行駛了...");
}
}


public class Driver{
public void drive(){
Car bmw = CarFactory.createCar("BMW");
Car benz = CarFactory.createCar("BENZ");
bmw.run();
benz.run();
}

}

使用場景

代替new產生物件時，產品的型別比較少時。

缺點

不符合開閉原則，當新加產品型別的時候，就需要修改工廠中的建立的程式碼。

工廠方法模式：

角色：抽象工廠，抽象工廠實現，抽象產品，產品，使用者

類圖，略。

程式碼實現：

public class ICarFactory{
Car createBMWCar();

Car createBENZCar();
}


public class CarFactory implements ICarFactory{
public Car createBMWCar(){
return new BMW("BMW");
}

public Car createBENZCar(){
return new BENZ("BENZ");
}
}


public interface Car{
void run();
}


public class BMW implements Car{
private String name;
public BMW(){
this.name =  "BMW";
}

public void run(){
System.out.println(name + "開始行駛了...");
}
}


public class BENZ implements Car{
private String name;
public BENZ(){
this.name = "BENZ";
}
public void run(){
System.out.println(name + "開始行駛了...");
}
}


public class Driver{
public void drive(){
Car bmw = CarFactory.createBMWCar();
Car benz = CarFactory.createBENZCar();
bmw.run();
benz.run();
}

}

這樣修改簡單工廠之後就可以滿足開閉原則了。

使用場景：系統產品包含多個產品族，每個產品族又有一系列產品，每次系統只使用一種產品族的產品。

主要缺點：產品族擴充套件比較難，需要修改的地方較多。

抽象工廠模式

角色：同工廠方法

類圖：略

實現程式碼：

public interface PCFactory{

    Cpu createCpu(String name);

    KeyBoard createKeyBoard(String name);

}

LenovoPCFactory implements PCFactory{

    public Cpu createCpu(){

        return LenovoCPU（）；

    }

public KeyBoard createKeyBoard (){

        return LenovoKeyBoard （）；

    }

}

MACPCFactory implements PCFactory{

    public Cpu createCpu(){

        return MACCPU（）；

    }

public KeyBoard createKeyBoard (){

        return MACKeyBoard （）；

    }

}

public interface Cpu{

}

public class LenovoCpu implements Cpu{

}

public class MACCpu implements Cpu{

}

public interface KeyBoard{

}

public class LenovoKeyBoard implements KeyBoard{

}

public class MACKeyBoard implements KeyBoard{

}

public class Test{

    public static void main(String[] args){

        MACPCFactory.createCpu();

        LenovoPCFactory.createCpu();

        LenovoPCFactory.createKeyBoard();

        MACPCFactory.createKeyBoard();

    }

}

單例模式：

使用場景：全域性只需要一個該物件，該物件的初始化比較耗費資源。

程式碼實現：

餓漢式：


public class Single{
private static final Single instance = new Single();

private Single(){

}


public static final Single getInstance(){
return instance;
}
}


懶漢式：


public class Single{
private volatile Single instance;

public Single(){
if(instance == null){
synchronized(this){
instance = new Single();
}
}else{
return instance;
}
}


public static final Single getInstance(){
return instance;
}
}




內部類同時具備餓漢式和懶漢式有點的實現


public class Single{
private Single(){
}

//靜態內部類由虛擬機器負責執行緒安全
private static class SingleHolder{
private static final Single instance = new Single();
}

public static final Single getInstance(){
return SingleHolder.instance;
}

}

建造者模式：

使用場景：如果一個物件比較的複雜，又比較關注產品構造的細節。與工廠模式的主要區別是工廠模式關注產品整體，也就是說只要造出產品即可，通常產品的屬性比較少；而建造模式關注產品製造的細節，屬性比較多複雜。

程式碼實現：

public interface Packing {
   public String pack();

}

public interface Item {
   public String name();
   public Packing packing();
   public float price();    

}

public interface Item {
   public String name();
   public Packing packing();
   public float price();    

}

public class Bottle implements Packing {
   @Override
   public String pack() {
      return "Bottle";
   }

}

public abstract class Burger implements Item {


   @Override
   public Packing packing() {
      return new Wrapper();
   }


   @Override
   public abstract float price();
}


public abstract class ColdDrink implements Item {


    @Override
    public Packing packing() {
       return new Bottle();
    }


    @Override
    public abstract float price();
}


public class VegBurger extends Burger {


   @Override
   public float price() {
      return 25.0f;
   }


   @Override
   public String name() {
      return "Veg Burger";
   }
}


public class ChickenBurger extends Burger {


   @Override
   public float price() {
      return 50.5f;
   }


   @Override
   public String name() {
      return "Chicken Burger";
   }
}


public class Coke extends ColdDrink {


   @Override
   public float price() {
      return 30.0f;
   }


   @Override
   public String name() {
      return "Coke";
   }
}


public class Pepsi extends ColdDrink {


   @Override
   public float price() {
      return 35.0f;
   }


   @Override
   public String name() {
      return "Pepsi";
   }
}


public class Meal {
   private List<Item> items = new ArrayList<Item>();    


   public void addItem(Item item){
      items.add(item);
   }


   public float getCost(){
      float cost = 0.0f;
      for (Item item : items) {
         cost += item.price();
      }        
      return cost;
   }


   public void showItems(){
      for (Item item : items) {
         System.out.print("Item : "+item.name());
         System.out.print(", Packing : "+item.packing().pack());
         System.out.println(", Price : "+item.price());
      }        
   }    
}


public class MealBuilder {


   public Meal prepareVegMeal (){
      Meal meal = new Meal();
      meal.addItem(new VegBurger());
      meal.addItem(new Coke());
      return meal;
   }   


   public Meal prepareNonVegMeal (){
      Meal meal = new Meal();
      meal.addItem(new ChickenBurger());
      meal.addItem(new Pepsi());
      return meal;
   }
}


public class Test {
   public static void main(String[] args) {
      MealBuilder mealBuilder = new MealBuilder();


      Meal vegMeal = mealBuilder.prepareVegMeal();
      System.out.println("Veg Meal");
      vegMeal.showItems();
      System.out.println("Total Cost: " +vegMeal.getCost());


      Meal nonVegMeal = mealBuilder.prepareNonVegMeal();
      System.out.println("\n\nNon-Veg Meal");
      nonVegMeal.showItems();
      System.out.println("Total Cost: " +nonVegMeal.getCost());
   }

}

其中建造者模式程式碼引用http://www.runoob.com/design-pattern/builder-pattern.html一節建造者模式。