黑馬程序員_Java設計模式-單例設計模式

------Java培訓、Android培訓、iOS培訓、.Net培訓、期待與您交流！ -------

    設計模式：解決某一類問題最行之有效的方法，java中有23種設計模式

1 單例設計模式概述：

    1、解決一個類在內存中只有一個對象(保證一個類僅有一個實例，並提供一個訪問他的全局訪問點)
    2、要保證對象的唯一：
        (1). 爲了避免其他程序過多的建立該類對象，先禁制其他程序建立該類對象
        (2). 爲了讓其他程序可以訪問到該類對象，只好在本類中，自定義一個對象
        (3). 爲了 方便其他程序對自定義對象的訪問，可以對外提供一些訪問方式

    3、代碼實現步驟：
        (1). 將構造函數私有化
        (2). 在類中創建一個本類對象
        (3). 給外部提供一個靜態放阿飛獲取對象實例

    4、兩種實現方式：
        (1). 餓漢式
        (2). 懶漢式

2 餓漢式：

    這種是先初始化對象，稱爲：餓漢式 Single類一進內存，就已經創建好了對象（開發一般用這個，簡單安全）

public class SingleDemo1 {
    public static void main(String[] args) {
        Single s1 = Single.getInstance();//main函數中有了一個s1引用，獲取到了Single對象的地址，指向Single對象
    }
}
class Single{
    private Single(){}//將構造函數私有化，不讓其他程序建立對象

    private static Single s = new Single();//下面的靜態方法訪問到該對象所以要將該對象也修飾爲靜態
    
    //調用用類名調用，（方法的調用只有兩種方式：對象調用和類名調用，這裏沒對象只能用類名調用，所以要靜態）
    public static Single getInstance(){
        return s;
    }
}

public class SingleDemo {
    public static void main(String[] args) {
        Singleton1 s = Singleton1.getInstance();
        s.print();
    }
}
/*
          把該類設計成單例設計模式：
              餓漢式
 */
class Singleton1{
    //構造函數私有化
    private Singleton1(){
    
    }
    
    //定義一個本類對象並實例化
    private static Singleton1 s = new Singleton1();
    
    public static Singleton1 getInstance(){
        return s;
    }
    
    public void print(){
        System.out.println("餓漢式——單例設計模式");
    }
}

    如果想要該類只能建立一個對象那麼只需在該類中加入這三部就可以了（這個類該怎麼描述就怎麼描述）

public class SingleDemo1 {
    public static void main(String[] args) {
        //Test t1 = new Test();
        //Test t2 = new Test();
        Test t1 = Test.getInctance();
        Test t2 = Test.getInctance();
        t1.setNum(10);
        t2.setNum(20);
        System.out.println(t1.getNum());
        System.out.println(t2.getNum());//兩個打印結果都是20，因爲內存中只有一個對象
    }
}
class Test{
    private int num;
    private static Test t = new Test();
    private Test(){}
    public static Test getInctance(){
        return t;
    }
    public void setNum(int num){
        this.num = num;
    }
    public int getNum(){
        return num;
    }
}

3 懶漢式：

    對象是方法被調用時才初始化，也叫做對象的延時加載，稱爲懶漢式
    Single類進內存，對象還咩有存在，只有調用了getInstance方法時，才建立對象

public class SingleDemo {
    public static void main(String[] args) {
        Singleton2 s = Singleton2.getInstance();
        s.print();
    }
}
//懶漢式
class Singleton2{
    private static Singleton2 s = null;
    private Singleton2(){}
    
    public static Singleton2 getInstance(){
        if(s==null){
            s = new Singleton2();
        }
        return s;
    }
    public void print(){
        System.out.println("懶漢式——單例設計模式");
    }
}

public class SingleDemo2 {
    public static void main(String[] args) {

    }

}
class Single{
    private static Single s = null;
    private Single(){}
    //synchronized（同步）只要有一個程序進去其他程序就不能進來了，但是這樣程序的效率的降低了，執行前需要先判斷
    public static synchronized Single getInstance(){
        //減少判斷鎖的次數
        if (s==null){
            //最終的解決方案，減少判斷的次數，上面那個函數就不用同步了
            synchronized(Single.class){
                if (s==null)
                    s = new Single();
            }
        }
        return s;
    }
}

    加入同步爲了解決多線程安全問題。加入雙重判斷是爲了解決效率問題。