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

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

单例设计

  1. 此时有一Java类:Singleton,由于某些要求,该类只允许提供一个实例化对象,即所谓的单例。
class Singleton{
    public void print(){
        System.out.println("你好");
    }
}
  1. 首先应该控制的就是构造方法,因为所有的新的实例产生,一定会调用构造方法,如果将构造方法私有化就无法产生实例化对象了(此时在外部new该类时就会报错)
class Singleton {
    //构造方法私有化
    private Singleton() {

    }
    public void print() {
        System.out.println("你好");
    }
}
  1. 单例要求有一个实例化对象,但是现在构造方法已经私有化了,而private访问权限的主要特点在于:不能在类外部访问,但是可以在类本身访问,所以现在可以考虑在类内部调用构造方法
class Singleton {
    Singleton instance = new Singleton();
    //构造方法私有化
    private Singleton() {

    }
    public void print() {
        System.out.println("你好");
    }
}
  1. 此时Singleton类内部的instance属于一个普通属性,而普通属性是在有实例化对象产生之后才会被调用的,但是此时外部无法产生实例化对象,所以这个属性就不能够访问到了,就必须考虑如何在没有实例化对象的时候获取此属性,那么只有static属性可以成功
class Singleton {
    static Singleton instance = new Singleton();
    //构造方法私有化
    private Singleton() {

    }
    public void print() {
        System.out.println("你好");
    }
}
  1. 类中的属性应该封装后使用,所以理论上此时的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("你好");
    }
}
  1. 整个代码强调的是只有一个实例化对象,这个时候虽然提供有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();

为什么要使用单例设计模式?
在很多情况下有些类是不需要重复产生对象的,例如:如果一个程序启动,那么肯定需要有一个类负责保存有一些程序加载的数据信息(没必要产生多个实例化)coding-Java设计模式之单例设计、多例设计-
懒汉式、饿汉式
单例设计模式也分为两种:懒汉式、饿汉式。
在刚刚所定义的单例模式就属于饿汉式——在系统加载类的时候就会自动提供有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方法以返回实例化对象,单例设计使用情况一般会比多例设计频繁。

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

匿名

发表评论

匿名网友