java设计模式_single(单例设计模式)

设计模式：解决某一类问题最行之有效的方法，java中有23种设计模式

一、单例设计模式概述：

　　1、解决一个类在内存中只有一个对象(保证一个类仅有一个实例，并提供一个访问他的全局访问点)
　　  2、要保证对象的唯一：
　　　　　　1.为了避免其他程序过多的建立该类对象，先禁制其他程序建立该类对象
　　　　　　2.为了让其他程序可以访问到该类对象，只好在本类中，自定义一个对象
　　　　　　3.为了 方便其他程序对自定义对象的访问，可以对外提供一些访问方式

　　 3、代码实现步骤：

　　　　　　1.将构造函数私有化
　　　　　　2.在类中创建一个本类对象
　　　　　　3.给外部提供一个静态放阿飞获取对象实例

　　  4、两种实现方式：
　　　　　　1、饿汉式
　　　　　　2、懒汉式

二、饿汉式：

　　这种是先初始化对象，称为：饿汉式 Single类一进内存，就已经创建好了对象（开发一般用这个，简单安全）

 1 public class SingleDemo1 {
 2     public static void main(String[] args) {
 3         Single s1 = Single.getInstance();//main函数中有了一个s1引用，获取到了Single对象的地址，指向Single对象
 4     }
 5 }
 6 class Single{
 7     private Single(){}//将构造函数私有化，不让其他程序建立对象
 8
 9     private static Single s = new Single();//下面的静态方法访问到该对象所以要将该对象也修饰为静态
10
11     //调用用类名调用，（方法的调用只有两种方式：对象调用和类名调用，这里没对象只能用类名调用，所以要静态）
12     public static Single getInstance(){
13         return s;
14     }
15 }

public class SingleDemo {
    public static void main(String[] args) {
        Singleton1 s = Singleton1.getInstance();
        s.print();
    }
}
/*
          把该类设计成单例设计模式：
              饿汉式
 */
class Singleton1{
    //构造函数私有化
    private Singleton1(){

    }

    //定义一个本类对象并实例化
    private static Singleton1 s = new Singleton1();

    public static Singleton1 getInstance(){
        return s;
    }

    public void print(){
        System.out.println("饿汉式——单例设计模式");
    }
}

如果想要该类只能建立一个对象那么只需在该类中加入这三部就可以了（这个类该怎么描述就怎么描述）

 1 public class SingleDemo1 {
 2     public static void main(String[] args) {
 3         //Test t1 = new Test();
 4         //Test t2 = new Test();
 5         Test t1 = Test.getInctance();
 6         Test t2 = Test.getInctance();
 7         t1.setNum(10);
 8         t2.setNum(20);
 9         System.out.println(t1.getNum());
10         System.out.println(t2.getNum());//两个打印结果都是20，因为内存中只有一个对象
11     }
12 }
13 class Test{
14     private int num;
15     private static Test t = new Test();
16     private Test(){}
17     public static Test getInctance(){
18         return t;
19     }
20     public void setNum(int num){
21         this.num = num;
22     }
23     public int getNum(){
24         return num;
25     }
26 }

三、懒汉式：

　　对象是方法被调用时才初始化，也叫做对象的延时加载，称为懒汉式
　　Single类进内存，对象还咩有存在，只有调用了getInstance方法时，才建立对象

public class SingleDemo {
    public static void main(String[] args) {
        Singleton2 s = Singleton2.getInstance();
        s.print();
    }
}
//懒汉式
class Singleton2{
    private static Singleton2 s = null;
    private Singleton2(){}

    public static Singleton2 getInstance(){
        if(s==null){
            s = new Singleton2();
        }
        return s;
    }
    public void print(){
        System.out.println("懒汉式——单例设计模式");
    }
}

 1 public class SingleDemo2 {
 2     public static void main(String[] args) {
 3
 4     }
 5
 6 }
 7 class Single{
 8     private static Single s = null;
 9     private Single(){}
10     //synchronized（同步）只要有一个程序进去其他程序就不能进来了，但是这样程序的效率的降低了，执行前需要先判断
11     public static synchronized Single getInstance(){
12         //减少判断锁的次数
13         if (s==null){
14             //最终的解决方案，减少判断的次数，上面那个函数就不用同步了
15             synchronized(Single.class){
16                 if (s==null)
17                     s = new Single();
18             }
19         }
20         return s;
21     }
22 }

加入同步为了解决多线程安全问题。加入双重判断是为了解决效率问题。