设计模式可分为三种：创建型模式、结构型模式和行为型模式
- 创建型模式是什么？
简单来说就是帮我们
创建对象的
- **创建模式又有：
单例模式、工厂模式、建造者模式和原型模式**
单例模式
** 核心作用**：
保证一个类只有一个实例，并且提供一个访问该实例的全局访问点
** 优点**：– 由于单例模式只生成一个实例，
减少了系统性能开销，当一个对象的产生需要比较多的资源时，如读取配置、产生其他依赖对象时，则可以通过在应用启动时直接产生一个单例对象，然后永久驻留内存的方式来解决 ；
– 单例模式可以在系统设置全局的访问点，
优化环共享资源访问，例如可以设计一个单例类，负责所有数据表的映射处理。
** 实现单例模式的5种方式：**
- 饿汉式：线程安全，调用效率高，不能延时加载
（ps:
饿汉式单例模式代码中，static变量会在类装载时初始化，此时也不会涉及多个线程对象访问该对象的问题。虚拟机保证只会装载一次该类，肯定不会发生并发访问的问题。因此，可以省略synchronized关键字。
问题：如果只是加载本类，而不是要调用getInstance()，甚至永远没有调用，则会造成资源浪费！
）
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
2
3/**
4 * 测试饿汉式单例模式
5 */
6public class SingletonDemo1 {
7
8 //类初始化时，立即加载这个对象（没有延时加载的优势）。加载类时，天然的是线程安全的！
9 private static SingletonDemo1 instance = new SingletonDemo1();
10
11 private SingletonDemo1(){
12 }
13
14 //方法没有同步，调用效率高！
15 public static SingletonDemo1 getInstance(){
16 return instance;
17 }
18
19}
20
21
- 懒汉式：线程安全，调用效率低（因为方法同步），能延时加载
(ps:问题 资源利用率高了。但是，每次调用getInstance()方法都要同步，并发效率较低。 )
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
2
3/**
4 * 测试懒汉式单例模式
5 */
6public class SingletonDemo2 {
7
8 //类初始化时，不初始化这个对象（延时加载，真正用的时候再创建）。
9 private static SingletonDemo2 instance;
10
11 private SingletonDemo2(){ //私有化构造器
12 }
13
14 //方法同步，调用效率低！
15 public static synchronized SingletonDemo2 getInstance(){
16 if(instance==null){
17 instance = new SingletonDemo2();
18 }
19 return instance;
20 }
21
22}
23
24
- 双重检测锁式：线程安全，调用效率高（只是比懒汉式好），能延时加载，
由于JVM底层内部模型原因，偶尔会出问题。不建议使用
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
2
3/**
4 * 双重检查锁实现单例模式(不推荐使用)
5 */
6public class SingletonDemo3 {
7
8 private static SingletonDemo3 instance = null;
9
10 public static SingletonDemo3 getInstance() {
11 if (instance == null) {
12 SingletonDemo3 sc;
13 synchronized (SingletonDemo3.class) {
14 sc = instance;
15 if (sc == null) {
16 synchronized (SingletonDemo3.class) {
17 if (sc == null) {
18 sc = new SingletonDemo3();
19 }
20 }
21 instance = sc;
22 }
23 }
24 }
25 return instance;
26 }
27
28 private SingletonDemo3() {
29
30 }
31
32}
33
34
- 静态内部类式：线程安全，调用效率高，能延时加载
(
外部类没有static属性，则不会像饿汉式那样立即加载对象.只有真正调用getInstance(),才会加载静态内部类。加载类时是线程 安全的。 instance是static final类型，保证了内存中只有这样一个实例存在，而且只能被赋值一次，从而保证了线程安全性。
兼备了并发高效调用和延迟加载的优势
！)
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
2
3/**
4 * - 外部类没有static属性，则不会像饿汉式那样立即加载对象。
5 * – 只有真正调用getInstance(),才会加载静态内部类。加载类时是线程安全的。
6 * instance是static final 类型
7 * 保证了内存中只有这样一个实例存在，而且只能被赋值一次，从而保证了线程安全性.
8 * – 兼备了并发高效调用和延迟加载的优势！
9 *
10 * * 测试静态内部类实现单例模式
11 * * 这种方式：线程安全，调用效率高，并且实现了延时加载！
12 */
13public class SingletonDemo4 {
14 //静态内部类
15 private static class SingletonClassInstance{
16 private static final SingletonDemo4 instance=new SingletonDemo4();
17 }
18
19 public static SingletonDemo4 getInstance(){
20 return SingletonClassInstance.instance;
21 }
22
23 private SingletonDemo4(){
24
25 }
26
27}
28
29
- 枚举单例：线程安全，调用效率高，不能延时加载
（可以避免通过反射和反序列的方式破坏单例）
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
2
3/**
4 * 线程安全，调用效率高，不能延时加载
5 */
6public enum SingletonDemo5 {
7 //定义一个枚举元素 代表一个单例
8 INSTANCE;
9 //单例可以有自己的操作
10 public void singletonOperation(){
11 //功能处理
12 }
13
14}
15
16
除了枚举方式，其他方式可以通过反射和反序列化来破坏单例，我们可以这样做：
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
2
3import java.io.ObjectStreamException;
4import java.io.Serializable;
5
6/**
7 * 测试懒汉式单例模式(如何防止反射和反序列化漏洞)
8 *
9 */
10public class SingletonDemo6 implements Serializable {
11 //类初始化时，不初始化这个对象（延时加载，真正用的时候再创建）。
12 private static SingletonDemo6 instance;
13
14 private SingletonDemo6(){ //私有化构造器
15 if(instance!=null){
16 throw new RuntimeException();
17 }
18 }
19
20 //方法同步，调用效率低！
21 public static synchronized SingletonDemo6 getInstance(){
22 if(instance==null){
23 instance = new SingletonDemo6();
24 }
25 return instance;
26 }
27
28 //反序列化时，如果定义了readResolve()则直接返回此方法指定的对象。而不需要单独再创建新对象！
29 private Object readResolve() throws ObjectStreamException {
30 return instance;
31 }
32
33}
34
35
所以这么多种方式，我们要怎么抉择呢？
如果单例对象占用资源少，且需要延时，静态内部类方式比懒汉式要好；
如果单例对象占用资源大，且不需要延时，枚举方式比饿汉式要好。
工厂模式
（工厂模式实现了创建者和调用者的分离）
• 核心本质：
– 实例化对象，用工厂方法代替new操作。
– 将选择实现类、创建对象统一管理和控制。从而将调用者跟我们的实现类
解耦
。
• 这里需要简单说下面向对象设计的原则：
- OCP（开闭原则，Open-Closed Principle）：一个软件的实体应当对扩展开放，对修改关闭。
- DIP（依赖倒转原则，Dependence Inversion Principle）：要针对接口编程不要针对实现编程。
- LoD（迪米特法则，Law of Demeter）：只与你直接的朋友通信，而避免和陌生人通信。
• 工厂模式可分为3种：
简单工厂、工厂方法、抽象工厂
– 简单工厂模式（不满足OCP原则，但实际使用最多）
• 用来生产同一等级结构中的任意产品。（对于增加新的产品，需要修改已有代码）
– 工厂方法模式（弥补了简单工厂不满足OCP原则，但是并不实用）
• 用来生产同一等级结构中的固定产品。（支持增加任意产品）
– 抽象工厂模式
• 用来生产不同产品族的全部产品。（对于增加新的产品，无能为力；支持增加产品族）
建造者模式
建造模式的本质：****
– 分离了对象子组件的单独构造(由Builder来负责)和装配(由Director负责)。 从而可以构造出复杂的对象。
这个模式适用于：
某个对象的构建过程复杂的情况下使用。
– 由于实现了构建和装配的解耦。不同的构建器，相同的装配，也可以做出不同的对象；
相同的构建器，不同的装配顺序也可以做出不同的对象。也就是
实现了构建算法、装配算法的解耦，实现了更好的复用。
原型模式
原型模式实现方式：
Cloneable接口和clone方法
创建对象，通过new创建，需要非常繁琐的数据准备或访问权限，这个时候就可以使用原型模式（就是克隆）
克隆，又有
浅克隆和
深克隆
• 浅克隆存在的问题
– 被复制的对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用都仍然指向原来的对象。
• 深克隆如何实现?
– 深克隆把引用的变量指向复制过的新对象，而不是原有的被引用的对象。
– 深克隆：让已实现Clonable接口的类中的属性也实现Clonable接口
– 基本数据类型和String能够自动实现深度克隆（值的复制）
创建型模式总结
– 单例模式
• 保证一个类只有一个实例，并且提供一个访问该实例的全局访问点。
– 工厂模式
• 简单工厂模式
– 用来生产同一等级结构中的任意产品。（对于增加新的产品，需要修改已有代码）
• 工厂方法模式
– 用来生产同一等级结构中的固定产品。（支持增加任意产品）
• 抽象工厂模式
– 用来生产不同产品族的全部产品。（对于增加新的产品，无能为力；支持增加产品族）
– 建造者模式
• 分离了对象子组件的单独构造(由Builder来负责)和装配(由Director负责)。 从而可以构造出复杂的对象。
– 原型模式
• 通过new产生一个对象需要非常繁琐的数据准备或访问权限，则可以使用原型模式
