设计模式

1、简单工厂设计模式

简单工厂模式最大的优点在于实现对象的创建和对象的使用分离，将对象的创建交给专门的工厂类负责，但是其最大的缺点在于工厂类不够灵活，增加新的具体产品需要修改工厂类的判断逻辑代码，而且产品较多时，工厂方法代码将会非常复杂。

简单工厂模式包含如下角色：

• Factory：工厂角色

  工厂角色负责实现创建所有实例的内部逻辑

• Product：抽象产品角色

  抽象产品角色是所创建的所有对象的父类，负责描述所有实例所共有的公共接口

• ConcreteProduct：具体产品角色

  具体产品角色是创建目标，所有创建的对象都充当这个角色的某个具体类的实例。

类图：

2、工厂方法模式

优点：
此模式中，通过定义一个抽象的核心工厂类，并定义创建产品对象的接口，创建具体产品实例的工作延迟到其工厂子类去完成。这样做的好处是核心类只关注工厂类的接口定义，而具体的产品实例交给具体的工厂子类去创建。当系统需要新增一个产品是，无需修改现有系统代码，只需要添加一个具体产品类和其对应的工厂子类，使系统的扩展性变得很好，符合面向对象编程的开闭原则。

缺点：

工厂方法模式虽然扩展性好，但是增加了编码难度，大量增加了类的数量，所以怎么选择还是看实际的需求。

工厂方法模式包含如下角色：

• Product：抽象产品
• ConcreteProduct：具体产品
• Factory：抽象工厂
• ConcreteFactory：具体工厂

例子：

//宝马和奔驰的共同父类
public class Car {
    private String name;

    public void run(){
        System.out.println(name+"在马路上跑...");
    }
    ...
}

public class BenzCar extends Car{
    public BenzCar() {
        super("奔驰");
    }
}

public class BMWCar extends Car{
    public BMWCar() {
        super("宝马");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

//定义工厂接口Factory
public interface CarFactory {
    //生产一辆车，工厂子类重写这个方法
    Car creat();
}

//奔驰车的工厂方法，实现工厂接口，返回新创建的奔驰车实例
public class BenzCarFactory implements CarFactory{
    @Override
    public Car creat() {
        return new BenzCar();
    }
}

//宝马车的工厂方法，实现工厂接口，返回新创建的奔驰车实例
public class BMWCarFactory implements CarFactory{
    @Override
    public Car creat() {
        return new BMWCar();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

所以当新增一个产品时，我们只需要新增一个实现了工厂接口的工厂方法和产品实体类。

3、抽象工厂

例1： 用抽象工厂模式设计农场类。

分析：农场中除了像畜牧场一样可以养动物，还可以培养植物，如养马、养牛、种菜、种水果等。

本例用抽象工厂模式来设计两个农场，一个是韶关农场用于养牛和种菜，一个是上饶农场用于养马和种水果，可以在以上两个农场中定义一个生成动物的方法 newAnimal() 和一个培养植物的方法 newPlant()。

// 抽象动物类
public interface Animal {
    public void disc();
}
// 为两个农场实现动物类
public class Cattle implements Animal{
    @Override
    public void disc() {
        System.out.println("奶牛产的奶真纯啊");
    }
}

public class Horse implements Animal{
    @Override
    public void disc() {
        System.out.println("马儿跑的真快啊");
    }
}

// 抽象植物类
public interface Plant {
}
// 为两个农场实现植物类
public class Fruit implements Plant{
}
public class Vegetable implements Plant{
}
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

// 为两个农场抽象农场类
public abstract interface Farm {
    abstract Animal creatAnimal();
    abstract Plant creatPlant();
}

// 上饶农场产出奶牛和蔬菜
public class SGfarmFactory implements Farm{
    @Override
    public Animal creatAnimal() {
        return new Cattle();
    }

    @Override
    public Plant creatPlant() {
        return new Vegetable();
    }
}

// 韶关农场产出马和水果
public class SRfarmfFactory implements Farm{

    @Override
    public Animal creatAnimal() {
        return new Horse();
    }

    @Override
    public Plant creatPlant() {
        return new Fruit();
    }

}
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 Main {
    public static void main(String[] args) {
        SRfarmfFactory sRfarmfFactory = new SRfarmfFactory();
        Animal animal = sRfarmfFactory.creatAnimal();
        Plant plant = sRfarmfFactory.creatPlant();
        animal.disc();
    }
}
1
2
3
4
5
6
7
8
9

抽象工厂模式是工厂方法模式的升级版本，在有多个业务品种、业务、分类时，通过抽象工厂模式产生需要的对象是一种非常好的解决方式。

4 、创建者设计模式

public class Computer {
    // 鼠标
    public String mouse;
    // 键盘
    public String keyboard;
    // cpu
    public String cpu;
    // 内存
    public String memoryBank;
    // 主板
    public String mainBoard;

    // 省略构造器、get set方法、toString()
1
2
3
4
5
6
7
8
9
10
11
12
13

// 生产电脑的生成器
class ComputerBuilder{

    private final Computer computer = new Computer();

    public ComputerBuilder buildMouse(String type){
        computer.setMouse(type);
        return this;
    }

    public ComputerBuilder buildKeyboard(String type){
        computer.setKeyboard(type);
        return this;
    }

    public ComputerBuilder buildCpu(String type){
        computer.setCpu(type);
        return this;
    }


    public ComputerBuilder buildMemoryBank(String type){
        computer.setMemoryBank(type);
        return this;
    }

    public ComputerBuilder buildMainBoard(String type){
        computer.setMainBoard(type);
        return this;
    }

    public Computer build(){
        return computer;
    }
}

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

// 测试类
public class Main {
    public static void main(String[] args) {
        Computer computer = new ComputerBuilder()
                .buildMainBoard("华硕")
                .buildCpu("英特尔")
                .buildMemoryBank("三星")
                .buildKeyboard("雷柏")
                .buildMouse("罗技")
                .build();
        System.out.println(computer);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

5、 单例模式

参考

所谓类的单例设计模式,就是采取一定的方法保证在整个系统中，某个类只能存在一个对象实例（不能自己new 对象）。

首先必须将类的构造器的访问权限设置为 private 。然后对外暴露一个获取该对象的接口，因为不能new，所以只能使用静态方法获取该对象，而静态方法又只能访问类中的静态成员变量，所以，该对象也只能为静态的

单例模式主要分为饿汉式和懒汉式：
饿汉式：（创建时就已经存在对象）
坏处：对象加载时间过长。
好处：饿汉式是线程安全的。

​ 懒汉式：
好处：延迟对象的创建

单例模式的优点：

由于单例模式值生成一个实例，减少了系统性能开销，当一个对象的产生需要比较多的资源时，如读取配置、产生其他依靠对象时，则可以用过在应用启动时直接产生一个单例对象，然后永远驻留内存的方式来解决。

1、饿汉式(静态属性)（不推荐）

public class SingletonV1 {
    
    private SingletonV1() {
    }

    private static SingletonV1 instance = new SingletonV1();

    public static SingletonV1 getInstance(){
        return instance;
    }
}
1
2
3
4
5
6
7
8
9
10
11

优点：写法简单，线程安全（类装载的时候就完成实例化，JVM保证了类加载的过程是线程安全的）

缺点：不是懒加载的，如果自始至终未使用该对象，会造成内存浪费

2、饿汉式（静态代码块）（不推荐）

与方式一类似，优缺点一样，只不过将new对象放在了静态代码块中，随着类的加载而加载

3、懒汉式（线程不安全）不推荐

public class SingletonV3 {

    private static SingletonV3 instance = null;

    private SingletonV3() {
    }
    
    private static SingletonV3 getInstance(){
        if(instance == null){
            instance = new SingletonV3();
        }
        return instance;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

优点：懒加载

缺点：线程不安全

在多线程的情况下，如果多个线程同时判断instance == null，就会new多次实例，浪费资源

4、懒汉式（线程安全，同步方法）（不推荐）

public class SingletonV4 {

    private static SingletonV4 instance = null;

    private SingletonV4() {
    }

    public static synchronized SingletonV4 getInstance(){
        if(instance == null){
            instance = new SingletonV4();
        }
        return instance;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

synchronized 解决了第三个线程安全的问题，但多线程环境下，每次执行getInstance()都需要同步，效率太低。

5、懒汉式（线程安全，同步代码块）不推荐

public class SingletonV5 {

    private static SingletonV5 instance = null;

    private SingletonV5() {
    }

    public static SingletonV5 getInstance(){
        if(instance == null){
            synchronized (SingletonV5.class){
                instance = new SingletonV5();
            }
        }
        return instance;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

本意是对4的改进，但会遇到和3一样的问题

6、双重检查（懒汉式、线程安全）推荐

public class SingletonV6 {

    private static volatile SingletonV6 instance = null;

    private SingletonV6() {
    }

    public static SingletonV6 getInstance(){
        if(instance == null){
            synchronized (SingletonV6.class){
                if (instance == null){
                    instance = new SingletonV6();
                }
            }
        }
        return instance;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

对5的进一步改进，解决了5的问题

注意 该对象要加volatile修饰，

volatile关键字:

1. 保证变量的可见性：当一个被volatile关键字修饰的变量被一个线程修改的时候，其他线程可以立刻得到修改之后的结果。
   当一个线程向被volatile关键字修饰的变量写入数据的时候，虚拟机会强制它被值刷新到主内存中。
   当一个线程用到被volatile关键字修饰的值的时候，虚拟机会强制要求它从主内存中读取。

2. 屏蔽指令重排序：指令重排序是编译器和处理器为了高效，对程序进行优化的手段；
   它只能保证程序执行的结果时正确的，但是无法保证程序的操作顺序与代码顺序一致。
   这在单线程中不会构成问题，但是在多线程中就会出现问题。
   非常经典的例子是在单例方法中同时对字段加入voliate，就是为了防止指令重排序。

   比如在上述第11行中，new instance分解为3步

   1. 分配内存

   2. 初始化对象

   3. 让instance变量指向1中为对象分配的内存地址

   ​ 如果A线程在11行创建对象并出现了重排序，即先执行了1和3，B线程在第9行就会判断该对象不为空，直接返回一个未初始化的对象。

7、静态内部类

8、枚举

后面两种能实现6的效果，但在实际开发中推荐使用6

应用场景