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

一，构造方法私有化：

即对构造方法加上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）返回实例化对象的引用。