Java 单例设计模式

设计模式：一系列解决问题的方法（思想）（基本原型23种）

其中一种单例设计模式（singleton）

解决问题：保证类的对象唯一

例子：多个程序操作的是同一个类

1.程序A和程序B是两个不同的程序

2.程序A要对C这个文件中的数据引用

3.将C中要被A引用的数据封装为一个类，在A中创建C的对象

4.B也要引用C中的数据，并且，B要引用与A引用的数据相同的数据结果（或者 B要引用A对C中数据改变后的数据）

此时就要保证C文件的类是唯一的，A调用后，B再接着调用。

总结：

需要用到单例设计的情景： 多个程序都要使用一个文件里必须要把数据封装到一个类中，而且要实现数据的共享和交换，此时多个程序都要引用同一个类，那就是要保证类的对象是唯一的

怎样实现对象的唯一性

1.类提供了构造函数，导致只要在程序中调用构造函数，就可以创建对象————无法实现对象的个数可控

2.对于上述问题：是其他程序无法调用构造函数，无法在程序中使用构造函数——在程序中无法创建对象

3.对于2的问题（那对象从何而来）：直接在类中创建对象

4.在类中创建可以调用这个类的方式（一般是写一个方法）

解决思路：

1.将构造函数私有化

2.在类中创建类的对象（是类的对象的个数私有化）

3.在类中定义方法使外部程序可以调用这个对象

代码实现：

饿汉式

package Object;
class Single{
    //1.构造函数私有化
    private Single(){}
    //2.创建对象
   

 static Single s=new Single();

    //给外部函数创建调用的方式

public static Single getInstance(){ //public :给这个函数最大的权限（函数用来获取对象，权限不大无法获取那程序就此也无法再进行下去） //静态的方法调用的必须都是静态 return s; } void Speak(){ System.out.println("完成创建类的唯一对象！"); }}public class singletonDemo { public static void main(String[] args){ //调用方法，一用对象，二用类名 //构造函数被私有化 无法用对象调用，则用类名调用 //用类名调用必须是静态 Single d =Single.getInstance(); d.Speak(); }}

输出：完成创建类的唯一对象！

单例代码的优化和细节处理

1.类中有两个静态

 static Single s=new Single();

 public  static Single getInstance(){
        return s;
    }

在主函数中的调用

Single d =Single.getInstance();

 Single d2=Single.s;

都实现了对象的调用（都是对同一个对象s调用）

区别：一，用方法调用可以实现对对象的可控调用，使用创建语句调用对象是不可控的，只要调用就可以调用对象

举例：在主函数中存在一个数据x 为一个指标：当指标大于10时才能调用对象（使用对象中的数据 ），此时用创建语句据无法实现这一功能，就要使用方法区调用

 public  static Single getInstance(int x){
      if(x>10){
        return s;
    }
}

实现对对象调用的可控

通常方法调用更优

2.将创建语句私有还是外部程序无法调用，只留最优的方法调用

private  static Single s=new Single();

单例的另一种表示方式

//单例延迟（懒汉式）

class Single2{
    private Single2(){}
    public static Single2 s=null;   //只定义引用变量
    public static Single2 getInstance(){
        if(s==null){
            s=new Single2();//对象在函数调用时创建
        }
        return s;
    } 
}

总结：

饿汉式：在类加载时就已经创建了类

懒汉式：在调用方时才会创建类。

开发时：一般用饿汉式，因为这个类的存在就是为了这个对象，不创建这个唯一的对象，这个类也没有存在的意义。同时懒汉式在多线程时会有很多问题