本章目标
- 了解后遭方法私有化的目的
- 掌握单态设计模式（单例设计模式）
1、具体内容
构造方法私有化
类的封装不光体下载对属性的封装上，实际上方法也是可以封装的，当然在方法封装中也包含了对构造方法的封装。例如：以下的代码，就是对构造方法进行了封装
class Singleton{
private Singleton(){ // 将构造方法进行了封装，私有化
}
public void print(){
System.out.println("Hello World!!!") ;
}
};
使用
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() ; // 错误，无法实例化对象
}
};
此时，被私有化构造方法的Singleton类，不能在外部直接实例化，既然在外部不可以使用，那么如果在内部呢？
class Singleton{
Singleton instance = new Singleton() ; // 在内部产生本类的实例化对象
private Singleton(){ // 将构造方法进行了封装，私有化
}
public void print(){
System.out.println("Hello World!!!") ;
}
};
public class SingletonDemo03{
public static void main(String args[]){
Singleton s1 = null ; // 声明对象
}
};
一个类的构造方法被私有化之后，则只能从其类的内部取得实例化对象，那么此时要考虑的问题就是如何把内部生成的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!!!
正常情况下，这些属性应该封装才对，所以以上的代码最好修改为以下的模式：
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() ; // 调用方法
}
};
运行结果：
Hello World!!!
构造私有化之后，就可以通过以上的形式取得实例化对象。
程序的意义？
- 以上的代码远不如直接实例化操作来的直接，为什么还要这样去做呢？
- 如果现在产生了本类的三个对象。
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() ; // 调用方法
}
};
运行结果：
Hello World!!!
Hello World!!!
Hello World!!!
不管外部声明了多少个Singleton的对象，但是最终结果都是通过getInstance()方法取得的实例化对象，也就是说，此时s1、s2、s3都是用了一个对象的引用：instance
那么这样的设计在设计模式上来讲，属于单态设计模式（单例设计模式）：Singleton。
如果现在不希望一个类产生过多的对象的话，则就必须时用单态设计模式，而且单态设计模式在一户的Java学习中会经常碰到，因为在Java的支持类库中，大量的采用了此种设计模式。
所谓的单态就是在入口处（构造方法）限制了对象的实例化操作。
这就是单态设计的应用点。
2、总结
单态设计模式的核心及时将类的构造方法私有化，之后在类的内部产生实例化对象，并通过类的静态方法返回实例化对象的引用。
