单例模式理解

一个类只有一个实例，并提供一个访问它的全局访问点。

不考虑多线程的情况

class Singleton{
	private static Singleton instance;
	
	//构造函数用private，限制外界利用new 使用此类创建实例
	private Singleton() {
	}
	
	//此方法是获得本类实例的唯一方法
	public static Singleton GetInstance() {
		if (instance == null) {
			instance = new Singleton();
		}
		return instance;
	}	
}

//客户端访问
static void main(String[] args) {
	Singleton s = Singleton.GetInstance();
}

恶汉式和懒汉式的单例模式区别：

此部分参考学习了 https://blog.csdn.net/u012110719/article/details/45437439

饿汉式则是程序只要开始，就将他实例化，到用到他的时候就省去了再实例的时间，所以速度和反应快。懒汉式是，只有用到这个用例的时候，再将他实例化，不会浪费。

/*  
 * 单例模式之恶汉式:类一加载就创建对象  
 */  
public class Student {  

    private Student(){  
          
    }  
    //外部不能new对象，只能自己内部new一个student对象了  
    //这个要static化，因为下面要提供一个static方法对外界直接访问 
    //而且为了外部不能修改这个对象为null（Student.student=null,没意义），所以这个对象也要private  
     private static Student student = new Student();  
      
    //提供公共的访问方式，内部new的对象为了外部使用许提供一个public方法获取对象实例  
    //但是注意因为外部不能new对象，则不能通过对象名.方法获取Student类的内部实例，所有要把这个公共方法静态化statis  
    //static化之后因为static方法不能直接方法普通成员方法，只能访问静态成员，所以要将new的对象static化
    public static Student getStudent(){  
        return student;  
    }  
  
}  

//客户端访问
static void main(String[] args) {
	Student student = Student.getStudent();  
}

/×
 × 单例模式懒汉式： 使用时才创建对象
 ×/
public class Teacher {  
	  
    //私有构造方法  
    private Teacher(){  
          
    }  
    //私有  static Teacher类对象的引用teacher  需要的时候才new对象，初值为null  
    private static Teacher teacher = null;  
      
    public synchronized static Teacher getTeacher(){  
        //t1  t2  t3  
        if(teacher==null){
        	//t1判断为空进去new一个对象，然后轮到t2进去，又new一个对象出来。。。。所以线程不安全，在面试的时候就要加上synchronized同步操作  
            teacher = new Teacher();  
        }  
        return teacher;  
    }  
}  

//客户端访问
static void main(String[] args) {
	Teacher teacher = Teacher.getTeacher();
}