原博文请参考:https://www.cnblogs.com/alsf/p/5517504.html
一,构造方法私有化:
即对构造方法加上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)返回实例化对象的引用。
五,单例模式实现方式
饿汉式:
public class SingletonDemo {
private static SingletonDemo instance=new SingletonDemo();
private SingletonDemo(){
}
public static SingletonDemo getInstance(){
return instance;
}
}
懒汉式:
public class SingletonDemo {
private static SingletonDemo instance;
private SingletonDemo(){
}
public static SingletonDemo getInstance(){
if(instance==null){
instance=new SingletonDemo();
}
return instance;
}
}