Java设计模式——工厂方法和抽象工厂方法

最新推荐文章于 2024-09-03 12:06:04 发布

转载最新推荐文章于 2024-09-03 12:06:04 发布 · 300 阅读

46 篇文章

订阅专栏

工厂方法(Factory Method)模式的意义是定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类当中。核心工厂类不再负责产品的创建，这样核心类成为一个抽象工厂角色，仅负责具体工厂子类必须实现的接口，这样进一步抽象化的好处是使得工厂方法模式可以使系统在不修改具体工厂角色的情况下引进新的产品。

例如：

 1 //交通工具必须实现的接口
 2 public interface Moveable {
 3     public void run();
 4 }
 5 
 6 //交通工具1.car
 7 public class Car implements Moveable{
 8 
 9     @Override
10     public void run() {
11         // TODO Auto-generated method stub
12         System.out.println("Car----------------");
13         
14     }
15 
16 }
17 
18 //交通工具2.plane
19 public class Plane implements Moveable{
20 
21     @Override
22     public void run() {
23         // TODO Auto-generated method stub
24         System.out.println("Plane----------------");
25     }
26 
27 }
28 
29 //作为工厂必须实现的接口
30 public interface Factory {
31     public Moveable create();
32 }
33 
34 //具体的交通工具工厂CarFactory
35 public class CarFactory implements Factory{
36 
37     @Override
38     public Moveable create() {
39         // TODO Auto-generated method stub
40         
41         return new Car();
42     }
43 
44 }
45 
46 //具体的交通工具工厂PlaneFactory
47 public class PlaneFactory implements Factory{
48 
49     @Override
50     public Moveable create() {
51         // TODO Auto-generated method stub
52         return new Plane();
53     }
54 
55 }

测试1：

1 public class Test {
2     public static void main(String args[]){
3         Factory fac = new PlaneFactory();
4         Moveable mov = fac.create();
5         mov.run();
6     }
7 }

输出1：

Plane----------------

测试2:

1 public class Test {
2     public static void main(String args[]){
3         Factory fac = new CarFactory();
4         Moveable mov = fac.create();
5         mov.run();
6     }
7 }

输出2：

Car----------------

在上述例子中，工厂方法使我们能够定制任意交通工具的类型和生产过程，假设我们有了新的交通工具vihicle

//交通工具3.vihicle
public class Vihicle implements Moveable{

    @Override
    public void run() {
        // TODO Auto-generated method stub
        System.out.println("Vihicle----------------");  
    }
}

实现VihicleFactory类：

1 public class VihicleFactory implements Factory{
2 
3     @Override
4     public Moveable create() {
5         // TODO Auto-generated method stub
6         return new Vihicle();
7     }
8 
9 }

在生产过程中，我们只需new一个VihicleFactory并调用create()方法即可：

1 public class Test {
2     public static void main(String args[]){
3         Factory fac = new VihicleFactory();
4         Moveable mov = fac.create();
5         mov.run();
6     }
7 }

输出：

Vihicle----------------

在工厂方法中，每当我们有了新的Product需要生产时，我们就必须实现对应的ProductFactory，这样一来，随着Product数量的增多，往往容易造成ProductFactory泛滥，若我们想要生产十几种产品就要相应的实现十几个具体的工厂，这显然是不科学的，而抽象工厂方法正好解决了这个问题

例：

  1 //食物接口
  2 public interface Food {
  3     public void printName();
  4 }
  5 
  6 //食物产品1.apple
  7 public class Apple implements Food{
  8 
  9     @Override
 10     public void printName() {
 11         // TODO Auto-generated method stub
 12         System.out.println("this is apple");
 13     }
 14 
 15 }
 16 
 17 //食物产品2.banana
 18 public class Banana implements Food{
 19 
 20     @Override
 21     public void printName() {
 22         // TODO Auto-generated method stub
 23         System.out.println("this is banana");
 24     }
 25 
 26 }
 27 
 28 //汽车接口
 29 public interface Vehicle {
 30     public void run();
 31 }
 32 
 33 //汽车产品1.benz
 34 public class Benz implements Vehicle{
 35 
 36     @Override
 37     public void run() {
 38         // TODO Auto-generated method stub
 39         System.out.println("Benz--------------");
 40     }
 41 
 42 }
 43 
 44 
 45 //汽车产品2.bwm
 46 public class BWM implements Vehicle{
 47 
 48     @Override
 49     public void run() {
 50         // TODO Auto-generated method stub
 51         System.out.println("BWM--------------");
 52     }
 53 
 54 }
 55 
 56 //武器接口
 57 public interface Weapon {
 58     public void shot();
 59 }
 60 
 61 
 62 //武器产品1.AK47
 63 public class AK47 implements Weapon{
 64     @Override
 65     public void shot(){
 66         System.out.println("AK47-------------");
 67     }
 68 }
 69 
 70 //武器产品2.M4
 71 public class M4 implements Weapon{
 72 
 73     @Override
 74     public void shot() {
 75         // TODO Auto-generated method stub
 76         System.out.println("M4--------------");
 77     }
 78 
 79 }
 80 
 81 //工厂接口
 82 public interface AbstractFactory {
 83     public Vehicle createVehicle();
 84     public Weapon  createWeapon();
 85     public Food     createFood();
 86 }
 87 
 88 //工厂1：能够生产BWM、AK47、Apple
 89 public class Factory1 implements AbstractFactory{
 90 
 91     @Override
 92     public Vehicle createVehicle() {
 93         // TODO Auto-generated method stub
 94         return new BWM();
 95     }
 96 
 97     @Override
 98     public Weapon createWeapon() {
 99         // TODO Auto-generated method stub
100         return new AK47();
101     }
102 
103     @Override
104     public Food createFood() {
105         // TODO Auto-generated method stub
106         return new Apple();
107     }
108 
109 }
110 
111 //工厂2：Benz、M4、Banana
112 public class Factory2 implements AbstractFactory{
113 
114     @Override
115     public Vehicle createVehicle() {
116         // TODO Auto-generated method stub
117         return new Benz();
118     }
119 
120     @Override
121     public Weapon createWeapon() {
122         // TODO Auto-generated method stub
123         return new M4();
124     }
125 
126     @Override
127     public Food createFood() {
128         // TODO Auto-generated method stub
129         return new Banana();
130     }
131 
132 }

测试1：

public class Test {
    public static void main(String args[]){
        AbstractFactory abs=new Factory1();
        Food fo = abs.createFood();
        Vehicle ve = abs.createVehicle();
        Weapon we = abs.createWeapon();
        fo.printName();
        ve.run();
        we.shot();
    }
}

输出1：

this is apple
BWM--------------
AK47-------------

测试2:

public class Test {
    public static void main(String args[]){
        AbstractFactory abs=new Factory2();
        Food fo = abs.createFood();
        Vehicle ve = abs.createVehicle();
        Weapon we = abs.createWeapon();
        fo.printName();
        ve.run();
        we.shot();
    }
}

输出2:

1 this is banana
2 Benz--------------
3 M4--------------

抽象工厂的优点在于能够生产一系列可能存在关联的产品，但是，当我们需要在抽象工厂中添加新的产品时，几乎所有的工厂类都要修改

图片来自http://www.cnblogs.com/devinzhang/archive/2011/12/19/2293160.html

这样看来：

工厂模式生产一类产品（一个产品等级结构），来自同一个接口或抽象类

抽象工厂生产多类可能存在关联的产品（多个产品等级结构），来自多个接口或抽象类