【设计模式】学习笔记（二）——创建型设计模式

• 创建型设计模式介绍
• 创建型设计模式分类

• 简单工厂设计模式介绍
• 简单工厂设计模式实现

• 工厂方法模式介绍
• 工厂方法模式实现

• 单例设计模式介绍
• 单例模式的实现方式
  • 饿汉模式
  • 懒汉模式
  • 懒汉和饿汉的区别

步骤如下：
1）构造器私有化（防止 new）
2）类的内部创建对象
3）向外暴露一个静态的公共方法。getInstance

class Singleton{
    //1.构造器私有化，外部不能new
    private Singleton(){

    }

    //2.本类内部创建对象实例
    private final static Singleton instance = new Singleton();

    //3.提供一个公有的静态方法，放回实例对象
    public static Singleton getInstance(){
        return instance;
    }
}

1）构造器私有化（防止 new）
2）类的内部声名静态对象
3）在静态代码块中，创建单例对象
4）提供一个公有的静态方法，放回实例对象

class Singleton{

    private static Singleton instance;

    private Singleton(){

    }

    static {// 在静态代码块中，创建单例对象
        instance = new Singleton();
    }

    public static Singleton getInstance(){
        return instance;
    }
}

实现步骤
1）构造器私有化（防止 new）
2）类的内部声名静态对象
3）提供一个静态的公有方法，当使用到该方法时，才去创建 instance

class Singleton{

    private static Singleton instance;

    private Singleton(){

    }

    //提供一个静态的公有方法，当使用到该方法时，才去创建 instance
    //即懒汉式
    public static Singleton getInstance(){
        if(instance == null){
            instance = new Singleton();
        }
        return instance;
    }
}

实现步骤
1）构造器私有化（防止 new）
2）类的内部声名静态对象
3）

class Singleton{

    private static Singleton instance;

    private Singleton(){

    }

    //提供一个静态的公有方法，加入同步处理的代码，解决线程安全问题
    //即懒汉式
    public static synchronized Singleton getInstance(){
        if(instance == null){
            instance = new Singleton();
        }
        return instance;
    }
}

实现步骤
1）构造器私有化（防止 new）
2）类的内部声名静态对象
3）提供一个静态的公有方法，在代码块中加入同步处理的代码（synchronized）

class Singleton{
    private static Singleton singleton;

    private Singleton(){

    }

    //提供一个静态的公有方法，在代码块中加入同步处理的代码（synchronized）
    //即懒汉式
    public static Singleton getInstance(){
        if(singleton == null){
            synchronized(Singleton.class){
                singleton = new Singleton();
            }
        }
        return singleton;
    }
}

实现步骤
1）构造器私有化（防止 new）
2）类的内部声名静态对象并用volatile（用来确保将变量的更新操作通知到其他线程）关键字修饰
3）提供一个静态的公有方法，加入双重检查代码，解决线程安全问题，同时解决懒加载问题

class Singleton{
    private static volatile Singleton instance;

    private Singleton(){

    }

    //提供一个静态的公有方法，加入双重检查代码，解决线程安全问题，同时解决懒加载问题
    public static synchronized Singleton getInstance(){
        if(instance == null){
            synchronized(Singleton.class){//当第一个线程执行完对象实例化操作后
               if(instance == null) {//后面的线程来到这里时判断
                   instance = new Singleton();
               }
               //else 到下面返回 instance
            }
        }
        //而当再后面的线程来时在最上方的判断语句中就直接来到这里返回instance
        return instance;
    }
}

实现步骤
1）构造器私有化（防止 new）
2）类的内部声名静态对象
3）写一个静态内部类，该类中有一个静态属性外部类的静态常量
4）提供一个静态的公有方法，直接返回静态内部类常量属性

class Singleton{
    private static Singleton instance;

    private Singleton(){

    }

    //写一个静态内部类，该类中有一个静态属性 Singleton
    private static class SingletonInstance{
        private static final Singleton INSTANCE = new Singleton();
    }

    //提供一个静态的公有方法，直接返回 SingletonInstance.INSTANCE
    public static synchronized Singleton getInstance(){

        return SingletonInstance.INSTANCE;
    }
}

//使用枚举，可以实现单例，推荐
enum Singleton{
    INSTANCE;//属性
    public void sayOK(){
        System.out.println("ok~");
    }
}