单例模式

本文主要是介绍单例模式，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

单例模式

单例(单个的实例)
所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例， 并且该类只提供一个取得其对象实例的方法

1. 单例模式的两种实现方式 ：(1)饿汉式 (2)懒汉式

   • 饿汉式(步骤)

     1. 构造器私有化

        • private Person(String name) {
            this.name = name;
              }
          

     2. 类的内部创建static对象

        • private static Person person = new Person(name);
          

     3. 向外提供一个静态的方法，返回 一个对象

        • public static Person getInstance(){
            return person;
              }
          

        代码

        public static void main(String[] args) { 
          // GirlFriend xh = new GirlFriend("小红"); 
          // GirlFriend xb = new GirlFriend("小白"); 
          //通过方法可以获取对象 
          GirlFriend instance = GirlFriend.getInstance(); 
          System.out.println(instance);
          GirlFriend instance2 = GirlFriend.getInstance(); 
          System.out.println(instance2); 
          System.out.println(instance == instance2);//T 
          //System.out.println(GirlFriend.n1); //...
        }
        //有一个类， GirlFriend 
        //只能有一个女朋友 
        class GirlFriend { 
          private String name;
         //public static int n1 = 100;
          //为了能够在静态方法中，返回 gf 对象，需要将其修饰为 static 
          //對象，通常是重量級的對象, 餓漢式可能造成創建了對象，但是沒有使用. 
          private static GirlFriend gf = new GirlFriend("小红红"); 
          //如何保障我们只能创建一个 GirlFriend 对象 
          //步骤[单例模式-饿汉式] 
          //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 + '\'' + '}';
          } 
        }
        

   • 懒汉式(步骤)

     1. 构造器私有化

         private Person(String name) {
          this.name = name;
            }
        

     2. 定义一个static静态属性对象，不直接new。静态的随着类的加载只会执行一次

        • private static Person person;
          

     3. 提供一个公共的pubilc的static方法，用来返回一个person对象(加入一个判断条件：判断person对象 是否为空)

        • public static Person getInstance(){
            if (person == null){
               person = new Person(name);
              }
               return person;
          }
          

        代码

        public class SingleTon02 { 
          public static void main(String[] args) { 
            //new Cat("大黃"); 
            //System.out.println(Cat.n1); 
            Cat instance = Cat.getInstance(); 
            System.out.println(instance); 
            //再次調用 
            getInstance Cat instance2 = Cat.getInstance(); 
            System.out.println(instance2); 
            System.out.println(instance == instance2);//T 
          } 
        }
        //希望在程序運行過程中，只能創建一個 Cat 對象 
        //使用單例模式
        class Cat {
          private String name; 
          public static int n1 = 999;
          private static Cat cat ; //默認是 null 
          //步驟
          //1.仍然構造器私有化 
          //2.定義一個 static 静态属性对象
          //3.提供一個 public 的 static 方法，可以返回一個 Cat 對象
          //4.懶漢式，只有當用戶使用 getInstance 時，才返回 cat 對象, 後面再次調用時，會返回上次創建的 cat 對象 
          // 從而保證了單例 
          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 + '\'' + '}';
          }
        

2. 饿汉式的问题：在类加载的时候就创建对象，会导致创建了对象但是没有使用,可能存在资源浪费问题

3. 懒汉式的问题：存在线程安全问题

这篇关于单例模式的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！