工厂设计模式

Posted on | In | |

##工厂设计模式

###一.什么是工厂设计模式

工厂模式是我们最常用的实例化对象模式了，是用工厂方法代替new操作的一种模式。因为工厂模式就相当于创建实例对象的new，虽然这样做，可能多做一些工作，但会给你系统带来更大的可扩展性和尽量少的修改量。工厂模式最直接的作用就是将创建对象和对象的业务逻辑相分离。

工厂模式最常见的三种：

  • 简单工厂模式
  • 工厂方法模式
  • 抽象工厂

二、简单工厂模式

以下是我看《headefirst设计模式》的工厂模式的笔记。非常有意思，但是篇幅有点长，所以打算总结下，写个简洁版的。

假如你有个pizza店，你可以为客人做很多 pizza。

首先，你需要很多pizza对象，定义一个pizza抽象类：

1
2
3
4
5
6
7
8
public abstract class Pizza {
    abstract void prepared();
    abstract void bake();
    abstract void cut();
    abstract void box();
}


中式 pizza:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class ChineasePizza extends Pizza {
    @Override
    public void prepared() {

    }

    @Override
    public void bake() {

    }

    @Override
    public void cut() {

    }

    @Override
    public void box() {

    }
}

美式pizza:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public class AmericanPizza extends Pizza {
    @Override
    public void prepared() {

    }

    @Override
    public void bake() {

    }

    @Override
    public void cut() {

    }

    @Override
    public void box() {

    }
}


当我需要为客人准备一份pizza，我们可能会需要这样写：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public Pizza orderPizza(String type){
        Pizza pizza = null;
        if(type.equals("c")){
            pizza=new ChineasePizza();
        }else if(type.equals("a")){
            pizza=new AmericanPizza();
        }else if(type.equals("e")){
            pizza=new EnglishPizza();
        }else {
            pizza=new ChineasePizza();
        }
        pizza.prepared();
        pizza.bake();
        pizza.cut();
        pizza.box();
        return pizza;
    }

当你有很多种pizza的时候，这个else if()特别的长：

1
2
3
4
5
6
7
8
9
10
11
12
13
if(type.equals("c")){
           pizza=new ChineasePizza();
       }else if(type.equals("a")){
           pizza=new AmericanPizza();
       }else if(type.equals("e")){
           pizza=new EnglishPizza();
       }else if(...){
       ....
       }else {
           pizza=new ChineasePizza();
       }


你需要创建一个工厂来管理这些pizza的创建实例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

public class SimplePizzaFactory {

    public Pizza createPizza(String type) {

        Pizza pizza = null;
        if(type.equals("c")){
            pizza=new ChineasePizza();
        }else if(type.equals("a")){
            pizza=new AmericanPizza();
        }else if(type.equals("e")){
            pizza=new EnglishPizza();
        }else {
            pizza=new ChineasePizza();
        }

        return pizza;
    }
}

有了工厂之后的你代码应该这样写：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class PizzaStore {

    private SimplePizzaFactory simplePizzaFactory;
    public PizzaStore(SimplePizzaFactory simplePizzaFactory){
        this.simplePizzaFactory=simplePizzaFactory;
    }

    public Pizza orderPizza(String type) {
       Pizza pizza= simplePizzaFactory.createPizza(type);
        pizza.prepared();
        pizza.bake();
        pizza.cut();
        pizza.box();
        return pizza;
    }
}

就是简单的工厂模式，工厂处理创建对象的细节。工厂模式将创建对象和对象的业务逻辑相分离，降低了代码的耦合性，提高了代码的可读性。

三、工厂方法模式

当你需要开很多pizza店的时候，你可能需要创建的pizztore抽象类,这个抽象类只专注于卖pizza的业务逻辑，不专注pizza是怎么来的：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public abstract class APizzaStore {

    public Pizza orderPizza(String type) {
        Pizza pizza= createPizza(type);
        pizza.prepared();
        pizza.bake();
        pizza.cut();
        pizza.box();
        return pizza;
    }
    abstract Pizza createPizza(String type);
}


它的子类需要专注于pizza 是怎么来的，你需要在北京开一家pizza店：

1
2
3
4
5
6
7
8
9
10
11
12
13
public class BeijingtPizzaStore extends APizzaStore{

    @Override
    Pizza createPizza(String type) {
        Pizza pizza;
        if(type.equals("a")){
            pizza=new AmericanPizza();
        }else {
            pizza=new ChineasePizza();
        }
        return pizza;
    }
}

你在北京卖pizza之需要：

1
2
3
BeijingtPizzaStore bps=new BeijingtPizzaStore();
bps.orderPizza();

同理,你需要在深圳开pizza店： 

1
2
3
4
5
6
7
 public class ShenZhengPizzaStore extends APizzaStore {
    @Override
    Pizza createPizza(String type) {
        return null;
    }
}

工厂方法用来处理对象的创建，并将这样的行为封装在子类中。超类的代码和子类的对象创建代码就解耦了。

四、抽象工厂模式

你制造pizza的时候，需要很多原料，这时需要一个工厂来制造：

1
2
3
4
5
6
7
public interface IngredientFactory {
    Dauch createDauch();
    Sauce createSauch();
    Cheese createCheese();
}


创建一个中国原料工厂：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class ChineaseIngredientFactory implements IngredientFactory {
    @Override
    public Dauch createDauch() {
        return new Dauch();
    }

    @Override
    public Sauce createSauch() {
        return new Sauce();　//这里我简便的写，其实也可以说Sauch的子类。
    }

    @Override
    public Cheese createCheese() {
        return new Cheese();
    }
}


同理也可以创建美国原料工厂：

这时我们可以重做pizza:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

public abstract class Pizza {    
                                 
    String name;                 
    Dauch dauch;                 
    Sauce sauch;            
    Cheese  cheese ;     
                                 
    abstract void prepared();    
    abstract void bake();        
    abstract void cut();         
    abstract void box();         
}

中国式pizza:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
public class ChineasePizza extends Pizza {
    
    private ChineaseIngredientFactory ingredientFactory;
    
    public ChineasePizza(ChineaseIngredientFactory ingredientFactory){
        this.ingredientFactory=ingredientFactory;
    }
    @Override
    public void prepared() {
        dauch=ingredientFactory.createDauch();
        sauch=ingredientFactory.createSauch();
        cheese=ingredientFactory.createCheese();
        //TODO
        
    }

    @Override
    public void bake() {
        //TODO
    }

    @Override
    public void cut() {
        //TODO
    }

    @Override
    public void box() {
        //TODO
    }
}


这时候我们再看，利用抽象工厂模式，可以为pizza创建原料，pizza只关注于它自身的业务逻辑，而不用关注pizza原料从哪里来，这样的pizza和pizza原料的解耦。

通过抽象工厂所提供的接口，可以创建产品的家族，利用这个接口写代码，我们的代码将实际工厂解耦，以便在不同的工厂，制造出不同的产品。

到此为止，三种工厂模式已经讲解完毕，源码下载。

优秀文章推荐：

请我吃🍗