设计模式之抽象工厂模式

这个模式看的我有点懵。。。梳理一下

先上定义：抽象工厂模式，提供一个创建一系列相关或者依赖对象的接口，而无须指定它们具体的类；

不知道我自己在说什么。。

 1 package com.java.AbstractFactoryPattern;
 2 
 3 public interface Product {
 4     public void productInfo();
 5 }
 6 
 7 package com.java.AbstractFactoryPattern;
 8 
 9 public interface NewProduct {
10     public void productSay();
11 }    

Product和NewProduct是两个抽象产品。

1 package com.java.AbstractFactoryPattern;
2 
3 public interface Factory {
4     public Product createProductA();
5     
6     public NewProduct createProductB();
7 }

factory则是一个抽象工厂接口，它里面包含所有产品创建的抽象方法。

 1 package com.java.AbstractFactoryPattern;
 2 
 3 public class ProductA implements Product {
 4 
 5     @Override
 6     public void productInfo() {
 7         System.out.println("产品A");
 8     }
 9 
10 }
11 package com.java.AbstractFactoryPattern;
12 
13 public class ProductB implements Product {
14 
15     @Override
16     public void productInfo() {
17         System.out.println("产品B");
18 
19     }
20 
21 }
22 package com.java.AbstractFactoryPattern;
23 
24 public class ProductA2 implements NewProduct {
25 
26 
27     @Override
28     public void productSay() {
29         System.out.println("全新的产品A2");
30     }
31 
32 }
33 package com.java.AbstractFactoryPattern;
34 
35 public class ProductB2 implements NewProduct {
36 
37 
38     @Override
39     public void productSay() {
40         System.out.println("全新产品B2");
41     }
42 
43 }

这四个是对两个抽象产品的具体实现；

 1 package com.java.AbstractFactoryPattern;
 2 
 3 public class FactoryA implements Factory {
 4 
 5     @Override
 6     public Product createProductA() {
 7         return new ProductB();
 8     }
 9 
10     @Override
11     public NewProduct createProductB() {
12         return new ProductB2();
13     }
14 
15 }
16 
17 package com.java.AbstractFactoryPattern;
18 
19 public class FactoryB implements Factory {
20 
21     @Override
22     public Product createProductA() {
23 
24         return new ProductA();
25     }
26 
27     @Override
28     public NewProduct createProductB() {
29         return new ProductA2();
30     }
31 
32 }

这两个就是具体的工厂了。

 1 package com.java.AbstractFactoryPattern;
 2 
 3 public class Test {
 4     public static void main(String[] args) {
 5         Factory factory = new FactoryA();
 6         Product pa = factory.createProductA();
 7         NewProduct pb = factory.createProductB();
 8         pa.productInfo();
 9         pb.productSay();
10         
11         Factory factory1 = new FactoryB();
12         Product pa1 = factory1.createProductA();
13         NewProduct pb1 = factory1.createProductB();
14         pa1.productInfo();
15         pb1.productSay();
16         
17     }
18 }

抽象工厂模式通常是在运行时刻再创建一个Factory的实例，这个具体的工厂再创建具有特定实现的产品对象。也就是说，为创建不同的产品对象，客户端应该使用不同的具体工厂。

以上就是我的理解，但是我觉得还是太浅，以后有了新的感悟再来更新。

转载于:https://www.cnblogs.com/loveyejinhui/p/8729076.html