【设计模式】——抽象工厂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

posted @ 2014-10-19 13:35 xingoo 阅读(3101) 评论(8) 编辑收藏举报

刷新页面返回顶部

xingoo