Java设计模式之单例模式

单例模式：

        核心思想：某些类的对象在创建的时候，在系统内存始终只有一个对象；

        优点：
                在系统中只存在一个对象，因此可以节约系统资源，对于一些需要频繁创建和销毁的对象单例模式可以提高系统的性能；
        缺点：
                1> 没有抽象层，扩展很难；
                2> 职责过重，在一定程度上违背了单一职责；

        分类：
                1> 饿汉式；
                        简单记：在加载那个类的时候，对象的创建工作就已经完成了；
                2> 懒汉式(类似于多线程环境)；
                         简单记：需要的时候才进行创建工作；

        两种分类在设计上几乎一样：
                1> 定义个类，将该类的无参构造方法私有化；
2> 在该类的成员位置创建该类对象并且一定要私有化，防止外界更改这个对象；
                3> 在该类中提供静态成员方法(返回值就是创建的那个对象)，能被当前类直接调用，static修饰；

        实现：
                1> 构造函数私有化：
                        ①类外不可创建对象；
                        ②构造函数私有的类(父类)，不可被继承(子类不能调用父类的私有)；
                2> 类的静态成员，必须初始化；

                3> 静态数据成员的访问：不能通过对象直接访问，只能调用类中的静态方法间接访问；

饿汉式：

        举例：
                定义一个学生类：

package org.westos_03;

//学生类
public class Student {

	//无参构造私有化,目的为了防止用户创建对象的时候,会产生多个对象!
	//为了不让直接通过构造方法创建该类对象
	/*public Student() {
		
	}*/
        //无参构造私有化
	private Student() {

        }

	//成员位置创建该类的实例
	//静态方法只能访问静态变量,所以这个Student方法要加上static
	//加入私有修饰,防止定义对象之前将Student s=null	
	private static Student s = new Student() ; //静态的类变量

	//提供一个公共的成员方法
	public  static Student getStudent() {
		return s ;
	}
}

                测试类：

package org.westos_03;
/**
 *设计模式之单例模式
 *		单例模式核心思想:某些类的对象在创建的时候 ,在系统内存始终只有一个对象!
 *		单例模式分类:
 *			1)饿汉式 2)懒汉式(类似于多线程环境..)
 *
 *饿汉式:
 *		在加载那个类的时候,对象的创建工作就已经完成了
 */
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);//true
		
		System.out.println(s1);//org.westos_03.Student@70dea4e
		System.out.println(s2);//org.westos_03.Student@70dea4e
	}
}

懒汉式：

        举例：
                定义一个老师类：

package org.westos_04;

//老师类
public class Teacher {
	
	//无参构造私有化
	private Teacher() {
		
	}
	
	//在成员位置声明变量
	//私有化,并且
	private static Teacher t = null ;
	
	//提供公共的静态功能
	/*public static Teacher getTeacher() {
		//如何创建该类对象,需要用的时候在创建
		//t1,t2,t3
		//在这里需要判断
		synchronized (t) {
			if(t==null) {
				t = new Teacher() ;
			}
			return t ;
		}
		
	}*/
	
	
	//静态的同步方法  (锁对象: 类名.class)
	public synchronized static Teacher getTeacher() {
		if(t==null) {
			t = new Teacher() ;
		}
		return t ;
	}
}

                测试类：

package org.westos_04;
/*
 * 懒汉式:
 * 		符合单例模式核心思想
 * 		1)自定义一个类,将无参构造私有化
 * 		2)在成员位置声明变量
 * 		3)提供公共静态功能,在里面判断的创建该类对象,返回该类对象
 * 
 * 如果是开发中,那么就使用饿汉式(饿汉式它不会出现问题的单例模式)
 * 如果是面试中,那么使用懒汉式(因为他是可能出现问题的一种单例模式)
 * 
 * 面试题:
 * 	你使用过单例模式吗?简单介绍一种单例模式,请用代码设计
 * 		面试官想问的是:使用设计单例的懒汉式,能否想到使用同步机制解决线程的安全问题..
 * 
 * 懒汉式(延迟加载 -->懒加载)
 * 		可能会出现问题
 * 			--->多线程的问题
 * 			--->校验多线程安全问题的标准
 * 				1)是否是多线程环境
 * 				2)是否有共享数据
 * 				3)是否有多条语句对共享数据进行操作  (使用同步机制进行操作)
 *
 */
public class TeacherDemo {
	
	public static void main(String[] args) {
		
		//调用getTeacher()功能
		Teacher t1 = Teacher.getTeacher() ;
		Teacher t2 = Teacher.getTeacher() ;
		System.out.println(t1==t2);
		System.out.println(t1);//org.westos_04.Teacher@70dea4e
		System.out.println(t2);
		}
}