创建型模式

1.单例模式

单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

• 注意：
  • 1、单例类只能有一个实例。
  • 2、单例类必须自己创建自己的唯一实例。
  • 3、单例类必须给所有其他对象提供这一实例。

import java.util.HashSet;
import java.util.Set;
 
public class SingleInstance {
    /**
     * 我用一个private的Static的变量来存放我们的SIngleInstance的实例
     */
    private static SingleInstance singleInstance = null;
    /**
     * 让构造方法编程私有的，这样我们可以防止在外面被其他类直接new出来，构造方	 *  法同其它方法一样，也可以用private修饰，私有的构造方法无法在本类外部使	 *  用，也就导致本类无法用new实例化，这样可以控制对象的生成。
     */
    private SingleInstance() {
    }
    /**
     * 我们提供一个静态的方法来创建我们的单例
     * @return
     */
    public static SingleInstance instance() throws InterruptedException {
        Thread.sleep(1000);
        if (singleInstance == null) {
            synchronized (SingleInstance.class) {
                if (singleInstance == null) {
                    System.out.println("我被new出来了");
                    singleInstance = new SingleInstance();
                }
            }
        }
        return singleInstance;
    }
    public static void main(String[] args) {
        Runnable runnable = () -> {
            try {
                instance();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        };
        Set<Thread> threads = new HashSet<>();
        for (int i = 0; i < 10; i++) {
            threads.add(new Thread(runnable));
        }
        threads.forEach(t -> t.start());
    }
}

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

参考链接：
https://www.cnblogs.com/qq895139140/p/7774152.html

1.1 懒汉式-线程不安全

单例类的实例在第一次被引用时候才被初始化。
public class Singleton {  
    private static Singleton instance=null;  
      
    private Singleton() {  
          
    }  
      
    public static Singleton getInstance(){  
        if (instance == null) {  
            instance = new Singleton();  
        }  
          
        return instance;  
    }  
}

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

1.2 懒汉式-线程安全

这种方式效率比较低，性能不是太好，不过也可以用，因为是对整个方法加上了线程同步，其实只要在new的时候考虑线程同步就行了，这种方法不推荐使用。

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

1.3 饿汉式

单例类的实例在加载的时候就被初始化。

public class Singleton {  
    private static Singleton instance = new Singleton();  
      
    private Singleton() {  
          
    }  
      
    public static Singleton getInstance(){  
        return instance;  
    }  
}
1
2
3
4
5
6
7
8
9
10
11

1.4 懒汉式-同步代码块

synchronized同步块括号中的锁定对象是采用的一个无关的Object类实例，而不是采用this，因为getInstance是一个静态方法，在它内部不能使用未静态的或者未实例的类对象

public class Singleton {  
    private static Singleton instance;  
    private final static Object syncLock = new Object();  
      
    private Singleton() {  
          
    }  
      
    public static Singleton getInstance(){  
        if (instance == null) {  
            synchronized (syncLock) {  
                if (instance == null) {  
                    instance = new Singleton();  
                }  
            }  
        }  
          
        return instance;  
    }  
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

1.5 懒汉式–同步类（最终）

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

2. 简单工厂

简单来说：简单工厂模式主要是工厂类根据参数的不同来创建不同类的实例，通常这些不同类拥有同一个父类。因为静态方法，也叫做静态工厂模式。

其实JDK中也广泛使用了这种模式，如DataFormat类，根据参数不同，会创建data、time、datatime类等等。

2.1 简单实现

• 简单工厂模式属于类创建型模式
  • 可以根据参数的不同返回不同的实例
  • 专门创建一个类来创建其他类的实例
  • 被创建的实例通常具有共同的父类

简单工厂中的角色:

1. 抽象产品类
2. 产品子类
3. 工厂类

abstract class Product{
	public void use() {

	}
}

class ProductA extends Product {
	public void use(){
		System.out.println(使用了产品A);
	}
}

class ProductB extends Product {
		public void use(){
		System.out.println(使用了产品B);
	}
}

class Factory{

	public static Product createProduct(String type){
		if (type.equals(A)){
			return new ProductA();
		}else if (type.equals(B)) {
			return new ProductB();
		}
		return new ProductA();
	}
}
*/
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

2.2 优缺点

• 优点：创建由专门的工厂类负责，客户端成员不用关心其是怎么创建的，直接使用就行。

  • （1）工厂类包含必要的逻辑判断，可以决定在什么时候创建哪一个产品的实例。客户端可以免除直接创建产品对象的职责
  • （2）客户端无需知道所创建具体产品的类名，只需知道参数即可

• 缺点：工厂类不够灵活，如何新增一个产品，则需要修改逻辑，如果产品越多，则越复杂。

  • （1）工厂类集中了所有产品的创建逻辑，职责过重，一旦异常，整个系统将受影响
  • （2）使用简单工厂模式会增加系统中类的个数(引入新的工厂类)，增加系统的复杂度和理解难度
  • （3）系统扩展困难，一旦增加新产品不得不修改工厂逻辑，在产品类型较多时，可能造成逻辑过于复杂，违反开发封闭原则。

2.3适用环境

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

2.4 扩充

工厂类：
根据参数，创建A/B产品，普通
直接多个方法，创建A/B产品，多方法
静态方法，创建A/B产品，静态方法

3. 工厂模式

3.1 简单工厂模式：

3.2 工厂模式：

注：从图上看，感觉更复杂了，但是，计算机中有一个“开闭原则”（扩展优于修改），这里举个例子，一个工厂，生产拖拉机，然后又生产口罩，那么为了更好的区别，最好是工厂下有个拖拉机工厂，有一个口罩工厂。

Jdk同样也用了这种思想：

4.抽象工厂方法

对类进行区分，如果都生产手机，你要生产口罩，则工厂方法就显得不合适了，因为接口功能不一样了，所以增加一个产品接口，表示一个大类，然后在工厂接口中，可以同时创建手机和口罩的对象，但是这样明显也违反了“开发封闭”原则。

5. 原型模型

6. 生成器模型

在产品结构比较复杂,构造过程比较繁琐,一次性构造比较难的时候,我们可以采取分而治之的原则,将产品组件化,每个组件由专门的厂商来生产,最后的产品指派给制定的车间进行最后装配.这种方式其实是现代制造业的一种典型的模式.比如汽车,飞机的制造等.这样做的好处是：

• 1.产品的部件由专门的生产厂商来生产,这样分工更加明确,更加精细,生产专业化,可以降低成本;
• 2.整个产品的生产更加简单,也可增加零件的复用.
• 3.转换生产比较容易,比如产品的材质发生变化,只需要找相应提供该材质的厂商即可.