JAVA單態設計模式，JAVA態設計模式

JAVA單態設計模式，JAVA態設計模式

核心--在類的內部把構造器私人化,同時在內部產生對象,並通過類.靜態方法(static)返回執行個體化對象的引用

 

設計模式是在大量的實踐總結和理論化之後優選的代碼結果,編程風格,以及解決問題的思考方式.設計模式就像是經典的棋譜,不同的棋局我們用不同的棋譜.

單態設計模式：採取一定的方法保證在整個軟體系統中,對某個類只能產生一個對象執行個體,並且該類只提供一個取得其對象的執行個體方法.

在java中實現單態模式只需要執行以下三步：  

  1.將類的構造方法的存取權限聲明為private.這樣就不能用new操作符在類的外部產生類的對象了,但在類內部仍可以產生該類的對象.

  2.在類內部產生一個靜態執行個體.

  3.提供一個靜態方法用於外部取得該類的執行個體.

  因為在類的外部無法得到類的對象,所以只能調用該類的某個靜態方法以返回類內部建立的對象,又因為靜態方法只能訪問類中的靜態成員變數,所以,指向類內部產生該類對象的變數也必須定義成靜態.

 

 

 

class Chinese{

    static Chinese objRef = new Chinese();

   

    private Chinese(){}

    public static Chinese getInstance(){

        return objRef;

    }

}

 

class Chinese_opt{

    static Chinese_opt objRef = null;

    private Chinese_opt(){}

    public static Chinese_opt getInstance(){

        if(objRef == null)

            objRef = new Chinese_opt();

        return objRef;

    }

   

}

class TestChinese{

    public static void main(String[] args){

        Chinese chinese1 = Chinese.getInstance();

        Chinese chinese2 = Chinese.getInstance();

        System.out.println(chinese1 == chinese2);

    }

}

 

 

 

 

 

 

1：構造方法私人化：

物件導向編程的三大特性：封裝、繼承、多態。類的封裝性不僅體現在對屬性的封裝上，實際上方法也是可以被封裝的，構造方法是特殊的方法當然也可以被封裝，例如下面的代碼就是對構造方法的封裝：

package com.zxf.javaopp;

 

public class Singleton {

    private Singleton(){     // 將構造方法進行了封裝，私人化  

    }

    public void print(){

       System.out.println("Hello World!!!") ;

    }

}

建構函式被私人化，不能在外部執行個體化，就無法在外部使用，此時只能在該類的內部執行個體化對象了，然後將該類拿到外部進行使用，由於該類不能再外部執行個體化，此時在內部的執行個體化必須是用static關鍵字修飾的：代碼如下：

package com.zxf.javaopp;

 

class Singleton1{

    static Singleton1 instance = new Singleton1() ;  // 在內部產生本類的執行個體化對象

    private Singleton1(){       // 將構造方法進行了封裝，私人化  

    }

    public void print(){

       System.out.println("Hello World!!!") ;

    }

}

public class SingletonDemo01{

    public static void main(String args[]){

       Singleton1 s1 = null ;   // 聲明對象

       s1 = Singleton1.instance ;  // 取得執行個體化對象

       s1.print() ;      // 調用方法

    }

}

雖然上面的代碼實現了功能，但又有些問題：通常情況下：我們將屬性封裝，此時的代碼就要修改如下：

package com.zxf.javaopp;

 

class Singleton1{

    static Singleton1 instance = new Singleton1() ;  // 在內部產生本類的執行個體化對象

    public static Singleton1 getInstance(){       // 通過靜態方法取得instance對象

       return instance ;

    }

    private Singleton1(){       // 將構造方法進行了封裝，私人化  

    }

    public void print(){

       System.out.println("Hello World!!!") ;

    }

}

public class SingletonDemo01{

    public static void main(String args[]){

       Singleton1 s1 = null ;   // 聲明對象

       s1 = Singleton1.getInstance() ; // 取得執行個體化對象

       s1.print() ;      // 調用方法

    }

}

以上的代碼似乎變得很複雜，不如不將構造方法執行個體化呢，但是為什麼又會這樣做呢？

假如我們現在要產生幾個對象：按以往的代碼，就需要執行個體化多次，每個對象都有其對應的堆棧空間，此時的記憶體就消耗的很多，系統的效率坑定比較低，但是使用將構造方法封裝的模式效率就比較高：

 使用將構造方法封裝的方法：無論產生多少個對象，我們只執行個體化一次，這樣的設計在設計模式上稱為單態設計模式（單例設計模式）：

singleton,如果不希望一個類產生多個執行個體的話，則必須使用單態設計模式，此設計模式，在以後的高效能開發中經常使用，而且在java的類庫中大量的使用了此設計模式。

    所謂單態就是在入口處限制了對象的執行個體操作。

    單態設計模式的意義：

實際上這種模式非常常用，我們大家使用的windows作業系統中就使用了此設計模式，windows中用一個斷行符號站： ，除了案頭以外，其他的每個硬碟中都有一個斷行符號站，其他的斷行符號站和其他硬碟的每個斷行符號站都是同一個，也就是所整個作業系統中有且只有一個斷行符號站，各個地方只是引用此執行個體。

總結：

單態設計模式的核心就是將類的

 建構函式私人化，在類的內部產生執行個體對象，並通過類的靜態方法返回類的執行個體對象。