设计模式之单例模式和工厂模式

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());
    }
}

工厂方法模式

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

在这里插入图片描述

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();
    }
}

抽象工厂模式

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

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

在这里插入图片描述

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(接口)

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