【設計模式】——抽象工廠Abstract Factory

模式意圖

　　提供對象的使用接口，隱藏對象的建立過程。

模式結構

AbstractFactory 提供建立對象的接口。

ConcreteFactory 提供真正建立對象的實現類，用於組合並建立不一樣的對象，實現一個產品族。

AbstractProduct 提供對象的使用接口。

ConcreteProduct 提供真正的適用對象，隱藏該對象的建立過程，是工廠建立的對象。

Client 使用者，經過抽象工廠接口，使用不一樣的具體工廠方法建立對象組合，從而直接使用對象，無需關注對象的建立過程。

 

適合場景

　　1 系統獨立於它的產品建立、組合和表示。即無需關心內部對象時如何建立的，怎麼建立的，什麼含義。

　　2 系統須要多個產品組合中的一個配置。因爲對象不少，可以組合出的組合很是多，而系統只是使用某一個組合。

　　3 強調的對象的組合結果，而不是他們具體的接口和實現。

 

代碼結構

　　AbstractFactory.java

interface AbstractFactory {
    public AbstractProductA CreateProductA();
    public AbstractProductB CreateProductB();
}

　　ConcreteFactory.java

class ConcreteFactory1 implements AbstractFactory{

    @Override
    public AbstractProductA CreateProductA() {
        return new ConcreteProductA1();
    }

    @Override
    public AbstractProductB CreateProductB() {
        return new ConcreteProductB1();
    }

}

　　AbstractProduct.java

interface AbstractProductA {
    public void use();
}
interface AbstractProductB {
    public void use();
}

　　ConcreteProduct.java

class ConcreteProductA1 implements AbstractProductA{

    @Override
    public void use() {
        // TODO Auto-generated method stub
        System.out.println("use A1 product!");
    }

}
class ConcreteProductB1 implements AbstractProductB{

    @Override
    public void use() {
        // TODO Auto-generated method stub
        System.out.println("use B1 product!");
    }

}

　　使用方式

    public static void main(String[] args){
        AbstractProductA pa;
        AbstractProductB pb;
        
        AbstractFactory fa1 = new ConcreteFactory1();
        pa = fa1.CreateProductA();
        pb = fa1.CreateProductB();
        pa.use();
        pb.use();
        
        AbstractFactory fa2 = new ConcreteFactory2();
        pa = fa2.CreateProductA();
        pb = fa2.CreateProductB();
        pa.use();
        pb.use();
        
    }

　　所有代碼

 1 package com.designer;
 2 interface AbstractFactory {
 3     public AbstractProductA CreateProductA();
 4     public AbstractProductB CreateProductB();
 5 }
 6 interface AbstractProductA {
 7     public void use();
 8 }
 9 interface AbstractProductB {
10     public void use();
11 }
12 class ConcreteFactory1 implements AbstractFactory{
13 
14     @Override
15     public AbstractProductA CreateProductA() {
16         return new ConcreteProductA1();
17     }
18 
19     @Override
20     public AbstractProductB CreateProductB() {
21         return new ConcreteProductB1();
22     }
23 
24 }
25 class ConcreteFactory2 implements AbstractFactory{
26 
27     @Override
28     public AbstractProductA CreateProductA() {
29         return new ConcreteProductA2();
30     }
31 
32     @Override
33     public AbstractProductB CreateProductB() {
34         return new ConcreteProductB2();
35     }
36 
37 }
38 class ConcreteProductA1 implements AbstractProductA{
39 
40     @Override
41     public void use() {
42         // TODO Auto-generated method stub
43         System.out.println("use A1 product!");
44     }
45 
46 }
47 class ConcreteProductA2 implements AbstractProductA{
48 
49     @Override
50     public void use() {
51         // TODO Auto-generated method stub
52         System.out.println("use A2 product!");
53     }
54 
55 }
56 class ConcreteProductB1 implements AbstractProductB{
57 
58     @Override
59     public void use() {
60         // TODO Auto-generated method stub
61         System.out.println("use B1 product!");
62     }
63 
64 }
65 class ConcreteProductB2 implements AbstractProductB{
66 
67     @Override
68     public void use() {
69         // TODO Auto-generated method stub
70         System.out.println("use B2 product!");
71     }
72 
73 }
74 public class Client {
75     public static void main(String[] args){
76         AbstractProductA pa;
77         AbstractProductB pb;
78         
79         AbstractFactory fa1 = new ConcreteFactory1();
80         pa = fa1.CreateProductA();
81         pb = fa1.CreateProductB();
82         pa.use();
83         pb.use();
84         
85         AbstractFactory fa2 = new ConcreteFactory2();
86         pa = fa2.CreateProductA();
87         pb = fa2.CreateProductB();
88         pa.use();
89         pb.use();
90         
91     }
92 }

View Code

生活中的設計模式

　　在生活中，咱們常常會碰到使用一系列東西的時候。好比，咱們願意吃炸雞配啤酒，喜歡吃爆米花配可樂。咱們不關心炸雞怎麼炸的，啤酒怎麼釀的，爆米花怎麼爆的，而只關心咱們吃什麼，喝什麼，這就是典型的抽象工廠。 

　　例如，大部分程序猿們都有吃早餐的習慣，固然不少人喜歡睡懶覺也來不及吃，可是爲了身體健康，仍是要按時吃飯才行！扯遠了...

　　有人喜歡吃中式的，有人喜歡吃西式的。那麼去食堂咱們不會去問，包子怎麼作的，麪包怎麼烤的，僅僅是付費吃飯而已。而中式通常是豆漿油條，西式麪包牛奶。這種搭配已經造成了一種習慣，也就是默認的產品組合。

　　所以，咱們在買單時，只要指定早餐的樣式，就能夠了。下面就是咱們吃早餐，使用早餐工廠的流程...

interface BreakfastFactory{
    public StapleFood MakeStapleFood();
    public Drinks MakeDrinks();
}
interface StapleFood{
    public void eating();
}
interface Drinks{
    public void drinking();
}
class BreakfastCStyle implements BreakfastFactory{

    @Override
    public StapleFood MakeStapleFood() {
        return new DeepFriedDoughSticks();
    }

    @Override
    public Drinks MakeDrinks() {
        return new SoybeanMilk();
    }
    
}
class BreakfastWStyle implements BreakfastFactory {

    @Override
    public StapleFood MakeStapleFood() {
        return new Bread();
    }

    @Override
    public Drinks MakeDrinks() {
        return new Milk();
    }

}
class DeepFriedDoughSticks implements StapleFood{
    @Override
    public void eating() {
        System.out.println("我在吃油條！...");
    }
}
class SoybeanMilk implements Drinks{
    @Override
    public void drinking() {
        System.out.println("我在喝豆漿！...");
    }
}
class Bread implements StapleFood{
    @Override
    public void eating() {
        System.out.println("我在吃麪包！...");
    }
}
class Milk implements Drinks{
    @Override
    public void drinking() {
        System.out.println("我在喝牛奶！...");
    }
}
public class Breakfast{
    public static void main(String[] args){
        StapleFood sf;
        Drinks dk;
        System.out.println("——————————————————第一天——————————————————————————");
        System.out.println("我要吃中式早餐");
        BreakfastFactory bf1 = new BreakfastCStyle();
        sf = bf1.MakeStapleFood();
        dk = bf1.MakeDrinks();
        sf.eating();
        dk.drinking();
        System.out.println("——————————————————次日——————————————————————————");
        System.out.println("我要吃西式早餐");
        BreakfastFactory bf2 = new BreakfastWStyle();
        sf = bf2.MakeStapleFood();
        dk = bf2.MakeDrinks();
        sf.eating();
        dk.drinking();
    }
}

　　能夠看到，很是方便的就遲到了中式和西式的早餐，而省掉了大量炸油條，烤麪包的時間。

——————————————————第一天——————————————————————————
我要吃中式早餐
我在吃油條！...
我在喝豆漿！...
——————————————————次日——————————————————————————
我要吃西式早餐
我在吃麪包！...
我在喝牛奶！...

　　這就是一個簡單的抽象工廠的使用。

【轉載聲明】: by xingoo