Java设计模式_工厂模式

Posted 2020-10-06

简单工厂模式

简单工厂模式的工厂类一般是使用静态方法，通过接收的参数的不同来返回不同的对象实例。(不修改代码的话，是无法扩展的。 )

 1 //产品接口 
 2 interface IProduct { 
 3     public void productName(); 
 4 } 
 5 
 6 //产品实体类 
 7 class ProductA implements IProduct { 
 8     @Override 
 9     public void productName() { 
10         System.out.println("product A"); 
11     } 
12 } 
13 
14 class ProductB implements IProduct { 
15     @Override 
16     public void productName() { 
17         System.out.println("product B"); 
18     } 
19 }
20 
21 //工厂类 
22 class Factory { 
23     public IProduct create(String productName) { 
24         switch (productName) { 
25         case "A": 
26             return new ProductA(); 
27         case "B": 
28             return new ProductB(); 
29         default: 
30             return null; 
31         } 
32     } 
33 } 
34 
35 //测试类
36 class Client {
37     
38     public static void main(String[] args) { 
39         Factory factory = new Factory(); 
40         IProduct productA = factory.create("A"); 
41         productA.productName(); 
42         
43         IProduct productB = factory.create("B"); 
44         productB.productName(); 
45     } 
46 }
47 
48 输出 ：
49 product A 
50 product B 

 

工厂方法模式

工厂方法是针 对每一种产品提供一个工厂类 。通过不同的工厂实例来创建不同的产品实例。 (在同一等级结构中， 支持增加任意产品 。)

 1 //产品接口 
 2 interface IProduct { 
 3     public void productName(); 
 4 } 
 5 
 6 //产品实体类 
 7 class ProductA implements IProduct { 
 8     @Override 
 9     public void productName() { 
10         System.out.println("product A"); 
11     } 
12 } 
13 class ProductB implements IProduct { 
14     @Override 
15     public void productName() { 
16         System.out.println("product B"); 
17     } 
18 }
19 
20 //工厂接口
21 interface IFactory { 
22     public IProduct create(); 
23 } 
24 
25 //工厂实体类 
26 class FactoryA implements IFactory { 
27     @Override 
28     public IProduct create() { 
29         return new ProductA(); 
30     } 
31 } 
32 class FactoryB implements IFactory { 
33     @Override 
34     public IProduct create() { 
35         return new ProductB(); 
36     } 
37 }
38 
39 //测试类 
40 class Client { 
41     public static void main(String[] args) { 
42         IFactory factoryA = new FactoryA(); 
43         IProduct productA = factoryA.create(); 
44         productA.productName(); 
45         
46         IFactory factoryB = new FactoryB(); 
47         IProduct productB = factoryB.create(); 
48         productB.productName(); 
49     }
50 }
51 
52 输出：
53 product A
54 product B

 

 抽象工厂模式

抽象工厂是应对产品族概念的。比如说，每个汽车公司可能要同时生产轿车，货车，客车，那么每一个工厂都要有创建轿车，货车和客车的方法。
(应对产品族概念而生，增加新的产品线很容易，但是无法增加新的产品。)
和工厂方法的区别是: 抽象工厂往往有多种方法，可以生产多种产品，即产品簇。

 

 1 //抽象工厂接口
 2 interface AbstractFactory { 
 3     public IProductA createProductA(); 
 4     public IProductB createProductB(); 
 5 } 
 6 
 7 //工厂实体类 
 8 class FactoryA implements AbstractFactory { 
 9     @Override 
10     public IProductA createProductA() { 
11         return new ProductA1(); 
12     } 
13 
14     @Override 
15     public IProductB createProductB() { 
16         return new ProductB1(); 
17     } 
18 } 
19 class FactoryB implements AbstractFactory { 
20     @Override 
21     public IProductA createProductA() { 
22         return new ProductA2(); 
23     } 
24 
25     @Override 
26     public IProductB createProductB() { 
27         return new ProductB2(); 
28     } 
29 } 
30 
31 //产品接口
32 interface IProductA { 
33     public void productName(); 
34 } 
35 interface IProductB { 
36     public void productName(); 
37 } 
38 
39 //产品实体类 
40 class ProductA1 implements IProductA { 
41     @Override 
42     public void productName() { 
43         System.out.println("product A1"); 
44     } 
45 }
46 class ProductA2 implements IProductA { 
47     @Override 
48     public void productName() { 
49         System.out.println("product A2"); 
50     } 
51 }
52 class ProductB1 implements IProductB { 
53     @Override 
54     public void productName() { 
55         System.out.println("product B1"); 
56     } 
57 }
58 class ProductB2 implements IProductB { 
59     @Override 
60     public void productName() { 
61         System.out.println("product B2"); 
62     } 
63 }
64 
65 //测试类 
66 class Client { 
67     public static void main(String[] args) { 
68         AbstractFactory factoryA = new FactoryA(); 
69         IProductA productA1 = factoryA.createProductA(); 
70         IProductB productB1 = factoryA.createProductB();
71         productA1.productName();
72         productB1.productName();
73 
74         AbstractFactory factoryB = new FactoryB(); 
75         IProductA productA2 = factoryB.createProductA(); 
76         IProductB productB2 = factoryB.createProductB();
77         productA2.productName();
78         productB2.productName();
79     }
80 }
81 
82 输出：
83 product A1
84 product B1
85 product A2
86 product B2