1、单例模式

单例模式的八种方式：饿汉式（静态常量）、饿汉式（静态代码块）、懒汉式（线程不安全）、懒汉式（线程安全，同步方法）、懒汉式（线程不安全，同步代码块）、双重检查、静态内部类、枚举

1）：饿汉式（静态常量）

​ 构造器私有化，类的内部创建对象，向外暴露一个静态的公共方法

package com.singleModel.test1;public class test01 {public static void main(String[] args) {Singleton instance02 = Singleton.getInstance();Singleton instance01 = Singleton.getInstance();System.out.println(instance01 == instance02);System.out.println(instance01.hashCode());System.out.println(instance02.hashCode());}
}
class Singleton{//1、构造器私有化private Singleton() {}//2、本类北部创建实例对象private final static Singleton instance = new Singleton();//3、提供一个工友的静态方法，返回实例对象public static Singleton getInstance(){return instance;}
}

优点：这种写法比较简单，就是在类装载的时候就完成实例化，避免了线程同步问题

缺点：（1）在类装载的时候就完成实例化，没有达到lazy loading的效果，如果从始至终从未使用过这个实例，则会造成内存的浪费。

​ （2）这种方式基于classLoader机制避免了多线程的同步问题，不过，instance在类装载的时候就实例化，在单例模式中大多数都是调用instance方法，但是导致类装载的原因有很多种，因此不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化instance就没有达到lazy loading的效果。

结论：这种单例模式可用，可能造成内存浪费。

2）：饿汉式（静态代码块）

package com.singleModel.test02;public class test01 {public static void main(String[] args) {Singleton instance02 = Singleton.getInstance();Singleton instance01 = Singleton.getInstance();System.out.println(instance01 == instance02);System.out.println(instance01.hashCode());System.out.println(instance02.hashCode());}
}class Singleton{//1、构造器私有化private Singleton() {}//2、本类北部创建实例对象private final static Singleton instance;static {instance  = new Singleton();}//3、提供一个工友的静态方法，返回实例对象public static Singleton getInstance(){return instance;}
}

优缺点说明：

​ 这种方式和上面的方式其实类似，只不过将实例化的过程放在了静态代码块中，也是在类装载的时候，就执行静态代码块中的代码，初始化的实例。优缺点和上面也是一样的。

结论：这种单例模式可用，但是可能造成内存浪费。

3）懒汉式（线程不安全）

package com.singleModel.test03;public class test01 {public static void main(String[] args) {Singleton instance02 = Singleton.getInstance();Singleton instance01 = Singleton.getInstance();System.out.println(instance01 == instance02);System.out.println(instance01.hashCode());System.out.println(instance02.hashCode());}
}class Singleton{//1、构造器私有化private Singleton() {}//2、本类北部创建实例对象private static Singleton instance;//3、提供一个工友的静态方法，返回实例对象public static Singleton getInstance(){if(instance == null){instance = new Singleton();}return instance;}
}

优缺点说明：

​ 起到了lazy loading的效果，但是只能在单线程下使用，如果在多线程下，一个线程进入了if(singleton == null)判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例，所以在多线程环境下不可使用这种模式。

结论：在实际开发中，不要使用这种方式。

4）：懒汉式（线程安全，同步方法）

package com.singleModel.test04;public class test01 {public static void main(String[] args) {Singleton instance02 = Singleton.getInstance();Singleton instance01 = Singleton.getInstance();System.out.println(instance01 == instance02);System.out.println(instance01.hashCode());System.out.println(instance02.hashCode());}
}class Singleton{//1、构造器私有化private Singleton() {}//2、本类北部创建实例对象private static Singleton instance;//3、提供一个工友的静态方法，返回实例对象public static synchronized Singleton getInstance(){if(instance == null){instance = new Singleton();}return instance;}
}

优缺点分析：

​ 解决了线程不安全的问题，效率太低了，每个线程在想获得类的实例的时候，执行getInstance()方法否要进行同步，而其实这个方法只执行一次实例化代码就够了，后面的相获得该实例，直接return就行了，方法进行同步效率太低。

结论：在实际开发中，不推荐使用这种方式

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

package com.singleModel.test05;public class test01 {public static void main(String[] args) {Singleton instance02 = Singleton.getInstance();Singleton instance01 = Singleton.getInstance();System.out.println(instance01 == instance02);System.out.println(instance01.hashCode());System.out.println(instance02.hashCode());}
}class Singleton{//1、构造器私有化private Singleton() {}//2、本类北部创建实例对象private static Singleton instance;//3、提供一个工友的静态方法，返回实例对象public static Singleton getInstance(){if(instance == null){synchronized (Singleton.class){instance = new Singleton();}}return instance;}
}

优缺点说明：

​ 这种方式，本意是想对第四种实现方式的改进，因为前面同步方法效率太低，改为同步产生实例化的代码块，但是这种不同步并不能起到线程同步的作用，跟第三种实现方式遇到的情形一样，假如一个线程进入了if（singleton == null）判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生过个实例。

结论：在实际开发中，不能使用这种方式。

6）双重检查

package com.singleModel.test06;public class test01 {public static void main(String[] args) {Singleton instance02 = Singleton.getInstance();Singleton instance01 = Singleton.getInstance();System.out.println(instance01 == instance02);System.out.println(instance01.hashCode());System.out.println(instance02.hashCode());}
}
class Singleton{//1、构造器私有化private Singleton() { }//2、本类北部创建实例对象private static volatile Singleton instance;//3、提供一个工友的静态方法，返回实例对象public static Singleton getInstance(){if(instance == null){synchronized (Singleton.class){if(instance == null){instance = new Singleton();}}}return instance;}
}

优缺点说明：

​ Double-Check概念是多线程开发中常使用到的，如代码中所示，我们进行了两次if(singleton == null)检查，这样就可以保证线程安全了

​ 这样，实例化代码只用执行一次，后面再次访问时，判断if（singleton == null）,直接return实例化对象，也避免了反复进行方法同步，线程安全，延迟加载，效率较高

结论：在实际开发中，推荐使用这种单例设计模式。

7）：静态内部类

package com.singleModel.test07;public class test01 {public static void main(String[] args) {Singleton instance02 = Singleton.getInstance();Singleton instance01 = Singleton.getInstance();System.out.println(instance01 == instance02);System.out.println(instance01.hashCode());System.out.println(instance02.hashCode());}
}class Singleton{//1、构造器私有化private Singleton() { }//2、本类北部创建实例对象private static volatile Singleton instance;//3.在Singleton装载的时候，静态内部类不会被装载，从而实现懒加载private static class SingletonInstance{private static final Singleton INSTANCE = new Singleton();}//JVM在装载类的时候  是线程安全的public static Singleton getInstance(){return SingletonInstance.INSTANCE;}
}

​ 这种方式采用了类装载的机制来保证初始化实例时只有一个线程，静态内部类方式在Singleton被装载是并不会立即实例化，而是在需要实例化时，调用getInstance方法，才会装载SinglrtonInstance类，从而完成Singleton的实例化，类的静态属性只会在第一次加载类的时候初始化，所以在这里，JVM帮助我们保证了线程的安全性，在类进行初始化时，别的线程是无法进入的。

优点：避免了线程不安全，利用静态内部类特点实现延迟加载，效率高。

结论：推荐使用

8）枚举

package com.singleModel.test08;public class Test08 {public static void main(String[] args) {Singleton instance = Singleton.instance;Singleton instance1 = Singleton.instance;System.out.println(instance == instance1);System.out.println(instance.hashCode());System.out.println(instance1.hashCode());}
}
enum Singleton{instance;public void method(){System.out.println("hello~");}
}

​ 借助JDK1.5中添加的枚举来实现单例对象，不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象，这种方式是Effective Java作者Josh Bloch提倡的方式。

结论：推荐使用

单例模式注意事项和细节说明：

​ 单例模式保证了系统内存中该类只存在一个对象，节省了系统资源，对于一些需要频繁创建销毁的对象，使用单例模式可以提高系统性能，当想实例化一个单例类的时候，必须要记住使用响应的获取对象的方法，而不是使用new

​ 单例模式使用的场景：需要频繁的进行创建和销毁对象，创建对象耗时过多或耗费资源过多（即：重量级对象），但又经常用到的对象，工具类对象，频繁访问数据库或者文件的对象（比如数据源，session工厂等）

2、工厂模式

package com.factoryModel;public abstract class Pizza {private String name;public String getName() {return name;}public void setName(String name) {this.name = name;}//准备元材料，不同的披萨做法不一样，所以做成抽象方法public abstract void prepare();public void bake(){System.out.println(name + "is bake");}public void cut(){System.out.println(name + "is cut");}public void box(){System.out.println(name + "is box");}
}

package com.factoryModel;
public class CheesePizza extends Pizza {public void prepare() {System.out.println("制作奶酪披萨准备原材料");}
}

package com.factoryModel;import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;public class OrderPizza {public OrderPizza() {Pizza pizza = null;String orderType;do {orderType = getType();if(orderType.equals("cheese")){pizza = new CheesePizza();pizza.setName("cheese");}else if (orderType.equals("greece")){pizza = new GreecePizza();pizza.setName("greece");} else {break;}pizza.prepare();pizza.bake();pizza.cut();pizza.box();}while (true);}private String getType(){BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));System.out.println("input is ");try {String readLine = bufferedReader.readLine();return readLine;} catch (IOException e) {return "";}}
}

package com.factoryModel;public class PizzaStore {public static void main(String[] args) {new OrderPizza();}
}

传统方式的优缺点：

​ 优点：比较好理解，简单易操作

​ 缺点：违反了设计模式的ocp原则。即对扩展开放，对修改关闭，当我们给类新增加功能的时候，尽量不修改代码，或者尽可能减少修改代码。

1）简单工厂模式：

​ 简单工厂模式是属于创建型模式，是工厂模式的一种，简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例，简单工厂模式是工厂模式家族中最简单使用的模式，

​ 简单工厂模式：定义了一个创建对象的类，由这个类来封装实例化对象的行为。

​ 在软件开发中，当我们会用到大量的创建某种、某类或者某批对象时，就会使用到工厂模式。

package com.factoryModel.simpleFactory;import com.factoryModel.CheesePizza;
import com.factoryModel.GreecePizza;
import com.factoryModel.Pizza;public class SimpleFactory {//增加orderType,返回对应的Pizza对象public Pizza createPizza(String orderType){Pizza pizza = null;System.out.println("使用简单工厂模式");if(orderType.equals("cheese")){pizza = new CheesePizza();pizza.setName("cheese");}else if (orderType.equals("greece")){pizza = new GreecePizza();pizza.setName("greece");}return pizza;}
}

package com.factoryModel.simpleFactory;import com.factoryModel.Pizza;import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;public class OrderPizza {SimpleFactory simpleFactory;//构造器public OrderPizza(SimpleFactory simpleFactory) {setFactory(simpleFactory);}public void setFactory(SimpleFactory simpleFactory){String orderType = "";this.simpleFactory = simpleFactory;do {orderType = getType();Pizza pizza = this.simpleFactory.createPizza(orderType);if( pizza != null){pizza.prepare();pizza.bake();pizza.cut();pizza.box();}else{System.out.println("订购失败");break;}}while (true);}private String getType(){BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));System.out.println("input is ");try {String readLine = bufferedReader.readLine();return readLine;} catch (IOException e) {return "";}}
}

package com.factoryModel.simpleFactory;public class PizzaStore {public static void main(String[] args) {new OrderPizza(new SimpleFactory());}
}

2. 工厂方法模式

​ 工厂方法模式定义了一个创建对象的抽象方法，由子类决定要实例化的类，工厂方法模式将对象的实例化推迟到子类。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Y1YlPNru-1595929884627)(D:\大数据\设计模式\picture\方法工厂模式.png)]

package com.factoryModel.methodFactory;public abstract class Pizza {private String name;public String getName() {return name;}public void setName(String name) {this.name = name;}//准备元材料，不同的披萨做法不一样，所以做成抽象方法public abstract void prepare();public void bake(){System.out.println(name + "is bake");}public void cut(){System.out.println(name + "is cut");}public void box(){System.out.println(name + "is box");}
}

package com.factoryModel.methodFactory;public class BJCheesePizza extends Pizza {public void prepare() {setName("北京奶酪披萨");System.out.println("北京的奶酪准备原材料");}
}

package com.factoryModel.methodFactory;public class BJPepperPizza extends Pizza {public void prepare() {setName("北京胡椒披萨");System.out.println("北京的胡椒准备原材料");}
}

package com.factoryModel.methodFactory;public class LDCheesePizza extends Pizza {public void prepare() {setName("伦敦奶酪披萨");System.out.println("伦敦的奶酪准备原材料");}
}

package com.factoryModel.methodFactory;public class LDPepperPizza extends Pizza {public void prepare() {setName("伦敦胡椒披萨");System.out.println("伦敦的胡椒准备原材料");}
}

package com.factoryModel.methodFactory;public class BJOrderPizza extends OrderPizza{Pizza createPizza(String orderType) {Pizza pizza = null;if(orderType.equals("cheese")){pizza = new BJCheesePizza();}else if(orderType.equals("pepper")){pizza =  new BJPepperPizza();}return pizza;}
}

package com.factoryModel.methodFactory;public class LDOrderPizza extends OrderPizza {Pizza createPizza(String orderType) {Pizza pizza = null;if(orderType.equals("cheese")){pizza = new LDCheesePizza();}else if(orderType.equals("pepper")){pizza = new LDPepperPizza();}return pizza;}
}

package com.factoryModel.methodFactory;public class PizzaStore {public static void main(String[] args) {//new BJOrderPizza();new LDOrderPizza();}
}

3. 抽象工厂模式

​ 抽象工厂模式定义了一个interface用于创建相关或有依赖关系的对象簇，而无需指明具体的类。

​ 抽象工厂模式可以将简单工厂模式和工厂方法模式进行整合。从设计层面看，抽象工厂模式就是对简单工厂模式的改进（或者称进一步的抽象），将工厂抽象成两层，AbsFactory（抽象工厂）和具体实现的工厂子类，程序员可以根据创建对象类型使用对应的工厂子类，这样将单个的简单工厂类变成了工厂簇，更利于代码的的维护和扩展。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-esMS2LEA-1595929884629)(D:\大数据\设计模式\picture\抽象工厂模式.png)]

package com.factoryModel.absFactory.order;import com.factoryModel.absFactory.pizza.Pizza;public interface AbsFactory {public Pizza createPizza(String orderType);
}

package com.factoryModel.absFactory.order;import com.factoryModel.absFactory.pizza.BJCheesePizza;
import com.factoryModel.absFactory.pizza.BJPepperPizza;
import com.factoryModel.absFactory.pizza.Pizza;public class BJFactory implements AbsFactory {public Pizza createPizza(String orderType) {Pizza pizza = null;if(orderType.equals("cheese")){pizza = new BJCheesePizza();}else if(orderType.equals("pepper")){pizza = new BJPepperPizza();}return pizza;}
}

package com.factoryModel.absFactory.order;import com.factoryModel.absFactory.pizza.LDCheesePizza;
import com.factoryModel.absFactory.pizza.LDPepperPizza;
import com.factoryModel.absFactory.pizza.Pizza;public class LDFactory implements AbsFactory {public Pizza createPizza(String orderType) {Pizza pizza = null;if(orderType.equals("cheese")){pizza = new LDCheesePizza();}else if(orderType.equals("pepper")){pizza = new LDPepperPizza();}return pizza;}
}

package com.factoryModel.absFactory.order;import com.factoryModel.absFactory.pizza.Pizza;import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;public class OrderPizza {AbsFactory factory;public OrderPizza(AbsFactory factory) {setFactory(factory);}private void setFactory(AbsFactory factory){Pizza pizza = null;String orderType = "";this.factory = factory;do {orderType = getType();pizza =factory.createPizza(orderType);if(pizza != null){pizza.prepare();pizza.bake();pizza.cut();pizza.box();}else{System.out.println("订购失败");break;}}while (true);}private String getType(){BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));System.out.println("input is ");try {String readLine = bufferedReader.readLine();return readLine;} catch (IOException e) {return "";}}
}

package com.factoryModel.absFactory.order;public class PizzaStore {public static void main(String[] args) {new OrderPizza(new BJFactory());}
}

工厂模式小结：

（1）工厂模式的意义：将实例化对象的代码提取出来，放到一个类中统一管理和维护，达到和主项目的依赖关系的解耦，从而提高项目的扩展和维护性。

（2）三种工厂模式：简单工厂模式、工厂方法模式、抽象工厂模式

（3）设计模式的依赖抽象原则

​ 创建对象实例时，不要直接new类，而是把这个new类的动作放在一个工厂的方法中，并返回。有的书上说，变量不要直接持有具体类的引用。

​ 不要让类继承具体类，而是继承抽象类或者是实现interface(接口)

​ 不要覆盖基类中已经实现的方法。