Java设计模式_工厂模式

简单工厂模式

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

 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