單例設計模式

所謂的單例設計模式，就是指一個類只能實例化一個對象

範例：一個簡單的程序

class Singleton{
    public void print() {
        System.out.println("Hello World");
    }
}
 class SingletonTest {
    public static void main(String[] args) {
        Singleton singleton = null ; // 聲明對象
           singleton = new Singleton() ; //
 
 實例化對象
           singleton.print();
    }
}

以上程序在進行對象實例化的時候調用了Singleton的無參構造。

使用private修飾聲明構造方法

class Singleton{  
  private Singleton() { 
// private聲明構造 
   }  
  public void print() {  
      System.out.println("Hello World"); 
   }
 }
 

這個時候類中已經明確的提供了一個私有的構造方法，那麽默認生成的無參構造不再產生，此時進行對象實例化的 時候一定會有錯誤。

一旦構造方法被私有化了，表示外部無法調用構造即外部不能夠產生新的實例化對象。此時的類是一個相對而言封 閉的狀態。
如果此時還想繼續調用Singleton類的print()方法，那麽必須提供實例化對象。考慮到封裝的特點，可以在類的內部 產生一個實例化對象。

範例：在類的內部產生實例化對象

class Singleton{
    // 在類的內部可以訪問私有結構，所以可以在類的內部產生實例化對象
   Singleton instance = new Singleton() ;
   private Singleton() {
       // private聲明構造
       }
       
 
public void print() {
       System.out.println("Hello World");
   }
}

現在Singleton內部的instance對象（屬性）是一個普通屬性，所有的普通屬性必須在有實例化對象的時候才能進行 內存空間的分配，而現在外部無法產生實例化對象，所以必須想一個辦法，可以在Singleton沒有實例化對象產生 的時候，也可以將instance進行使用。此時，聯想到使用static關鍵字。

範例：使用static產生實例化對象

class Singleton{
    // 在類的內部可以訪問私有結構，所以可以在類的內部產生實例化對象
  static Singleton instance = new Singleton() ;
  private Singleton() {
      // private聲明構造
        }
        public void print() {
      System.out.println("Hello World");
  }
}
 class SingletonTest {
    public static void main(String[] args) {
        Singleton singleton = null ;
        // 聲明對象
           singleton = Singleton.instance ;
           singleton.print();
    }
}
  

以上雖然可以取得Singleton類的實例化對象，但是對於類中屬性應該使用private進行封裝，要想取得private屬 性，應該提供getter()方法。由於此時訪問的是static屬性，並且這個類無法在外部提供實例化對象，因此應該提供 一個static的getter()方法，因為static方法也不受對象實例化控制。

範例:static的getter()方法

class Singleton{
    // 在類的內部可以訪問私有結構，所以可以在類的內部產生實例化對象
   private static Singleton instance = new Singleton() ;
   private Singleton() {
       // private聲明構造
         }
         public static Singleton getInstance() {
       return instance ;
   }
   public void print() {
       System.out.println("Hello World");
   }
}
 class SingletonTest {
    public static void main(String[] args) {
        Singleton singleton = null ; // 聲明對象
            singleton = Singleton.getInstance() ;
            singleton.print();
    }
}

這樣做到底要幹哈？？？？？？？
只希望類中產生唯一的一個實例化對象
對於單例設計模式也有兩類形式：懶漢式、餓漢式。
上面的代碼實際上就是餓漢式的應用。不管你是否使用Singleton類的對象，只要該類加載了，那麽一定會自動創 建好一個公共的instance對象。既然是餓漢式，就希望整體的操作之中只能夠有一個實例化對象，所以一般還會在 前面追加一個?nal關鍵字

範例：餓漢式單例模式

class Singleton{
    // 在類的內部可以訪問私有結構，所以可以在類的內部產生實例化對象
      private final static Singleton INSTANCE = new Singleton() ;
      private Singleton() {
          // private聲明構造
           }
           public static Singleton getInstance() {
          return INSTANCE ;
      }
      public void print() {
          System.out.println("Hello World");
      }
      }

class SingletonTest {
     public static void main(String[] args) {
         Singleton singleton = null; // 聲明對象
         singleton = Singleton.getInstance();
         singleton.print();

     }
 }

請編寫一個單例程序，並說明程序的主要特點。
特點：構造方法私有化，外部無法產生新的實例化對象，只能通過static方法取得實例化對象
範例：懶漢式單例模式
特點：當第一次去使用Singleton對象的時候才會為其產生實例化對象的操作

餓漢式單例

class Singleton{
    private static Singleton instance ;
    private Singleton() {
        // private聲明構造
         }
         public static Singleton getInstance() {
        if (instance==null) {
            // 表示此時還沒有實例化
                    instance = new Singleton() ;
        }        return instance ;
    }
    public void print() {
        System.out.println("Hello World");
    }
}
class SingletonTest {
    public static void main(String[] args) {
        Singleton singleton = null ; // 聲明對象
           singleton = Singleton.getInstance() ;
           singleton.print();
    }
}

懶漢式存在多線程安全問題，而餓漢式不會。）
單例模式是一個重點，重點，重點。雖然代碼量不大，但是概念用到的很多。

java 單例設計模式