1. <p>package com.itheima.design;
   
2. 
   
3. public class FactoryDesign {
   
4. public static void main(String[] args) {
   
5.                
   
6.                 IFactory factory = new Factory();
   
7.                 IProduct product = factory.creadteProduct();
   
8.                 product.productMethod();
   
9.         }
   
10. 
    
11. }
    
12. 
    
13. interface IProduct{
    
14.         public void productMethod();
    
15. }
    
16. 
    
17. interface IFactory{
    
18.         public IProduct creadteProduct();
    
19. }
    
20. 
    
21. class Product implements IProduct{
    
22. 
    
23.         @Override
    
24.         public void productMethod() {
    
25.                 System.out.println("产品");
    
26.         }
    
27. 
    
28. }
    
29. class Factory implements IFactory{
    
30. 
    
31.         @Override
    
32.         public IProduct creadteProduct() {
    
33.                
    
34.                 return new Product();
    
35.         }
    
36.         
    
37. }</p>

复制代码

上述是否属于抽象化工厂设计模式，如果不是，请简要说明下抽象化工厂设计模式的要点。最好附个简单代码例子（带注释）

自己通过一些资料学习，我上述代码是工厂方法模式，而抽象工厂模式与工厂方法模式的主要区别在于体现在产品等级结构的不同，前者产品结构多级化，而后者产品等级结构比较单一，例如生产汽车行业，汽车会有2厢和3厢的区别，还有排量的区别，比如说有2.0和3.0的区别。那么这个2厢和3厢的车就是体现了产品等级结构的不同，而排量的不同称之为产品族的不同。在具体一点就是说，2.0、2厢的车子跟3.0、2厢的车子属于同一个等级结构，而2.0 、3厢的车子跟3.0、3厢的车子属于另一个等级结构，而同种排量不同厢数属于同一个产品族，反之则不同。总而言之，就是对产品从整体上先做一个产品等级结构划分，进而内部的一些属性再进行细分为产品族。
那么如果上述的工厂方法模式变为了抽象工厂模式后的代码如下：

1. package com.itheima.design;
   
2. 
   
3. public class FactoryDesign2 {
   
4. 
   
5.         /**
   
6.          * 抽象工厂模式
   
7.          */
   
8.         public static void main(String[] args) {
   
9.                 Factory1 factory = new Factory1();
   
10.                 factory.creadteProduct1().show();
    
11.                 factory.creadteProduct2().show();
    
12.         }
    
13. }
    
14. 
    
15. // 产品接口
    
16. interface IProduct1 {
    
17.         public void show();
    
18. }
    
19. 
    
20. interface IProduct2 {
    
21.         public void show();
    
22. }
    
23. // 工厂接口
    
24. interface IFactory1 {
    
25.         public IProduct1 creadteProduct1();
    
26.         public IProduct2 creadteProduct2();
    
27. }
    
28. 
    
29. // 产品类
    
30. class Product1 implements IProduct1 {
    
31. 
    
32.         @Override
    
33.         public void show() {
    
34.                 System.out.println("第一型号产品");
    
35.         }
    
36. 
    
37. }
    
38. 
    
39. class Product2 implements IProduct2 {
    
40. 
    
41.         @Override
    
42.         public void show() {
    
43.                 System.out.println("第二型号产品");
    
44.         }
    
45. 
    
46. }
    
47. 
    
48. // 工厂类
    
49. class Factory1 implements IFactory1 {
    
50. 
    
51.         @Override
    
52.         public IProduct1 creadteProduct1() {
    
53. 
    
54.                 return new Product1();
    
55.         }
    
56. 
    
57.         @Override
    
58.         public IProduct2 creadteProduct2() {
    
59. 
    
60.                 return new Product2();
    
61.         }
    
62. 
    
63. }
    

复制代码