【单例模式】JAVA懒汉式和饿汉式简单实现

一、什么是单例模式

通过单例模式的方法创建的类在当前进程中只有一个实例，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法

二、实现步骤

1. 构造器私有化，防止被直接创建对象
2. 类的内部创建对象
3. 向外实现一个静态公共方法可以调用

二、饿汉式单例

• 饿汉式概念：饿汉式在一开始类加载的时候就已经实例化，并且创建单例对象，以后只管用即可
• 饿汉式实现：

• public class text {
  
      public static void main(String[] args) {
  
  //通过方法可以获取对象
          GirlFriend instance = GirlFriend.getInstance();
          System.out.println(instance);
          GirlFriend instance2 = GirlFriend.getInstance();
          System.out.println(instance2);
          System.out.println(instance.equals(instance2));
      }
  }
    
  class GirlFriend {
          private String name;
  
  //饿汉式可能造成创建了对象，但是沒有使用.
          //在
  private static GirlFriend gf = new GirlFriend("小美");
  public static int n1 = 100;
  //1. 将构造器私有化
  //2. 在类的内部直接创建对象(该对象是 static)
  //3. 提供一个公共的 static 方法，返回 gf 对象
          private GirlFriend(String name) {
              System.out.println("构造器被使用.");
              this.name = name;
          }
          public static GirlFriend getInstance() {
              return gf;
          }
          @Override
          public String toString() {
              return "GirlFriend{" +
                      "name='" + name + '\'' +
                      '}';
          }
      }
  
  

  小结：将构造器进行私有化，防止new出多个对象，在本类的内部进行new一个对象并用static修饰，并编写一个getInstance()方法返回对象引用，此时在外部可以直接使用类名.getInstance()的方式调用方法，而调用静态方法的同时会使类进行加载，而加载类的同时会将static修饰的属性和方法初始化，从而达到一个单例对象的效果，类加载时就创建了对象，线程安全，但使用static属性 n1 时也会创建对象，存在资源浪费的可能

三、懒汉式单例

• 懒汉式概念：懒汉式一开始不会实例化，什么时候用就什么时候new，才进行实例化
• 懒汉式实现：

public class text {
    
    public static void main(String[] args) {
          //System.out.println(Cat.n1);   //此时只执行Cat的静态属性不会创建出对象，构造器
//不会被调用
            Cat instance = Cat.getInstance();
            System.out.println(instance);

            Cat instance2 = Cat.getInstance();
            System.out.println(instance2);
            System.out.println(instance == instance2);//T
        }
    }


    class Cat {
        private String name;
        public static int n1 = 999;
        private static Cat cat ; //默认是 null

        private Cat(String name) {
            System.out.println("构造器调用...");
            this.name = name;
        }
        public static Cat getInstance() {
            if(cat == null) {  //如果还沒有创建 cat 
                cat = new Cat("小可愛");
            }
            return cat;
        }
        @Override
        public String toString() {
            return "Cat{" +
                    "name='" + name + '\'' +
                    '}';
        }
    }

小结：将构造器进行私有化，防止new出多个对象，在本类的内部定义一个Cat对象，默认是为null此时并未初始化，当用户使用其他静态属性或方法造成类的加载并不会使cat对象创建，当调用getInstance()方法时，会进行一个if判断语句，假如还未初始化就进行初始化，并返回对象，懒汉式不存在资源浪费问题，但存在线程安全问题