设计模式简单介绍

什么是设计模式

设计模式数组针对软件发开发中经常遇到的一些设计问题，根据基本的设计原则，总结出来的一套使用的解决方案或者设计思路。

经典的设计模式有23种：

1. 创建型模式：工厂方法模式，抽象工厂模式，单例模式，建造者模式，原型模式。
2. 结构型模式：适配器模式，装饰者模式，代理模式，门面模式，桥接模式，组合模式，享元模式。
3. 行为型模式：策略模式，模板方法模式，观察者模式，迭代子模式，责任链模式，命令模式，备忘录模式，状态模式，访问者模式，中介者模式，解释器模式。

单例模式

注意：

• 单例类只能有一个实例。
• 单例类必须自己创建自己的唯一实例。
• 单例类必须给其他对象提供自己的唯一实例。

单例模式的实现

单例类的构造必须是私有的，这样就防止了调用构造方法创建实例。

public class Singleton {
private Singleton() {

  }
}

单例模式的实现方式：

饿汉模式：在类加载的时候立即初始化，并且创建单例对象，不管有没有用到单例对象，先创建好再说，它是线程安全的，因为在线程还没有出现之前就创建好了，缺点是浪费内存。

public class Hungry_Singleleton {
    //实现饿汉模式
    private static final Hungry_Singleleton SINGLELETON = new Hungry_Singleleton();
    private Hungry_Singleleton(){

    }
    public static Hungry_Singleleton getInstance(){
        return SINGLELETON;
    }
}

public class Hungry_Singleleton2 {
    //静态代码块实现单例模式
    private static Hungry_Singleleton2 instance;
   static {
       instance = new Hungry_Singleleton2();
   }
    private Hungry_Singleleton2(){

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

懒汉模式：在用的时候再去创建单例对象，用的时候先检查有没有单例对象，有的话直接返回，没有就新建。下面这种写法，有一定概率会生成不同的对象，意味着这种写法不是线程安全的，当线程A和线程B同时出现时，线程A和线程B同时走到“if(lazy == null)”这个判断，因为lazy还没有没实例化过，所以两个线程判断的结果都是true，然后同时进入 if 代码块执行 new 操作，这时，线程A创建了一个实例，线程B也创建了一个实例，最后 return 的 lazy 肯定不是同一个对象，所以，这种写法是线程不安全的。可以通过加锁的方式解决这个问题。 

public class Lazy_SingleLeton {
    //懒汉模式实现单例类
    private static Lazy_SingleLeton LAZY_SINGLE_LETON = null;
    private Lazy_SingleLeton(){

    }
    public static Lazy_SingleLeton getInstance(){
        if(LAZY_SINGLE_LETON == null){
            LAZY_SINGLE_LETON = new Lazy_SingleLeton();
        }
        return LAZY_SINGLE_LETON;
    }
}

静态内部类：

 

public class Singleton2 {
private Singleton2() {}
public static Singleton2 getInstance() {
return Singleton2Inner.INSTANCE;
}
// 内部类可以访问外部类的所有东西（方法和属性） 包括private修饰的
static class Singleton2Inner {
private static Singleton2 INSTANCE = new Singleton2();
}
}

用枚举实现：定义一个只有一个枚举的类

public enum Singleton {
    INSTANCE();
}