对象=null new一个对象，单列和对象实例化

String str = new String("Test")，是开辟内存放入了对象，并把它的引用赋给str。
同理，BookInfo bookinfo=null与BookInfo bookinfo=new BookInfo()：前者，是声明了一个对象（的引用），jvm并没有开辟内存放入一个对象；而后者，在声明了一个对象的引用后，又把新开辟的没有存储任何有效值的对象的地址赋给了他。

单例
//1、单例类确保自己只有一个实例(构造方法私有化)
 //2、单例类必须自己创建自己的实例。
 //3、单例类必须为其他对象提供唯一的实例。
 //将entry类的构造函数声明为私有的构造函数，这样我们在外部就无法通过Singleton s = new Singleton()来实例化该，因为Private生命的成员只有在该类的内部可以访问。这样可以保证类的实例只有一个（那就是在类的内部给它实例化）。

//饿汉式（常用）
public class Singleton1
{
    //2.提供一个全局访问点（其实就是一个全局静态字段），外部可以通过该字段访问该类的唯一实例
    //因为静态字段是属于类的，所以这样可以保证只有一个实例。
    public static Singleton1 only = new Singleton1();
    //1 将构造函数声明成私有的，这样可以确保在类的外部无法实例化该类（即在类的外部获取不到类的实例）
    private Singleton1() {}
   
    public static Singleton1 sing(){
     return only;
    }
    public void put(){
     
    }
}
懒汉式

懒汉式单例设计模式
 * 懒汉式单例设计模式在多线程同时初始化实例的时候有线程安全问题，
 * 解决的方案是，加同步锁，使用同步方法和同步代码块都能解决问题。
 * 然而多线程每次都访问锁，导致效率低下，所以使用同步代码块，然后以双重判断的形式来解决每次都判断同步锁导致的效率低下问题。
 * 在这里锁使用的是该类的文件字节码对象。因为获取实例的方法时静态方法，使用锁选择类文件字节码
public class singleton {
 private singleton(){
 }
 public static singleton sing =null;
 public static singleton getInstance(){
  if(sing==null){
   synchronized(singleton.class){
    if(sing==null){
    sing=new singleton();
    }
   }
  }
   return sing;
 }
}

public static void main(String[] args) {
  //将entry类的构造函数声明为私有的构造函数，这样我们在外部就无法通过Singleton s = new Singleton()来实例化该，因为Private生命的成员只有在该类的内部可以访问。这样可以保证类的实例只有一个（那就是在类的内部给它实例化）。
  singleton sing = singleton.getInstance(); 
  singleton sing1 = singleton.getInstance(); 
  Singleton1 s = Singleton1.only;
  Singleton1 s1 = Singleton1.getInstance();
  s.put();
  s1.put();
  System.out.println(s.equals(s1));
  System.out.println(sing.equals(sing1));
  
 }