java 抽象工厂模式

java 抽象工厂模式 

抽象工厂模式，在很多场景下都有应用。

 

它有以下的优点

1：封装性，每个产品的实现类不是高层模块要关心的，它所要关心 的是接口和抽象类，他不关心对象是如何创建出来，只有工厂类去关心，只要知道工厂类是谁，我们就能得到一个需要的对象。

 

2：产品家族的约束为非公开状态。而抽象工厂模式针对的是多个产品等级结构。当每个抽象产品都有多于一个的具体子类的时候，工厂角色怎么知道实例化哪一个子类呢？比如每个抽象产品角色都有两个具体产品。抽象工厂模式提供两个具体工厂角色，分别对应于这两个具体产品角色，每一个具体工厂角色只负责某一个产品角色的实例化。每一个具体工厂类只负责创建抽象产品的某一个具体子类的实例。

 

抽象产品

Java代码  

1 package com.gengu.抽象工厂;   

2 /**  

3  * 抽象产品  

4  * */  

5 public abstract class Product {   

6     public abstract void dosomething();   

7 }  

 具体产品类

Java代码  

8 package com.gengu.抽象工厂;   

9   

10 /**  

11  * 产品A1  

12  * */  

13 public class ProductA1 extends Product{   

14   

15     @Override  

16     public void dosomething() {   

17         System.out.println("这是产品A1");   

18     }   

19 }   

20   

21   

22 package com.gengu.抽象工厂;   

23   

24 /**  

25  * 产品A 2  

26  * */  

27 public class ProductA2 extends Product{   

28   

29     @Override  

30     public void dosomething() {   

31         System.out.println("这是产品A2");   

32     }   

33   

34 }   

35   

36   

37 package com.gengu.抽象工厂;   

38   

39 /**  

40  * 产品B1  

41  * */  

42 public class ProductB1 extends Product{   

43   

44     @Override  

45     public void dosomething() {   

46         System.out.println("这里是产品B1");   

47     }   

48 }   

49   

50 package com.gengu.抽象工厂;   

51   

52 public class ProductB2 extends Product{   

53   

54     @Override  

55     public void dosomething() {   

56         System.out.println("这里是产品B2");   

57     }   

58 }  

 抽象工厂类

Java代码  

59 package com.gengu.抽象工厂;   

60   

61 public abstract class Creater {   

62   

63     public abstract Product createProductA();   

64        

65     public abstract Product createProductB();   

66 }  

 具体工厂类

Java代码  

67 package com.gengu.抽象工厂;   

68   

69 public class Creater1 extends Creater{   

70   

71     @Override  

72     public Product createProductA() {   

73            

74         return new ProductA1();   

75     }   

76     @Override  

77     public Product createProductB() {   

78         return new ProductB1();   

79     }   

80 }   

81   

82 package com.gengu.抽象工厂;   

83   

84 public class Creater2 extends Creater{   

85   

86     @Override  

87     public Product createProductA() {   

88            

89         return new ProductA2();   

90     }   

91     @Override  

92     public Product createProductB() {   

93         return new ProductB2();   

94     }   

95 }  

 测试类

Java代码  

96 package com.gengu.抽象工厂;   

97   

98 public class Client {   

99   

100     public static void main(String[] args) {   

101         Creater create1 = new Creater1();   

102         Product productA1 = create1.createProductA();   

103         productA1.dosomething();   

104     }   

105 }  

 

抽象工厂方法从纵向上看，几乎没有可扩展性，假如我们想增加一个产品C，也就是说产品家族由原来的2个变为3个，程序将会有很大的变动，抽象工厂中就需要增加一个方法。这严重违背了开闭原则。并且抽象类是不喜欢被修改的。

但是从横向上来看，却对扩展性有了很好的支持，如果我们增加一个产品等级3，我们只需要在写一个Create3就可以了，这里又符合了开闭原则，有多少个产品等级就应该有多少个实现工厂类。每增加一个产品等级就相应的增加一个实现工厂类，这里的扩展性又很自然的体现出来了。

 

所以每个模式都是必须在合适的地方使用的。

 

<!--EndFragment-->