构造方法私有化和单例模式

Posted 美好的明天

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了构造方法私有化和单例模式相关的知识,希望对你有一定的参考价值。

一,构造方法私有化:

即对构造方法加上private关键词。

如:

class Singleton{
    private Singleton(){        // 将构造方法进行了封装,私有化    
    }
};

但是由于私有化的方法和属性只能在本类中看到和访问,其他方法中是看不到的!

所以对于以下做法。

class Singleton{
    private Singleton(){        // 将构造方法进行了封装,私有化    
    }
    public void print(){
        System.out.println("Hello World!!!") ;
    }
};
public class SingletonDemo02{
    public static void main(String args[]){
        Singleton s1 = null ;    // 声明对象
        s1 = new Singleton() ;    // 错误,无法实例化对象
    }
};

运行结果:

Exception in thread "main" java.lang.Error: Unresolved compilation problem: 
    The constructor Singleton() is not visible
    at methoud.ThisDemo06.main(ThisDemo06.java:13)

会出现错误,无法实例化对象。私有化的构造方法在其他类中是不可见的。

被构造方法私有化的Singleton类,不能在外部实例化。

既然不能在外部实例化,如果在类的内部实例化呢

class Singleton{
    Singleton instance = new Singleton() ;    // 在内部产生本类的实例化对象
    private Singleton(){        // 将构造方法进行了封装,私有化    
    }
    public void print(){
        System.out.println("Hello World!!!") ;
    }
};
public class SingletonDemo04{
    public static void main(String args[]){
        Singleton s1 = null ;    // 声明对象
    }
};

但是这里虽然在内部产生了实例化对象,却没有在外部使用,赋给s1.怎么办?

一个类的构造方法私有化之后,只能从类的内部取得实例化对象。那么,要考虑的问题是如何把内部生成的

instance 对象拿到外部来,这样外部就可以直接实例化了。

正常情况下,instance属性只能通过singleton类的实例化对象才可以进行调用。

如果没有实例化对象的时候依然可以取得instance对象,则就需要将instance声明成static访问类型,因为使用static

声明的变量,可以直接使用类名称进行访问。

 

class Singleton{
    static Singleton instance = new Singleton() ;    // 在内部产生本类的实例化对象
    private Singleton(){        // 将构造方法进行了封装,私有化    
    }
    public void print(){
        System.out.println("Hello World!!!") ;
    }
};
public class SingletonDemo04{
    public static void main(String args[]){
        Singleton s1 = null ;    // 声明对象
        s1 = Singleton.instance ;    // 通过类取得实例化对象
        s1.print() ;        // 调用方法
    }
};
运行结果:hello world!!!

 

这样就通过声明static,把内部产生的对象,通过类名调用,取出到外部,赋给s1。

正常情况下,这些属性应该封装才对,所以,以上代码最好修改成以下形式。

class Singleton{
    private static Singleton instance = new Singleton() ;    // 在内部产生本类的实例化对象
    public static Singleton getInstance(){        // 通过静态方法取得instance对象
        return instance ;
    }
   private Singleton(){        // 将构造方法进行了封装,私有化    
    }
    public void print(){
        System.out.println("Hello World!!!") ;
    }
};
public class SingletonDemo05{
    public static void main(String args[]){
        Singleton s1 = null ;    // 声明对象
        s1 = Singleton.getInstance() ;    // 取得实例化对象
        s1.print() ;        // 调用方法
    }
};

二,程序的意义:

为什么要这样做呢?

如果现在产生了三个对象。

class Singleton{
    private static Singleton instance = new Singleton() ;    // 在内部产生本类的实例化对象
    public static Singleton getInstance(){        // 通过静态方法取得instance对象
        return instance ;
    }
    private Singleton(){        // 将构造方法进行了封装,私有化    
    }
    public void print(){
        System.out.println("Hello World!!!") ;
    }
};
public class SingletonDemo05{
    public static void main(String args[]){
        Singleton s1 = null ;    // 声明对象
        Singleton s2 = null ;    // 声明对象
        Singleton s3 = null ;    // 声明对象
        s1 = Singleton.getInstance() ;    // 取得实例化对象
        s2 = Singleton.getInstance() ;    // 取得实例化对象
        s3 = Singleton.getInstance() ;    // 取得实例化对象
        s1.print() ;        // 调用方法
        s2.print() ;        // 调用方法
        s3.print() ;        // 调用方法
    }
};

不管外部声明了多少个对象,但是最终结果都是通过getInstance()方法取得的实例化对象。也就是说,

此时s1,s2,s3实际上都使用了一个对象的引用:instance。

那么在设计模式上,称为单例设计模式:singleton。

如果现在不希望一个类产生过多的对象的话,则必须采用单例设计模式,而且,在以后的java学习中,

在支持java的类库中,大量采用了这种模式。

所谓的单态就是在入口处(也就是构造方法)限制了实例化操作。

三,一个现实中的例子:

在window中有一个回收站,除了桌面有回收站,每个硬盘都有回收站,实际上每个硬盘上的回收站和桌面的回收站是同一个,

也就是说,整个操作系统只有一个回收站实例,各个地方只是引用这个实例而已。

四,总结

单例设计模式核心就是将类的构造方法私有化,之后在类的内部产生实例化对象,并通过类名引用类的静态方法(static)返回实例化对象的引用。

 

以上是关于构造方法私有化和单例模式的主要内容,如果未能解决你的问题,请参考以下文章

单例模式

1-单例模式

单例设计模式

单例模式

单例模式

62单例模式