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