Android（java）学习笔记18：单例模式

单例模式代码示例：

1. 单例模式之饿汉式：

 package cn.itcast_03;

 public class Student {
     // 构造私有
     private Student() {
     }

     // 自己造一个
     // 静态方法只能访问静态成员变量，加静态
     // 为了不让外界直接访问修改这个值，加private
     private static Student s = new Student();

     // 提供公共的访问方式
     // 为了保证外界能够直接使用该方法，加静态,不加static，外界就必须创建一个对象，显然这里是不容许的
     public static Student getStudent() {
         return s;//这里是原子性操作，不是多条语句操作共享数据，所以开发的时候，我们用饿汉式，会比较安全（开发时候会常涉及到多线程）
     }
 }

 测试类：

 package cn.itcast_03;

 /*
  * 单例模式：保证类在内存中只有一个对象。
  *
  * 如何保证类在内存中只有一个对象呢?
  *         A：把构造方法私有
  *         B: 在成员位置自己创建一个对象
  *         C: 通过一个公共的方法提供访问
  */
 public class StudentDemo {
     public static void main(String[] args) {
         // Student s1 = new Student();
         // Student s2 = new Student();
         // System.out.println(s1 == s2); // false

         // 通过单例如何得到对象呢?

         // Student.s = null;

         Student s1 = Student.getStudent();
         Student s2 = Student.getStudent();
         System.out.println(s1 == s2);

         System.out.println(s1); // null，cn.itcast_03.Student@175078b
         System.out.println(s2);// null，cn.itcast_03.Student@175078b
     }
 }

2. 单例模式之懒汉式：

 package cn.itcast_03;

 /*
  * 单例模式：
  *         饿汉式：类一加载就创建对象
  *         懒汉式：用的时候，才去创建对象
  *
  * 面试题：单例模式的思想是什么?请写一个代码体现。
  *
  *         开发：饿汉式(是不会出问题的单例模式)
  *         面试：懒汉式(可能会出问题的单例模式)
  *             A:懒加载(延迟加载)
  *             B:线程安全问题
  *                 a:是否多线程环境    是
  *                 b:是否有共享数据    是
  *                 c:是否有多条语句操作共享数据     是
  */
 public class Teacher {
     private Teacher() {
     }

     private static Teacher t = null;

     public synchronized static Teacher getTeacher() {
         // t1,t2,t3
26         if (t == null) {//多条语句操作共享数据
27             //t1,t2,t3
             t = new Teacher();
29         }
         return t;
     }
 }

测试类：

 package cn.itcast_03;

 public class TeacherDemo {
     public static void main(String[] args) {
         Teacher t1 = Teacher.getTeacher();
         Teacher t2 = Teacher.getTeacher();
         System.out.println(t1 == t2);
         System.out.println(t1); // cn.itcast_03.Teacher@175078b
         System.out.println(t2);// cn.itcast_03.Teacher@175078b
     }
 }

3. 单例模式之双重锁定： 

思路很简单，就是我们只需要同步（synchronize）初始化instance的那部分代码从而使代码既正确又很有效率。 这就是所谓的“双检锁”机制（顾名思义）。 

 public class Singleton{
   private static Singleton single;    //声明静态的单例对象的变量
   private Singleton(){}    //私有构造方法   

   public static Singleton getSingle(){    //外部通过此方法可以获取对象
     if(single == null){           // Single Checked
         synchronized (Singleton.class) {   //保证了同一时间只能只能有一个对象访问此同步块
             if(single == null){   // Double Checked
                 single = new Singleton();
         }
       }
     }
     return single;   //返回创建好的对象
   }
 }