java设计模式之单例模式

单例模式：保证类在内存中只有一个对象。

                  分为：

                             饿汉式：类一加载就创建对象     经典案例：JDK中的Runtime类
                             懒汉式：用的时候，才去创建对象

如何保证类在内存中只有一个对象呢?
     A：把构造方法私有
     B：在成员位置自己创建一个对象
     C：通过一个公共的方法提供访问单例模式：保证类在内存中只有一个对象。

 A.饿汉式(是不会出问题的单例模式)：

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

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

	// 提供公共的访问方式
	// 为了保证外界能够直接使用该方法，加静态
	public static Student getStudent() {
		return s;
	}
}

测试类：
public class StudentDemo {
	public static void main(String[] args) {
		Student s1 = new Student();
		Student s2 = new Student();
		System.out.println(s1 == s2); // false 非单例模式
		Student s1 = Student.getStudent();
		Student s2 = Student.getStudent();
		System.out.println(s1 == s2); // true 饿汉式单例模式
		System.out.println(s1); // null //Student@175078b
		System.out.println(s2); // null //Student@175078b
	}
}

B.懒汉式(可能会出问题的单例模式)：
      A:懒加载(延迟加载)
      B:线程安全问题

public class Teacher {
	private Teacher() {
	}

	private static volatile Teacher t = null;
	// volatile关键字在下方解释

	public static Teacher getTeacher() {
		if (t == null) { //第一次判断，提高效率
			synchronized  (Teacher.class) {
				if(t == null) { //第二次判断，实现单例
					t = new Teacher();
				}
			}
		}
		return t;
	}
}

测试类：
public class TeacherDemo {
	public static void main(String[] args) {
		Teacher t1 = Teacher.getTeacher();
		Teacher t2 = Teacher.getTeacher();
		System.out.println(t1 == t2); // true 懒汉式单例模式
		System.out.println(t1); //Teacher@175078b
		System.out.println(t2); //Teacher@175078b
	}
}