设计模式 -- 工厂模式

发表于

「这是我参与11月更文挑战的第2天，活动详情查看：2021最后一次更文挑战」

工厂模式主要有三种，先介绍一下简单工厂模式，顾名思义比较简单

含义： 利用单独的类来进行创造实例的过程，定义⼀个创建对象的接⼝，让接⼝的实现类决定创建哪种对象，让类的实例化推迟到⼦类中进行。

就像工厂一样，在工厂先建好机器，然后等待一系列物品进行生产，就拿咖啡举例吧

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
34
35
36
37
38
39
40
41
42
43
44
45
46
typescript复制代码//首先创建一个咖啡的规范类
public interface Coffee{
    public String getName();
}
​
//然后定义工厂中生产的咖啡种类
public Americano interface Coffee{
    @Override
    public String getName(){
        return "Americano";
    }
}
​
public Latte interface Coffee{
    @Override
    public String getName(){
        return "Latte";
    }
}
    
public MoCha interface Coffee{
    @Override
    public String getName(){
        return "MoCha";
    }
}
​
//然后建立创建咖啡的工厂
public class CoffeeFactory{
    public Coffee createCoffee(String coffeeType){
        if (coffeeType.equals("Americano")){
            return new Americano();
        }else if (coffeeType.equals("Latte")){
            return new Latte();
        }else if(coffeeType.equals("MoCha"){
            return new MoCha();
        }
        return null; 
    }
}
                 
//现在我想喝咖啡了,我只需要告诉工厂我想喝什么，并不需要知道它的生产过程。
public static void main(String[] args){
    CoffeeFactory coffeeFactory = new CoffeeFactory();
    coffeeFactory.createCoffee("Americano");
}

接下来了解一下他的优缺点吧，优点显而易见，当想要创建对象时候，仅仅知道它的名称就可以了，并且屏蔽具体的实现过程，很好的体现了封装性；但是现在如果有很多种类咖啡的话，那么就要在工厂中增加大量的条件判断，不符合开闭原则，会使工厂类变得非常繁琐，也不符合单一职责原则，这就是它的缺点。

为了应对简单工厂模式的缺点，我们可以把生产各个产品的工厂也做抽象分离，即每个产品都有自己专门的工厂，顾名思义它叫工厂方法模式

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
typescript复制代码//首先创建一个咖啡工厂的规范类
public interface CoffeeFactory{
    public Coffee createCoffee();
}
​
public class AmericanoFactory implements CoffeeFactory{
    @Override
    public Coffee createCoffee(){
        return new Americano();
    }
}
​
public class LatteFactory implements CoffeeFactory{
    @Override
    public Coffee createCoffee(){
        return new Latte();
    }
}
​
public class MoChaFactory implements CoffeeFactory{
    @Override
    public Coffee createCoffee(){
        return new MoCha();
    }
}
​
public static void main(String[] args){
    AmericanoFactory americanoFactory = new AmericanoFactory();
    AmericanoFactory.createCoffee();
}

这样一来，当我们想要新的种类的时候，只需要新建工厂就行了，同时能够满足开闭原则和单一职责原则。但是它虽然进一步优化了简单工厂模式，可它仍然需要创建大量的类，增加函数的复杂度。

可以看出上述两种模式都是对同一种类的物品进行生产的工厂，那么我们要生产汽车，衣服怎么办呢？总不能还用咖啡的工厂来生产吧。就算像奶茶一样有相似之处，复制修改相同的代码虽然也是可以，但是如果后期维护和扩展功能你就知道这种做法是多么愚蠢了。因此就发明出了随时改变的抽象工厂模式。

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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
scala复制代码//首先创建抽象工厂
abstract class AbstractFactory{
    public abstract void createProduct(String product);
}
​
//奶茶工厂
class BeerFactory extends AbstractFactory{
    @Override
    public void createProduct(String product){
        switch(product){
            case "Bubble Tea":
                return new BubbleTea();
                break;
            case "milk":
                return new Milk();
                break;
            default:
                return new othersTea();
                break;
        }
        return null;
    }
}
​
//咖啡工厂
class CoffeeFactory extends AbstractFactory{
    @Override
    public void createProduct(String product){
        switch(product){
            case "Americano":
                return new Americano();
                break;
            case "Latte":
                return new Latte();
                break;
            default:
                return new othersCoffee();
                break;
        }
        return null;
    }
}
​
public class AbstractFactoryTest{
    public static void main(String[] args) {
       // 抽象工厂
       new CoffeeFactory()).createProduct("Latte");
   }
}

虽然完善了简单工厂模式和工厂方法模式不方便扩展产品族，并且增加了系统的抽象性和理解难度。

虽然看起来这三种工厂模式越来越好，但是并没有所谓的高级模式，只有适合使用的场景才是最好的，大家应该按照自己的需求找到最合适的模式。

本文转载自: 掘金

开发者博客 – 和开发相关的 这里全都有

0%