基本概念

软件设计原则

设计原则 解释
开闭原则 对扩展开放，对修改关闭。
依赖倒置原则 通过抽象使各个类或者模块不相互影响，实现松耦合。
单一职责原则 一个类、接口、方法只做一件事。
接口隔离原则 尽量保证接口的纯洁性，客户端不应该依赖不需要的接口。
迪米特法则 又叫最少知道原则，一个类对其所依赖的类知道得越少越好。
里氏替换原则 子类可以扩展父类的功能但不能改变父类原有的功能。
合成复用原则 尽量使用对象组合、聚合，而不使用继承关系达到代码复用的目的。

创建型模式

创建型模式的作用就是创建对象，说到创建一个对象，最熟悉的就是 new 一个对象，然后 set 相关属性。但是，在很多场景下，我们需要给客户端提供更加友好的创建对象的方式，尤其是那种我们定义了类，但是需要提供给其他开发者用的时候。

简单工厂模式

简单工厂模式(Simple Factory Pattern):又称为静态工厂方法(Static Factory Method)模式，它属于类创建型模式。在简单工厂模式中，可以根据参数的不同返回不同类的实例。简单工厂模式专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。

image-20201112144549270

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
public class ProductFactory {

    public Product create(String type) {
        if ("A".equals(type)) {
            return new ProductA();
        } else if ("B".equals(type)) {
            return new ProductB();
        } else {
            return null;
        }
    }

    public static void main(String[] args) {
        ProductFactory factory = new ProductFactory();
        Product product = factory.create("A");
        product.print();
        product = factory.create("B");
        product.print();
    }
}


interface Product {
    public abstract void print();
}

class ProductA implements Product {
    @Override
    public void print() {
        System.out.println("A");
    }
}

class ProductB implements Product {
    @Override
    public void print() {
        System.out.println("B");
    }
}

其中，ProductA 和 ProductB 都继承自 Product。

简单地说，简单工厂模式通常就是这样，一个工厂类 XxxFactory，里面有一个静态方法，根据我们不同的参数，返回不同的派生自同一个父类（或实现同一接口）的实例对象。

我们强调职责单一原则，一个类只提供一种功能，ProductFactory 的功能就是只要负责生产各种 Product。

工厂模式

定义一个用于创建对象的接口，让子类决定实例化哪个类。工厂方法使一个类的实例化延迟到其子类。在工厂方法 模式中用户只需要关心所需产品对应的工厂，无须关心创建细节，而且加入新的产品符合开闭原则。

image-20201112150057245

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
public interface Factory {

    public Product createProduct();

    public static void main(String[] args) {
        // 创建A
        Factory factory = new FactoryA();
        Product product = factory.createProduct();
        product.print();
        // 创建B
        factory = new FactoryB();
        product = factory.createProduct();
        product.print();
    }
}


class FactoryA implements Factory {
    @Override
    public Product createProduct() {
        return new ProductA();
    }
}


class FactoryB implements Factory {
    @Override
    public Product createProduct() {
        return new ProductB();
    }
}

interface Product {
    public abstract void print();
}

class ProductA implements Product {
    @Override
    public void print() {
        System.out.println("A");
    }
}

class ProductB implements Product {
    @Override
    public void print() {
        System.out.println("B");
    }
}

优点

缺点

  • 只能创建一大类产品

抽象工厂

image-20201112153326283

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
/**
 * 抽象工厂
 */
interface AbstractFactory {
    Phone createPhone(String param);
    Mask createMask(String param);
}

/**
 * 具体工厂
 */
class SuperFactory implements AbstractFactory {
    @Override
    public Phone createPhone(String param) {
        return new iPhone();
    }

    @Override
    public Mask createMask(String param) {
        return new N95();
    }
}

/**
 * 产品大类一手机
 */
interface Phone {}

class iPhone implements Phone {}

/**
 * 产品大类一口罩
 */
interface Mask {}

class N95 implements Mask {}