单例设计模式&多例设计模式：

单例设计模式&多例设计模式：

一、单例设计模式：

1、定义：
所谓的单例设计指的是一个类只允许产生一个实例化对象。

2、单例设计模式的分类：

▼——饿汉式单例——上来就new：

• 构造私有化（private）：限制实例化对象的产生个数为1个；
• 类的内部提供一个静态对象（static关键字）；
• 提供静态方法返回唯一对象；

▼——懒汉式单例——用时再new：

• 构造私有化（private）：限制实例化对象的产生个数为1个；
• 类的内部提供一个静态对象（static关键字）；
• 提供静态方法返回唯一对象；

[注意]：
单例模式中，饿汉式单例与懒汉式单例的区别是什么？

• 饿汉式单例与懒汉式单例在组成上都是一样的，唯一的区别就是实例化对象的时机不同；
• 饿汉式单例是上来就new，而懒汉式单例是使用时才new。

3、单例设计模式详解——饿汉式单例：

class Singleton{
    /**
     * 使用private声明构造方法：
     *      表示外部无法调用构造方法，也就是说，外部不能产生新的实例化对象。
     * 如果依旧想要在调用Singleton类的print()方法，就必须提供实例化对
     * 象，考虑到封装（private、default、protect）的特点，就只能在类的
     * 内部产生一个实例化的对象了。
     *      对象instance是一个普通的属性，而所有的普通属性必须在实例化对象
     * 的时候才能进行内存空间的分配，而外部现在又无法产生实例化对象，这个时
     * 候就需要用到static关键字修饰该实例化的对象。
     */
    //对于类中的属性应该使用private进行封装，而取得，就需要提供getter()方法
    private final static Singleton instance = new Singleton();//实例化对象
    private Singleton(){
    }
    //取得静态属性，提供一个静态方法getInstance()方法：
    public static Singleton getInstance(){
        return instance;
    }
    public void print(){
        System.out.println("hello world");
    }
}
public class test1 {
    public static void main(String[] args) {
        Singleton singleton = null;//声明对象
        singleton = Singleton.getInstance();
        singleton.print();
    }
}

[注意]：
在上面的代码中可以发现，不管你是否使用了Singleton类的对象，只要该类加载了，就会创建一个公共的instance对象。

4、单例设计模式详解——懒汉式单例：

class Singleton{
    private static Singleton instance;
    //private的构造方法，为了只产生一个Singleton类对象：
    private Singleton(){
    }
    public static Singleton getInstance(){
        //用时才new对象：
        if(instance == null){
            instance = new Singleton();
        }
        return instance;
    }
    public void print(){
        System.out.println("hello world");
    }
}
public class test1{
    public static void main(String[] args) {
        Singleton singleton = null;//声明对象
        singleton = Singleton.getInstance();
        singleton.print();
    }
}

5、两种单例模式总结：
懒汉式单例存在多线程安全的问题，而饿汉式不存在这种问题，因此在以后的应用中，介意使用饿汉式单例。

二、多例设计模式：

1、定义：
多例就是单例追加多个内部实例化对象的产生。
[注意]：
多例设计模式正在逐渐被枚举锁替代。

2、特点：
构造方法私有化；
类内部一定会提供一个static方法用于取得实例化对象；

3、多例模式详解：

class Data{
    private String tmp;
    public static final String YEAR_TMP = "年";
    public static final String MONTH_TMP = "月";
    public static final String DATE_TMP = "日";
    //三个实例化对象：
    private static final Data year = new Data(YEAR_TMP);
    private static final Data month = new Data(MONTH_TMP);
    private static final Data date = new Data(DATE_TMP);
    //构造方法私有化：
    private Data(String tmp){
        this.tmp = tmp;
    }
    //覆写toString()方法：
    public String toString(){
        return this.tmp;
    }
    //提供静态方法取得对象：
    public static Data getInstance(String del){
         switch(del){
             case YEAR_TMP:
                 return year;
             case MONTH_TMP:
                 return month;
             case DATE_TMP:
                 return date;
             default:
                 return null;
         }
    }
}
public class test2{
    public static void main(String[] args) {
        Data year = Data.getInstance(Data.YEAR_TMP);
        System.out.println(year);
        Data month = Data.getInstance(Data.MONTH_TMP);
        System.out.println(month);
        Data date = Data.getInstance(Data.DATE_TMP);
        System.out.println(date);
    }
}

——运行结果如下：