設計模式----------工廠(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 }