文章目录
1.单例设计模式（Singleton）
（1）构造方法私有化的问题：
构造方法一旦私有化，则在外部无法通过new来进行对象的实例化。
第一步思考：
既然构造方法被私有化，那么就说明这个类的构造方法只能被本类所调用，即只能在本来中产生本类实例化对象。
class Singleton{
Singleton instance = new Singleton();
private Singleton(){
}
public void print(){
System.out.println("Hello World!");
}
}
第二步思考：
对于一个类中的普通属性，默认情况下一定要在本类存在实例化对象后才可以进行调用，可是本程序在Singleton类的外部无法产生实例化对象，就必须想办法让Singleton类中的instance属性可以在没有Singleton类实例化对象时来进行调用。
因此可以使用static完成（由类名称直接调用，并且在没有实例化对象时也可以调用）关于static可以看这里
class Singleton{
static Singleton instance = new Singleton();
private Singleton(){
}
public void print(){
System.out.println("Hello World!");
}
}
public class TestSingleton {
public static void main(String[] args) {
Singleton s = Singleton.instance ;
s.print();
}
}
第三步思考：
类中的属性必须全部封装，而一旦封装之后如果想要访问此属性，则需要通过getter方法。（还是使用static属性）
class Singleton{
private static Singleton instance = new Singleton();
private Singleton(){
}
public void print(){
System.out.println("Hello World!");
}
public static Singleton getInstance(){
return instance;
}
}
public class TestSingleton {
public static void main(String[] args) {
Singleton s = Singleton.getInstance() ;
s.print();
}
}
第四步思考：
上面程序中的instance属性属于static，就表示所有Singleton类的对象不管有多少个对象声明，其本质都只会共同拥有同一个instance属性引用。意义何在？
如果要控制一个类中实例化对象的产生个数，首先要锁定的就是类中的构造方法（使用private定义构造），因为在实例化任何新对象时都要使用到构造方法，如果把构造方法锁起来，就自然无法产生新的实例化对象了。
构造方法私有化的目的：
控制一个类中实例化对象的产生个数。
（2）单例设计模式：
如果要调用类中定义的操作，那么很明显需要一个实例化对象，这时就可以在类的内部使用static方式来定义一个公共的对象，并且每一次通过static方法返回唯一的一个对象，这样外部不管有多少次调用，最后一个类只能够产生唯一的一个对象，这样的设计就属于单例设计模式。
最终代码优化：
class Singleton{
private static final Singleton INSTANCE = new Singleton();
private Singleton(){
}
public void print(){
System.out.println("Hello World!");
}
public static Singleton getInstance(){
return INSTANCE;
}
}
public class TestSingleton {
public static void main(String[] args) {
Singleton s = Singleton.getInstance() ;
s.print();
}
}
用了final后就变成了常量。
（3）单例设计特点：
构造方法被私有化，只能通过getInstance()方法取得Singleton类的实例化对象，这样不管外部如何操作，最终只有一个实例化对象。在单例设计模式中，一定会存在一个static方法，用于取得本类的实例化对象。
（4）单例设计模式形式：饿汉式、懒汉式。
上面的程序就属于饿汉式，其特点：在Singleton类定义时就已经准备好了一个Singleton类的实例化对象，而并没有关心这个对象是否使用。
懒汉式：它是在第一次使用的时候才进行实例化操作。
懒汉式代码：
class Singleton{
private final static Singleton INSTANCE ;
private Singleton(){
}
public void print(){
System.out.println("Hello World!");
}
public static Singleton getInstance(){
if (INSTANCE==null){ //此时还没有实例化
INSTANCE = new Singleton(); //实例化对象
}
return INSTANCE;
}
}
public class TestSingleton {
public static void main(String[] args) {
Singleton s = Singleton.getInstance() ;
s.print();
}
}
2.多例设计模式
作用：定义多个对象。
例如：
定义一个表示性别的类，它就只能有两个对象。
定义一个表示星期的类，它的对象就只能有七个。
定义一个表示性别的类：
class Sex{
private String title;
private static final Sex MALE=new Sex("男");
private static final Sex FEMALE=new Sex("女");
private Sex(String title) {
this.title = title;
}
public String toString() {
return this.title;
}
public static Sex getInstance(String ch){
switch (ch){
case "man":
return MALE;
case "women":
return FEMALE;
default:
return null;
}
}
}
public class Demo3 {
public static void main(String[] args) {
Sex sex=Sex.getInstance("man");
System.out.println(sex);
}
}
不管是单例设计还是多例设计，有一个核心不能改变：构造方法私有发。
