教你借助设计模式限制实例化数量 | 带你学《Java面向对象编程》之七十三

上一篇:带你领略类图以外的世界 | 带你学《Java面向对象编程》之七十二
【本节目标】
通过阅读本节内容,你将进一步利用所学知识来一步步实现某些开发要求,了解到单例模式与多例模式的实现原理与作用。

单例设计模式(多例设计模式)主要是一种控制实例化对象产生个数的设计操作。

单例设计

如果说有一个程序类,假设该程序类的定义如下:

class Singleton {
    public void print() {
        System.out.println("www.mldn.cn") ;
    }
}
public class JavaDemo{
    public static void main(String args[]) {
        Singleton instanceA = new Singleton() ;
        Singleton instanceB = new Singleton() ;
        Singleton instanceC = new Singleton() ;
        instanceA.print() ;
        instanceB.print() ; 
        instanceC.print() ; 
    }
}

但是由于某些要求,现在要求Singleton这个类只允许提供有一个实例化对象。那么此时首先控制构造方法因为所有的新的实例华对象产生了,那么一定要调用我们的构造方法,如果“没有”构造方法,那么就自然无法产生实例化对象了。
范例:构造方法私有化

class Singleton {
    private Singleton() {}    //构造方法私有化
    public void print() {
        System.out.println("www.mldn.cn") ;
    }
}
public class JavaDemo{
    public static void main(String args[]) {
        Singleton  instance = null ;    //声明对象
        instance = new Singleton() ;   //错误:Singleton()可以在Singleton中访问private
    }
}

但是现在是有严格要求的:必须产生有一个实例化对象。所以现在需要考虑去产生一个实例化对象交给客户端去调用。那么这个时候的分析如下:
1、private访问权限的主要特点在于:不能在类外部访问,但是可以在类本身调用,所以现在可以考虑在类的内部调用构造;

class Singleton {
    private Singleton instance = new Singleton() ;
    private Singleton() {}    //构造方法私有化
    public void print() {
        System.out.println("www.mldn.cn") ;
    }
}
public class JavaDemo{
       public static void main(String args[]) {
            Singleton  instance = null ;    //声明对象
            //instance = new Singleton() ;   //错误:Singleton()可以在Singleton中访问private
       }
}

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

class Singleton {
    static Singleton instance = new Singleton() ;
    private Singleton() {}    //构造方法私有化
    public void print() {
        System.out.println("www.mldn.cn") ;
    }
}
public class JavaDemo{
       public static void main(String args[]) {
            Singleton  instance = null ;    //声明对象
            instance = Singleton.instance ;   
            instance.print() ;   //www.mldn.cn
       }
}

3、类中的属性应该封装后使用,所以理论上此时的instance需要被封装起来,那么就需要通过static方法获得。

class Singleton {
    private static Singleton instance = new Singleton() ;
    private Singleton() {}    //构造方法私有化
    public static Singleton getInstance() {
          return instance ;
    }
    public void print() {
        System.out.println("www.mldn.cn") ;
    }
}
public class JavaDemo{
       public static void main(String args[]) {
            Singleton  instance = null ;    //声明对象
           instance = Singleton.getInstance() ;   
            instance.print() ;       //www.mldn.cn

       }
}

4、整个代码从头强调的是只有一个实例化对象,但是这个对象依然可以被重新使用。所以需要保证此时Singleton类内部的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("www.mldn.cn") ;
    }
}
public class JavaDemo{
       public static void main(String args[]) {
            Singleton  instance = null ;    //声明对象
           instance = Singleton.getInstance() ;   
            instance.print() ;       //www.mldn.cn

       }
}

在很多情况下有些类是不需要重复产生对象的,例如:如果一个程序启动,那么现在肯定需要有一个类负责保存有一些程序加载的数据信息。

教你借助设计模式限制实例化数量   | 带你学《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("www.mldn.cn") ;
    }
}
public class JavaDemo{
       public static void main(String args[]) {
            Singleton  instance = null ;    //声明对象
           instance = Singleton.getInstance() ;   
            instance.print() ;       //www.mldn.cn
       }
}

面试题:请编写一个Singleton程序,并说明其主要特点?

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

多例设计

与单例设计对应的还有一个多例设计,单例设计指的是只保留有一个实例化对象,而多例设计指的是可以保留有多个实例化对象。例如:如果现在定义一个描述性别的类。那么该对象只有两个:男、女。或者描述颜色基色的类,可以使用红色、绿色、蓝色。这种情况下就可以使用多例设计来解决。
范例:实现多例设计

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) {     //构造方法私有化
         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 ;
    } 
}
public class JavaDemo{
   public static void main(String args[]) {
       Color c =Color.getInstance("green") ;
       System.out.println(c) ;
   }      //绿色
}

多例设计与单例设计的本质是相同的,一定都会在内部提供有static方法以返回实例化对象。

想学习更多的Java的课程吗?从小白到大神,从入门到精通,更多精彩不容错过!免费为您提供更多的学习资源。
本内容视频来源于阿里云大学

下一篇:迅速了解多例模式竞争者-枚举 | 带你学《Java面向对象编程》之七十四
更多Java面向对象编程文章查看此处

上一篇:Spring MVC 之文件上传(七)


下一篇:高效研发运维体系构建的流程和方法论