设计模式-工厂模式

13 分钟 读完 (约 1928 字)

工厂模式是最常用的设计模式之一，该模式定义一个用于创建对象的工厂类，调用者不用关心创建的细节

工厂模式可以分为三个子模式：

简单工厂模式

定义工厂类，根据参数返回不同类的实例，这些实例通常具有共同的父类，因为简单工厂模式用静态方法创建实例，所以又称为静态工厂模式（Static Creational Pattern）

简单工厂模式UML

  • Factory：工厂类，实现创建所有产品实例的内部逻辑
  • Product：抽象产品类，封装产品公有方法，它的引入使得工厂类只需要定义一个通用的工厂方法，因为创建的具体产品都是该类的子类
  • ConcreteProduct：具体实现类

代码示例：

产品类：

1
2
3
4
5
6
7
8
9
10
11
12
// 抽象产品类
abstract class Product {
    abstract void doSomething(Context context);
}

// 具体产品类
class ConcreteProduct extends Product {
    @Override
    void doSomething(Context context) {
        
    }
}

工厂类：

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

    public Factory() {
        throw new RuntimeException("can't init");
    }

    static final String concreteProductA = "concreteProductA";
    static final String concreteProductB = "concreteProductB";

    static Product createdProduct(String arg) {
        switch (arg) {
            case concreteProductA:
                return new ConcreteProductA();
            case concreteProductB:
                return new ConcreteProductB();
            default:
                return null;
        }
    }
}

适用场景：

  • 工厂类负责创建的对象比较少，由于创建的对象较少，不会造成工厂方法中的业务逻辑太过复杂
  • 客户端只知道传入工厂类的参数，对于如何创建对象并不关心

现实情况是复杂多变的，突然有一天产品经理说还要增加一个其他的类型，如果是简单工厂方法，就不得不在 if...else 或者 switch 中增加一个判断，这样就违反了开闭原则，对于这样的工厂类，称它为全能类或者上帝类

工厂方法模式

工厂方法模式去掉简单工厂模式的静态方法，使它可以被子类继承，这样就可以把静态方法的压力分担给各个子类承担，每个子工厂类只负责创建一个具体的产品类实例

工厂方法模式

  • Product：抽象产品类，所有需要实例化子类的父类
  • ConcreteProduct：具体产品类
  • Factory：抽象工厂类，此类是工厂方法模式的核心，所有工厂类都要继承该类
  • ConcreteFactory：具体工厂类，实现具体的业务逻辑

示例代码：
产品类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// 抽象类
abstract class People {
    abstract void doSomething();
}

// 女性
class Female extends People{
    @Override
    void doSomething() {

    }
}

// 男性
class Male extends People {
    @Override
    void doSomething() {

    }
}

工厂类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// 抽象工厂类
public abstract class Factory {
    abstract People createPeople();
}

// 具体工厂类
public class FemaleFactory extends Factory {

    @Override
    People createPeople() {
        return new Female();
    }
}

public class MaleFactory extends Factory {

    @Override
    People createPeople() {
        return new Male();
    }
}

适用场景：

  • 客户端不知道它所需要的对象的类。在工厂方法模式中，客户端不需要知道具体产品类的类名，只需要知道所对应的工厂即可，具体的产品对象由具体工厂类创建
  • 抽象工厂类通过其子类来指定创建哪个对象。在工厂方法模式中，对于抽象工厂类只需要提供一个创建产品的接口，而由其子类来确定具体要创建的对象，利用面向对象的多态性和里氏代换原则，在程序运行时，子类对象将覆盖父类对象，从而使得系统更容易扩展

跟简单工厂模式一样的问题，虽然没有违反开闭原则，但是增加新产品类的时候，因为一个具体工厂类只负责一个具体产品类，所以必须也要增加对应的具体工厂类，项目中类的个数成对增加，进而增加了系统的复杂度，更多的类需要编译和运行，给系统带来额外的开销

抽象工厂模式

工厂方法模式中一个工厂类负责生产一个具体产品，有时根据业务需求，一个工厂类需要提供多个具体产品，例如生产共享单车，一个工厂类可以提供多个共享单车的组件，比如车胎，车架，车座，车把，从而组成一个完整产品，为了更好理解抽象工厂模式，先理解两个概念：

  • 产品等级结构：即产品的继承结构，如车轮，子类有实心车胎，充气车胎，山地车胎等，抽象车轮和车轮具体类型构成一个产品等级结构
  • 产品族：抽象工厂模式中，产品族指同一工厂生产的，位于不同产品等级结构的一组产品，如自行车厂商生产实心车胎、铝合金车架等，实心车胎位于车胎产品等级结构中，铝合金车架位于车架产品等级结构中，实心车胎、铝合金车架等构成一个产品族

抽象工厂模式

  • AbstractProductA：抽象产品类
  • AbstractProductB：抽象产品类
  • ConcreteProductA1：具体产品类
  • ConcreteProductA2：具体产品类
  • ConcreteProductB1：具体产品类
  • ConcreteProductB2：具体产品类
  • AbstractFactory：抽象工厂类
  • ConcreteFactory1：具体工厂类，实现具体的业务逻辑
  • ConcreteFactory2：具体工厂类，实现具体的业务逻辑

这里用一个生产单车的例子实践一下抽象工厂模式，示例代码：
产品类：

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
50
51
52
53
54
55
56
57
58
59
60
61
62
// 车座
interface ISeat {
    void seat();
}

// 车胎
interface ITire {
    void tire();
}

// 车架
interface IFrame {
    void frame();
}

// 铝合金车架
public class AlloyFrame implements IFrame {
    @Override
    public void frame() {
        Log.i("IFrame", "AlloyFrame");
    }
}

// 碳纤维车架
class CarbonFrame implements IFrame {
    @Override
    public void frame() {
        Log.i("IFrame", "CarbonFrame");
    }
}

// 真皮车座
class DermisSeat implements ISeat {
    @Override
    public void seat() {
        Log.i("ISeat", "DermisSeat");
    }
}

// 橡胶车座
class RubberSeat implements ISeat {
    @Override
    public void seat() {
        Log.i("ISeat", "RubberSeat");
    }
}

// 充气车胎
class InflateTire implements ITire {
    @Override
    public void tire() {
        Log.i("ITire", "InflateTire");
    }
}

// 实心车胎
class SolidTire implements ITire {
    @Override
    public void tire() {
        Log.i("ITire", "SolidTire");
    }
}

工厂类：

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
50
51
52
53
54
55
56
57
58
59
60
// 抽象工厂类
abstract class AbstractFactory {
    /**
     * 生产车胎
     *
     * @return 车胎
     */
    abstract ITire createTire();

    /**
     * 生产车架
     *
     * @return 车架
     */
    abstract IFrame createFrame();

    /**
     * 生产车座
     *
     * @return 车座
     */
    abstract ISeat createSeat();
}

// ofo 工厂类
class OfoFactory extends AbstractFactory {

    @Override
    ITire createTire() {
        return new InflateTire();
    }

    @Override
    IFrame createFrame() {
        return new CarbonFrame();
    }

    @Override
    ISeat createSeat() {
        return new RubberSeat();
    }
}

// mobike 工厂类
class MobikeFactory extends AbstractFactory{
    @Override
    ITire createTire() {
        return new SolidTire();
    }

    @Override
    IFrame createFrame() {
        return new AlloyFrame();
    }

    @Override
    ISeat createSeat() {
        return new DermisSeat();
    }
}

适用场景：

  • 一个系统不应当依赖于产品类实例如何被创建、组合和表达的细节，这对于所有类型的工厂模式都是很重要的，用户无须关心对象的创建过程，将对象的创建和使用解耦
  • 系统中有多于一个的产品族，而每次只使用其中某一产品族
  • 产品等级结构稳定，设计完成之后，不会向系统中增加新的产品等级结构或者删除已有的产品等级结构

抽象工厂模式可以很方便根据现有的产品等级结构生成新的产品族，但是增加新的产品等级结构会很麻烦，这种性质称为开闭原则的倾斜性

#[object Object] #设计模式
面向对象六大原则 Scrapy学习笔记03-Spiders

评论

Your browser is out-of-date!

Update your browser to view this website correctly. Update my browser now

×