构造方法私有化及单态设计模式

构造方法私有化，也就是，说构造方法是私有的。比如：

class Singleton{
    private Singleton(){}//构造方法进行了封装，私有化
    public void print (){
        System.out.println("Hello World!");
}
};
           

我们不能在外部实例化这个Singleton对象的类！比如:

public class SingletonDemo02{
    public static void main(String args[]){
    Singleton s1=null;//声明对象
    s1=new singleton();//错误，无法实例化对象
    }
}
           

如果我们想要在Singleton类的外部类中使用Singleton类对象的话，只能再Singleton类中实例化一个Singleton类的对象，并将实例化对象声明为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() ;        // 调用方法
    }
};
           

以上代码还不是最优的，属性最好被封装，所以instance最好被声明为private，然后通过静态方法来取得instance对象。

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

不管外部声明了多少个Singleton的对象，但是最终结果都是通过getInstance()方法取得的实例对象，也就是说，此时s1、s2、s3实际上都使用了一个对象的引用：instance

那么这样的设计在设计模式上来讲就属于单态（单例）设计模式。如果在开发中不希望一个类产生过多的对象的话，则必须使用单态设计模式。

所谓的单态就是在入口处（构造方法）限制了对象的实例化操作。