No11.构造方法私有化（单列设计模式）

知识点：

1.构造方法私有化的操作形式；

2.单例与多例设计模式

具体内容：

单例设计模式（Singleton）:

    在正常情况下，给了你一个类，那么只有通过产生对象之后才可以操作这个类。

范例：观察如下代码

package cn.mldn.po;
class Singleton{
	public void print(){
		System.out.println("Hello World!");
	}
}

public class Test {

	public static void main(String[] args) {
	  Singleton s = null;   //声明对象
	  s = new Singleton();  //实例化对象
	  s.print();
	}

}

     现在Singleton类里面存在有构造方法，如果没有明确定义一个构造的话，会自动的在编译时生成一个无参的构造方法什么都不做的构造方法。即：一个类至少保留有一个构造方法。

范例：修改Singleton类定义

package cn.mldn.po;
class Singleton{
	private Singleton(){    //构造方法私有化
		
	}
	public void print(){
		System.out.println("Hello World!");
	}
}

一旦构造方法实例化了之后狗，将无法通过关键字new来进行对象的实例化操作。

范例：错误的代码

public class Test {

	public static void main(String[] args) {
	  Singleton s = null;   //声明对象
	  s = new Singleton();  //实例化对象
	  s.print();
	}

}

  整个程序如何改造才可以让test类里面得到Singleton类的实体类。

分析步骤：

1.构造方法上使用了private声明（private Singleton(){}）,那么就表示这个构造方法只能被类的内部所使用，既然如此，可以在类的内部实例化一个对象；

2.现在的instacne在Singleton里面只是一个普通的类属性，而所有的普通类属性必须在类产生实例化对象之后才可以使用。，是否存在有一种方式，可以让这个属性不受Singleton实例化对象的控制呢？

   如果使用了static声明instance,那么就可以表示可以在一个类没有产生实例化对象的时候直接使用该属性。

  

package cn.mldn.po;
class Singleton{
	static Singleton instance = new Singleton();
	private Singleton(){    //构造方法私有化
		
	}
	public void print(){
		System.out.println("Hello World!");
	}
}

public class Test {

	public static void main(String[] args) {
	  Singleton s = null;   //声明对象
	  s = Singleton.instance;  //实例化对象
	  s.print();
	}

}

3.在定义一个类定义的时候应该想的就是类中属性需要进行封装：

private static Singleton instance = new Singleton();

4.而一旦封装之后想要访问属性只能通过getter方法，那么就需要提供一个getter方法可以同样不受Singleton实例化对象的控制，继续使用static属性。

package cn.mldn.po;
class Singleton{
	private static Singleton instance = new Singleton();
	private Singleton(){    //构造方法私有化
		
	}
	public static Singleton getInstanece(){
		return instance;
	}
	public void print(){
		System.out.println("Hello World!");
	}
}

public class Test {

	public static void main(String[] args) {
	  Singleton s = null;   //声明对象
	  s = Singleton.getInstanece();  //直接访问static
	  s.print();
	}

}

代码意义：

     如果说现在想要控制一个类实例化对象的产生个数，那么首先要锁定的就是类中的构造方法，因为在任何新对象都要使用构造方法，那么子凡无法产生新的实例化对象。

      可是既然需要是一个实例化对象，那么就可以在类的内部使用static方式来定义一个公共的对象，它会成为所有对象的公共对象，并且每一次通过static方法返回的唯一的一个对象，这样外部不管有多少次调用，那么最终一个类只能够产生唯一的一个对象，这样的设计就属于单利设计模式（Singleton）。

package cn.mldn.po;
class Singleton{
	private static final Singleton instance = new Singleton();
	private Singleton(){    //构造方法私有化
		
	}
	public static Singleton getInstanece(){
		return instance;
	}
	public void print(){
		System.out.println("Hello World!");
	}
}
public class Test {

	public static void main(String[] args) {
	  Singleton s = null;   //声明对象
	  s = Singleton.getInstanece();  //直接访问static
	  s.print();
	}

}

面试题：请编写一个单利设计模式（Singleton）程序，请解释Singleton程序的特点

程序如下：

package cn.mldn.po;
class Singleton{
	private static final Singleton instance = new Singleton();
	private Singleton(){    //构造方法私有化
		
	}
	public static Singleton getInstanece(){
		return instance;
	}
	public void print(){
		System.out.println("Hello World!");
	}
}
public class Test {

	public static void main(String[] args) {
	  Singleton s = null;   //声明对象
	  s = Singleton.getInstanece();  //直接访问static
	  s.print();
	}

}

程序的特点：构造方法私有化，在类的内部定义static属性与方法，利用static方法取得本类的实例化对象，那么这样一来不管外部会产生多少个Singleton类的对象，但是本质上永远只有为一的一个实例化对象。

    分类：饿汉式、懒汉式。

    在之前所编写的单例实际上属于恶寒时的应用，在Singleton类定义的时候就已经准备好了一个Singleton类的实例化对象instance，而并没有关心这个对象是否实用。

    而懒汉式的最大特点就在于它是在第一次实用的时候才进行实例化操作。

范例：实现懒汉式

class Singleton{
	private static Singleton instance ;
	private Singleton(){    //构造方法私有化
		
	}
	public static Singleton getInstanece(){
		if(instance==null){  //此时还没有实例化
			instance = new Singleton();  //实例化对象操作
		}
		return instance;
	}
	public void print(){
		System.out.println("Hello World!");
	}
}

核心目的：让一个类在整个系统里面只允许存在有一个实例化的对象。

多例设计模式（理解）：

   例如：现在要定义一个表示一周时间数的类，这个类只能够取七个对象；

   例如：现在要求定义一个表示性别的类，这个类只能取两个对象。

范例：定义一个表示性别的类

package cn.mldn.po;
class Sex{
	private String title;
	private static final Sex MALE = new Sex("男");
	private static final Sex FEMALE = new Sex("女");
	private Sex(String titel){ //构造私有化
		this.title = title;
	};
	public String toString(){  
		return this.title;
	}
	public static Sex getInstance(int ch){
		switch (ch) {
		case 1 : 
			return MALE;
		case 2 :
			return FEMALE;
		default :
			return null;
		}
		
	}
}
public class Test {

	public static void main(String[] args) {
	  Sex sex = Sex.getInstance(1);
	  System.out.println(sex);
	}

}

在JDK1.7之前，switch只能够利用int或者char,但是如果纯粹是数字或字符意义不明确，所以增加了String的支持。

package cn.mldn.po;
class Sex{
	private String title;
	private static final Sex MALE = new Sex("男");
	private static final Sex FEMALE = new Sex("女");
	private Sex(String titel){ //构造私有化
		this.title = title;
	};
	public String toString(){  
		return this.title;
	}
	public static Sex getInstance(String ch){
		switch (ch) {
		case "man" : 
			return MALE;
		case "woman" :
			return FEMALE;
		default :
			return null;
		}
		
	}
}
public class Test {

	public static void main(String[] args) {
	  Sex sex = Sex.getInstance("man");
	  System.out.println(sex);
	}

}

如果还是不希望实用String在switch语句（这个习惯实际上不好）上实用，那么可以再引入一个标记的接口。

package cn.mldn.po;
class Sex{
	private String title;
	private static final Sex MALE = new Sex("男");
	private static final Sex FEMALE = new Sex("女");
	private Sex(String titel){ //构造私有化
		this.title = title;
	};
	public String toString(){  
		return this.title;
	}
	public static Sex getInstance(int ch){
		switch (ch) {
		case 1 : 
			return MALE;
		case 2 :
			return FEMALE;
		default :
			return null;
		}
		
	}
}
interface Choose{
	public int MAN = 1;
	public int WQMAN = 2;
}

public class Test {

	public static void main(String[] args) {
	  Sex sex = Sex.getInstance(Choose.MAN);
	  System.out.println(sex);
	}

}

以上代码自己看没问题，但是其他人难看！

总结：

1.单例设计模式就是一个类只能产生唯一的一个实例化对象；

2.多例设计模式可以产生多个对象，要取得的时候需要加上标记。

单例和多例核心就是构造方法私有化。