单例模式

原文链接一，构造方法私有化：
即对构造方法加上private关键词。

如：

class Singleton{
private Singleton(){ // 将构造方法进行了封装，私有化
}
};
但是由于私有化的方法和属性只能在本类中看到和访问，其他方法中是看不到的！

所以对于以下做法。

按 Ctrl+C 复制代码

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() ; // 错误，无法实例化对象
}
};
按 Ctrl+C 复制代码
运行结果：

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）返回实例化对象的引用。