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

Posted 2020-07-10 美好的明天

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() ;        // 调用方法
    }
};