JAVA设计模式之工厂模式

Posted 2020-07-06 hxy

以下代码仅供展示工厂模式，不能直接编译，因为一个文件中最多只能有一个public class。

一、简单工厂模式：比较简单，produceProduct方法最好是静态的。它是根据参数来决定返回哪一种类型的product。

 1 public interface Product
 2 {
 3     public void getName();
 4 }
 5 
 6 public class ProductA implements Product
 7 {
 8     public void getName() 
 9     {
10         System.out.println("I am A.");
11     }
12 }
13 
14 public class ProductB implements Product
15 {
16     public void getName() 
17     {
18         System.out.println("I am B.");
19     }
20 }
21 
22 public class Factory 
23 {
24     public Product produceProduct(String type)
25     {
26         if(type.equals("A"))
27         {
28             return new ProductA();
29         }
30         else if(type.equals("B"))
31         {
32             return new ProductB();
33         }
34         else
35         {
36             return null;
37         }
38     }
39     
40     public static void main(String[] args)
41     {
42         Factory factory = new Factory();
43         Product product = factory.produceProduct("A");
44         product.getName();
45         product = factory.produceProduct("B");
46         product.getName();
47     }
48 }

二、工厂方法模式：不同于简单工厂，它将不同的产品放在实现了工厂接口的不同工厂类中，这样就算其中一个工厂出了问题，其他工厂也还可以正常工作。

 1 public interface Product
 2 {
 3     public void getName();
 4 }
 5 
 6 public class ProductA implements Product
 7 {
 8     public void getName() 
 9     {
10         System.out.println("I am A.");
11     }
12 }
13 
14 public class ProductB implements Product
15 {
16     public void getName() 
17     {
18         System.out.println("I am B.");
19     }
20 }
21 
22 public interface Produce 
23 {
24     public Product produce();
25 }
26 
27 public class FactoryA implements Produce
28 {
29     public Product produce()
30     {
31         return new ProductA();
32     }
33 }
34 
35 public class FactoryB implements Produce
36 {
37     public Product produce()
38     {
39         return new ProductB();
40     }
41 }
42 
43 public class Test 
44 {
45     public static void main(String[] args)
46     {
47         FactoryA fa = new FactoryA();
48         Product p = fa.produce();
49         p.getName();
50         FactoryB fb = new FactoryB();
51         p =    fb.produce();
52         p.getName();
53     }
54 }

三、抽象工厂模式：用于创建一系列产品

 1 public interface Fruit 
 2 {
 3     public void getFruit();
 4 }
 5 
 6 public class FruitA implements Fruit
 7 {
 8     public void getFruit() 
 9     {
10         System.out.println("FruitA");
11     }
12 }
13 
14 public class FruitB implements Fruit
15 {
16     public void getFruit() 
17     {
18         System.out.println("FruitB");
19     }
20 }
21 
22 public interface Vegetable 
23 {
24     public void getVegetable();
25 }
26 
27 public class VegetableA implements Vegetable
28 {
29     public void getVegetable() 
30     {
31         System.out.println("VegetableA");
32     }
33 }
34 
35 public class VegetableB implements Vegetable
36 {
37     public void getVegetable() 
38     {
39         System.out.println("VegetableB");
40     }
41 }
42 
43 public interface AbstractFactory 
44 {
45     public Fruit produceFruit();
46     public Vegetable produceVegetable();
47 }
48 
49 public class FactoryA implements AbstractFactory
50 {
51     public Fruit produceFruit() 
52     {
53         return new FruitA();
54     }
55 
56     public Vegetable produceVegetable() 
57     {
58         return new VegetableA();
59     }
60 }
61 
62 public class FactoryB implements AbstractFactory
63 {
64     public Fruit produceFruit() 
65     {
66         return new FruitB();
67     }
68 
69     public Vegetable produceVegetable() 
70     {
71         return new VegetableB();
72     }
73 }

说明：也可以有FactoryAB是return new FruitA()和return new VegetableB()的，或者是FactoryBA是return new FruitB()和return new VegetableA()的。其目的在于创建一系列产品。