設計模式----------工廠(Factory)模式

設計模式----------工廠(Factory)模式

　　做用

　　　　實現了建立者和調用者分離。

　　工廠模式核心/本質：

　　　　實例化對象不在使用new，而是用工廠方法代替。

　　　　將選擇實現類，建立對象統一管理和控制，從而實現調用者和咱們實現類解耦

　工廠模式詳細分類

　　1.簡單工廠模式（用來生產同一等級結構中的任意產品（對於新增的產品，須要覆蓋已有的代碼））

　　　　實現以汽車爲例

 1 //汽車接口
 2 public interface Car {  3     void carName();  4 }  5 
 6 //三個實現類
 7 public class Audi implements Car {  8  @Override  9     public void carName() { 10         System.out.println("I`m Audi Car"); 11  } 12 } 13 
14 public class Benz implements Car { 15  @Override 16     public void carName() { 17         System.out.println("I`m Benz Car"); 18  } 19 } 20 
21 public class BMW implements Car { 22  @Override 23     public void carName() { 24         System.out.println("I`m BMW Car"); 25  } 26 } 27 
28 //測試方法
29 public static void main(String[] args) { 30         Car c1 = new Audi(); 31         Car c2 = new Benz(); 32         Car c3 = new BMW(); 33  c1.carName(); 34  c2.carName(); 35  c3.carName(); 36     }

 　　此時若是須要增長一個類，那麼開發人員又須要new一個對象。

　　解決方案------簡單工廠模式  /  靜態工廠模式

 1 package com.qing.factory;  2 
 3 public class FactoryMethod {  4     /*
 5  解決方案一  6  此時外部調用只須要傳一個名字就可new一個該對象。可是此解決方案需改動方法內部代碼結構  7  違反了開閉原則  8      */
 9     public static Car getCar(String carName){ 10         if(carName == "Audi") { 11             return new Audi(); 12         } else if(carName == "Benz") { 13             return new Benz(); 14         }else if(carName == "BMW") { 15             return new BMW(); 16         }else{ 17             return null; 18  } 19  } 20     /*
21  解決方案二
　　　　　　　　　直接添加get方法獲取對象 22  這種解決方案雖然也違反了開閉原則，但不涉及方法內部代碼結構的改動， 23  在小型解決方案推薦使用此方案 24      */
25     public static Car getAudi(){ 26         return new Audi(); 27  } 28     public static Car getBenz(){ 29         return new Benz(); 30  } 31     public static Car getBMW(){ 32         return new BMW(); 33  } 34     public static void main(String[] args) { 35         Car audi = FactoryMethod.getAudi(); 36  } 37 }

　　2. 工廠方法模式（用來生產同一等級結構中的任意產品（支持增長任意產品） ）

　　　　

 1 //車接口
 2 public interface Car {  3     void carName();  4 }  5 //車工廠接口
 6 public interface CarFactory {  7  Car getCar();  8 }  9 //奧迪車實現類
10 public class Audi implements Car { 11  @Override 12     public void carName() { 13         System.out.println("I`m Audi Car"); 14  } 15 } 16 //奧迪車工廠實現類
17 public class AudiFactory implements CarFactory{ 18  @Override 19     public Car getCar() { 20         return new Audi(); 21  } 22 } 23 //奔馳車實現類
24 public class Benz implements Car { 25  @Override 26     public void carName() { 27         System.out.println("I`m Benz Car"); 28  } 29 } 30 //奔馳車工廠實現類
31 public class BenzFactory implements CarFactory { 32  @Override 33     public Car getCar() { 34         return new Benz(); 35  } 36 } 37 //寶馬車實現類
38 public class BMW implements Car { 39  @Override 40     public void carName() { 41         System.out.println("I`m BMW Car"); 42  } 43 } 44 //寶馬車工廠實現類
45 public class BMWFactory implements CarFactory { 46  @Override 47     public Car getCar() { 48         return new BMW(); 49  } 50 } 51 
52 //測試方法
53 public class MyTest { 54     public static void main(String[] args) { 55         Car c1=new AudiFactory().getCar(); 56         Car c2=new BenzFactory().getCar(); 57         Car c3=new BMWFactory().getCar(); 58  c1.carName(); 59  c2.carName(); 60  c3.carName(); 61  } 62 }

 

　　　　工廠方法模式雖然遵照設計原則，可是從結構複雜度、代碼複雜度、編程複雜度、管理複雜度來講，簡單工廠模式更容易實現。以下圖，實現相同的功能，多了幾個類

　　　　

 

　　3.抽象工廠模式（圍繞一個超級工廠建立其餘工廠，又稱爲其餘工廠的工廠）

　 　　　　直接上代碼，整理手機、電腦、魅族、小米之間的瓜關係

 1 //手機產品接口
 2 public interface Phone {  3     void start();  4     void shutdown();  5 }  6 //魅族手機
 7 public class MezuPhone implements Phone {  8  @Override  9     public void start() { 10         System.out.println("魅族手機開機"); 11  } 12 
13  @Override 14     public void shutdown() { 15         System.out.println("魅族手機關機"); 16  } 17 } 18 //小米手機
19 public class MiPhone implements Phone { 20  @Override 21     public void start() { 22         System.out.println("小米手機開機"); 23  } 24 
25  @Override 26     public void shutdown() { 27         System.out.println("小米手機關機"); 28  } 29 } 30 //電腦產品接口
31 public interface Computer { 32     void start(); 33     void shutdown(); 34 } 35 //魅族電腦
36 public class MezuComputer implements Computer{ 37  @Override 38     public void start() { 39         System.out.println("魅族電腦開機"); 40  } 41 
42  @Override 43     public void shutdown() { 44         System.out.println("魅族電腦關機"); 45  } 46 } 47 //小米電腦
48 public class MiComputer implements Computer { 49  @Override 50     public void start() { 51         System.out.println("小米電腦開機"); 52  } 53 
54  @Override 55     public void shutdown() { 56         System.out.println("小米電腦關機"); 57  } 58 } 59 //產品工廠
60 public interface ProductFactory { 61  Phone getPhone(); 62 
63  Computer getComputer(); 64 } 65 //魅族工廠
66 public class MezuProduct implements ProductFactory { 67  @Override 68     public Phone getPhone() { 69         return new MezuPhone(); 70  } 71 
72  @Override 73     public Computer getComputer() { 74         return new MezuComputer(); 75  } 76 } 77 //小米工廠
78 public class MiProduct implements ProductFactory { 79  @Override 80     public Phone getPhone() { 81         return new MiPhone(); 82  } 83 
84  @Override 85     public Computer getComputer() { 86         return new MiComputer(); 87  } 88 }

 

　　

  

 　　上圖可看出產品工廠（ProductFactory）能夠建立魅族和小米的產品，就能夠分別獲取手機和電腦對象了（能夠把小米和魅族看做產品族，手機和電腦看做是產品系列）。總之一句話，抽象工廠是工廠的工廠

　　 引用一句維基百科的說明：

　　 工廠模式中的每個形態都是針對必定問題的解決方案，工廠方法針對的是多個產品系列結構；而抽象工廠模式針對的是多個產品族結構，一個產品族內有多個產品系列。

 

1 bgftg
2 
3 
4 ger
5 ge
6 
7 gers

View Code

 

工廠模式依賴的原則

開閉原則：一個軟件的實體應當對擴展開放，對修改關閉

依賴倒轉原則：要針對接口編程，不要針對實現編程

迪米特法則：只與直接朋友通訊，避免和陌生人通訊