1. 单例设计模式(Singleton)
在正常情况下，如果有一个类，那么只有通过产生对象之后才可以操作这个类
范例：观察如下代码
class Singleton {
public void print() {
System.out.println("Hello world!");
}
}
public class SingletonDemo {
public static void main(String[] args) {
Singleton s = null; //声明对象
s = new Singleton(); //实例化对象
s.print();
}
}
现在Singleton类里面存在有构造方法，如果没有明确定义一个构造的话，会自动在编译的时候生成一个无参的，什么都不做的构造方法，即：一个类至少会保留一个构造方法。
范例：修改Singleton类的构造方法
class Singleton {
private Singleton(){} //构造方法私有化
public void print() {
System.out.println("Hello world!");
}
}
一旦构造方法私有化，外部将无法直接通过关键字new来进行对象的实例化操作。
范例：错误的代码
public static void main(String[] args) {
Singleton s = null; //声明对象
//错误代码
s = new Singleton(); //实例化对象
s.print();
}
如果修改代码才能够得到Singleton类的实例化对象，并且调用到print()方法？
分析步骤：
- 构造方法上使用了private声明
private Singleton(){}，那么就表示这个构造方法只能够被类的内部所使用；既然如此，可以直接在类的内部实例化一个对象：
class Singleton {
//直接在类内部实例化对象
Singleton instance = new Singleton();
private Singleton(){} //构造方法私有化
public void print() {
System.out.println("Hello world!");
}
}
- 现在的instance在Singleton里面只是一个普通的类属性，而所有的普通类属性必须在类产生实例化之后才可以使用，是否存在一种方式，可是让这个类属性不受Singleton类实例化对象的控制呢？
如果使用static声明instance属性，就可以表示在一个类没有产生实例化对象的时候直接使用属性。
class Singleton {
//直接在类内部实例化对象，用static声明
static Singleton instance = new Singleton();
private Singleton(){} //构造方法私有化
public void print() {
System.out.println("Hello world!");
}
}
public class SingletonDemo {
public static void main(String[] args) {
Singleton s = null; //声明对象
s = Singleton.instance; //直接访问static属性
s.print();
}
}
- 在一个类定义的时候应该对属性进行封装
private static Singleton instance = new Singleton();
- 一旦封装之后如果想要访问此属性只能通过getter()方法，那么就需要提供一个getter()方法，而且同样要不受到Singleton实例化对象的控制，所以继续使用static属性
class Singleton {
//直接在类内部实例化对象，用static声明
private static Singleton instance = new Singleton();
private Singleton(){} //构造方法私有化
public static Singleton getInstance() {
return instance;
}
public void print() {
System.out.println("Hello world!");
}
}
代码意义：
如果要想控制一个类中实例化对象的产生个数，那么首先要锁定类中的构造方法，因为在实例化任何新对象都要使用构造方法，如果构造方法被锁了，那么就无法产生新的实例化对象了。
既然需要是一个实例化对象，那么就可以在类的内部使用static方法来定义一个公共的对象，并且通过static方法返回唯一的对象，这样外部不管有多少次调用，对只会产生唯一的对象，这样的设计就属于单例设计模式(Singleton)。
面试题：编写Singleton程序，并解释Singleton程序的特点。
class Singleton {
//直接在类内部实例化对象，用static声明
private static final Singleton INSTANCE = new Singleton();
private Singleton(){} //构造方法私有化
public static Singleton getInstance() {
return INSTANCE;
}
public void print() {
System.out.println("Hello world!");
}
}
public class SingletonDemo {
public static void main(String[] args) {
Singleton s = null; //声明对象
s = Singleton.getInstance(); //直接访问static属性
s.print();
}
}
程序特点：构造方法私有化，在类的内部定义static属性方法，利用static方法取得本类的实例化对象，这样不管外部会产生多少个Singleton类的对象，但实际上只产生唯一的对象。
单例设计模式有两种形式：饿汉式、懒汉式饿汉式：上面编写的代码就是饿汉式的应用，在Singleton类定义的时候就已经准备好了一个Singleton类的实例化对象INSTANCE，而并没有关心这个对象是否使用。
懒汉式：最大的特点就在于它是在第一次使用的时候才进行实例化操作
范例：实现懒汉式
class SingletonLazy{
private static Singleton instance;
private static SingeletonLazy(){}
public static SingletonLazy getInstance() {
if (instance == null) { //此时还没有实例化
instance = new SingeletonLazy(); //实例化对象
}
return instance;
}
public void print(){
System.out.println("Hello world!");
}
}
2. 多例设计模式
多例设计模式，可以让一个类产生指定多个个数的实例化对象。
例如：
- 定义一个表示一周天数的类，这个类智能取七个对象；
- 定义一个表示性别的类，这个类智能取两个对象
范例：定义一个表示性别的类
class Sex {
private String title;
private static final Sex MALE = new Sex("男");
private static final Sex WOMALE = new Sex("女");
private Sex(String title) { //构造方法私有化
this.title = title;
}
public String toString() {
return this.title;
}
public static Sex getInstance(int ch){
switch (ch) {
case 1:
return MALE;
case 2:
return WOMALE;
default:
return null;
}
}
}
public class MultionDemo {
public static void main(String[] args) {
Sex sex = Sex.getInstance(2);
System.out.println(sex);
}
}
3. 总结
- 单例设计模式就是一个类只能产生唯一的实例化对象；
- 多例设计模式可以产生多个对象，要取得的时候需要加上标记，
单例和多例设计的核心：构造方法私有化
