构造方法私有化--単例设计模式

面向对象的封装特性，最简单的是提现在对类的属性的封装，其实，类的方法也是可以进行封装的，构造方法，私有化，就是对构造方法的封装。

构造方法私有化，就不能直接在类的外面通过new 类名称();来实例化对象了，这样使用起来似乎不那么方便了，那么问题来了：

1，为何要私有化构造方法呢?

2，私有化了构造方法，就可以说采用了単例设计模式，那么，采用単例设计模式有什么优点?提供了什么方便?和没有使用単例模式相比有什么优势?就是说为什么要使用単例设计模式呢?

3，什么时候使用，単例设计模式呢?

class Singleton{

private Singleton(){ // 将构造方法进行了封装，私有化

}

public void print(){

System.out.println("Hello World!!!") ;

}

};

问题：

这样的代码，这个print方法，似乎永远无法被调用呢，因为实例化对象就会出问题，怎么实例化这个类的对象呢。。。。。

解决方案：

构造方法私有化了，不能再外面直接实例化对象了，那怎么办呢，那么在内部实例化咯，在类的内部实例化构造方法私有化的这个类的对象，从语法权限上来说，必然不会出问题。

问题：

在内部产生实例化对象，然后再传到外部，似乎有点绕。而且问题来了，如何把这个类内部产生的对象拿到外面呢?。。。。话不多说，上代码：

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

}

};

以上代码实现了，私有化类内部创建对象，然后通过static修饰，拿到了外面，但是，这个属性并没有封装，不是很完美，可以进行优化：

优化

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,都使用了一个对象的引用，这些stack内存的引用都指向了一个heap内存。

分析：

开篇的问题

1，为何要将类的构造方法私有化呢?

当然是为了使用単例设计模式，

那么，什么是単例设计模式呢?这里了，就必须清楚的描述出来了：在程序的入口处(构造方法)限制了对象的实例化操作。构造方法私有化，在类的内部创建对象，然后通过static修饰然后封装这个对象，拿到外面使用，从而达到这个类从始至终只产生一个对象的目的的设计思路，就是単例设计。

2，使用単例有什么优点?

只产生一个对象实例，再多的对象也只是引用这一个对象实例，

3，什么时候使用単例?

当一个类只想创建一个对象实例的需求时候，当所有的对象都只有一个对象实例的引用的时候，就使用単例设计模式。

总结：

使用场景：

当要限制类的对象的产生的时候，就可以使用単例设计模式，

単例设计模式的核心就是：

将构造方法私有化，之后在类的内部产生实例化对象，并通过静态方法取得此实例化对象。