Java设计模式之单例设计、多例设计

单例设计模式、多例设计模式都是用来控制类实例化对象产生个数的设计操作

单例设计

1. 此时有一Java类：Singleton，由于某些要求，该类只允许提供一个实例化对象，即所谓的单例。

class Singleton{
    public void print(){
        System.out.println("你好");
    }
}

2. 首先应该控制的就是构造方法，因为所有的新的实例产生，一定会调用构造方法，如果将构造方法私有化就无法产生实例化对象了（此时在外部new该类时就会报错）

class Singleton {
    //构造方法私有化
    private Singleton() {

    }
    public void print() {
        System.out.println("你好");
    }
}

3. 单例要求有一个实例化对象，但是现在构造方法已经私有化了，而private访问权限的主要特点在于：不能在类外部访问，但是可以在类本身访问，所以现在可以考虑在类内部调用构造方法

class Singleton {
    Singleton instance = new Singleton();
    //构造方法私有化
    private Singleton() {

    }
    public void print() {
        System.out.println("你好");
    }
}

4. 此时Singleton类内部的instance属于一个普通属性，而普通属性是在有实例化对象产生之后才会被调用的，但是此时外部无法产生实例化对象，所以这个属性就不能够访问到了，就必须考虑如何在没有实例化对象的时候获取此属性，那么只有static属性可以成功

class Singleton {
    static Singleton instance = new Singleton();
    //构造方法私有化
    private Singleton() {

    }
    public void print() {
        System.out.println("你好");
    }
}

5. 类中的属性应该封装后使用，所以理论上此时的instance需要被封装，那么就需要通过一个static的get方法获得

class Singleton{
    private static Singleton instance = new Singleton();
    private Singleton(){} //构造方法私有化

    public static Singleton getInstance(){
        return instance;
    }
    public void print(){
        System.out.println("你好");
    }
}

6. 整个代码强调的是只有一个实例化对象，这个时候虽然提供有static实例化对象，但是这个对象依然可以在getInstance（）方法中被重新实例化

class Singleton{
    private static Singleton instance = new Singleton();
    private Singleton(){} //构造方法私有化
    public static Singleton getInstance(){
        instance = new Singleton();
        return instance;
    }
    public void print(){
        System.out.println("你好");
    }
}

7.所以需要对instance属性使用final关键字

class Singleton{
    private static final Singleton INSTANCE = new Singleton();
    private Singleton(){} //构造方法私有化

    public static Singleton getInstance(){
        return INSTANCE;
    }
    public void print(){
        System.out.println("你好");
    }
}

外部获取该实例直接调用

Singleton singleton = Singleton.getInstance();

为什么要使用单例设计模式？
在很多情况下有些类是不需要重复产生对象的，例如：如果一个程序启动，那么肯定需要有一个类负责保存有一些程序加载的数据信息（没必要产生多个实例化）
懒汉式、饿汉式
单例设计模式也分为两种：懒汉式、饿汉式。
在刚刚所定义的单例模式就属于饿汉式——在系统加载类的时候就会自动提供有Singleton类的实例化对象；
而懒汉式：在第一次使用的时候进行实例化对象处理。（系统加载类时懒得加载）
将单例修改为懒汉式：

class Singleton {
    private static Singleton instance;
    //构造方法私有化
    private Singleton() {} 
    public static Singleton getInstance() {
        if (instance == null) { //第一次使用
            instance = new Singleton(); //实例化对象
        }
        return instance;
    }
    public void print() {
        System.out.println("你好");
    }
}

面试题：请编写一个Singleton（单例）程序，并说明其主要特点？

• 代码如上，可以把懒汉式（后面考虑到线程同步问题）和饿汉式都写上；
• 特点：构造方法私有化，类内部提供static方法获取实例化对象，这样不管外部如何操作永远都只有一个实例化对象

多例设计模式

单例设计指的是只保留有一个实例化对象，而多例化设计可以保留有多个实例化对象
例如：如果现在要定义一个描述性别的类，那么该对象只有两个：男、女；或者描述颜色基色的类：红色、绿色、蓝色。这种情况下就可以利用多例设计实现：

public class demo2 {
    public static void main(String[] args) {
        Color c = Color.getInstance("green");
        System.out.println(c.toString());
    }
}
class Color{//定义描述颜色的类
    private static final Color RED =new Color("红色");
    private static final Color GREEN =new Color("绿色");
    private static final Color BLUE =new Color("蓝色");
    private String title;
    private Color(String title){  //构造方法私有化，这里不只是private,也可以是protected
        this.title=title;
    }
    public static Color getInstance(String color){
        switch (color){
            case "red" : return RED;
            case "green":return GREEN;
            case "blue":return BLUE;
            default:return null;
        }
    }
    public String toString(){
        return this.title;
    }
}

多例设计与单例设计的本质是相同的，一定都会在内部提供有static方法以返回实例化对象，单例设计使用情况一般会比多例设计频繁。

以上内容整理自阿里云大学