设计模式-抽象工厂模式

1.为什么需要抽象工厂模式：

　　提供对象的使用接口，隐藏对象的创建过程。

2.类图结构：

      

3.参与角色

AbstractFactory 提供创建对象的接口。 ConcreteFactory 提供真正创建对象的实现类，用于组合并创建不同的对象，实现一个产品族。 AbstractProduct 提供对象的使用接口。 ConcreteProduct 提供真正的适用对象，隐藏该对象的创建过程，是工厂创建的对象。 Client 使用者，通过抽象工厂接口，使用不同的具体工厂方法创建对象组合，从而直接使用对象，无需关注对象的创建过程。

4.适用场景

   1 系统独立于它的产品创建、组合和表示。即无需关心内部对象时如何创建的，怎么创建的，什么含义。

　　2 系统需要多个产品组合中的一个配置。由于对象很多，能够组合出的组合非常多，而系统只是使用某一个组合。

　　3 强调的对象的组合结果，而不是他们具体的接口和实现。

5.Demo

产品接口及具体产品类

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

Engine.java package org.factory.abstractFactory;   public interface Engine {     void run();     void start(); } class LuxuryEngine implements Engine{       @Override     public void run() {         System.out.println("转的快！");     }       @Override     public void start() {         System.out.println("启动快!可以自动启停！");     }       }   class LowEngine implements Engine{           @Override     public void run() {         System.out.println("转的慢！");     }           @Override     public void start() {         System.out.println("启动慢!");     }       }

 1 Seat.java
 2 package org.factory.abstractFactory;
 3 
 4 public interface Seat {
 5     void massage();
 6 }
 7 
 8 class LuxurySeat implements Seat {
 9 
10     @Override
11     public void massage() {
12         System.out.println("可以自动按摩！");
13     }
14     
15 }
16 
17 class LowSeat implements Seat {
18 
19     @Override
20     public void massage() {
21         System.out.println("不能按摩！");
22     }
23     
24 }
25 
26 package org.factory.abstractFactory;
27 
28 public interface Tyre {
29     void revolve();
30 }
31 class LuxuryTyre implements Tyre {
32 
33     @Override
34     public void revolve() {
35         System.out.println("旋转不磨损！");
36     }
37     
38 }
39 class LowTyre implements Tyre {
40 
41     @Override
42     public void revolve() {
43         System.out.println("旋转磨损快！");
44     }
45     
46 }

工厂接口及实现类

package org.factory.abstractFactory;
 2 
 3 public interface CarFactory {
 4     Engine createEngine();
 5     Seat createSeat();
 6     Tyre createTyre();
 7 }
 8 
 9 package org.factory.abstractFactory;
10 
11 public class LowCarFactory implements CarFactory {
12 
13     @Override
14     public Engine createEngine() {
15         // TODO Auto-generated method stub
16         return new LowEngine();
17     }
18 
19     @Override
20     public Seat createSeat() {
21         // TODO Auto-generated method stub
22         return new LowSeat();
23     }
24 
25     @Override
26     public Tyre createTyre() {
27         // TODO Auto-generated method stub
28         return new LowTyre();
29     }
30 
31 }
32 
33 package org.factory.abstractFactory;
34 
35 public class LuxuryCarFactory implements CarFactory {
36 
37     @Override
38     public Engine createEngine() {
39         // TODO Auto-generated method stub
40         return new LuxuryEngine();
41     }
42 
43     @Override
44     public Seat createSeat() {
45         // TODO Auto-generated method stub
46         return new LuxurySeat();
47     }
48 
49     @Override
50     public Tyre createTyre() {
51         // TODO Auto-generated method stub
52         return new LuxuryTyre();
53     }
54 
55 }

Client类

package org.factory.abstractFactory;
 2 
 3 public class Client {
 4 
 5     public static void main(String[] args) {
 6         // TODO Auto-generated method stub
 7         CarFactory  factory = new LuxuryCarFactory();
 8         Engine e = factory.createEngine();
 9         e.run();
10         e.start();
11         
12         
13     }
14 
15 }