java靜態單例

⑴ java中單列模式,我要詳細點的,麻煩各位給我介紹一下

單例模式分三種：懶漢式單例、餓漢式單例、登記式單例三種。
單例模式有一下特點：
1、單例類只能有一個實例。
2、單例類必須自己自己創建自己的唯一實例。
3、單例類必須給所有其他對象提供這一實例。

一、懶漢式單例
在類被載入的時候，唯一實例已經被創建。這個設計模式在Java中容易實現，在別的語言中難以實現。
/**
* Created by IntelliJ IDEA.
* User: leimin
* Date: 2007-9-11
* Time: 14:57:08
* <<Java與模式>> 單例模式-懶漢式單例
*/
public class LazySingleton {
/**
* 私有靜態對象,載入時候不做初始化
*/
private static LazySingleton m_intance=null;
/**
* 私有構造方法,避免外部創建實例
*/
private LazySingleton(){
}
/**
* 靜態工廠方法,返回此類的唯一實例.
* 當發現實例沒有初始化的時候,才初始化.
* @return LazySingleton
*/
synchronized public static LazySingleton getInstance(){
if(m_intance==null){
m_intance=new LazySingleton();
}
return m_intance;
}
}
二、餓漢式單例
在類載入的時候不創建單例實例。只有在第一次請求實例的時候的時候創建，並且只在第一次創建後，以後不再創建該類的實例。
/**
* Created by IntelliJ IDEA.
* User: leimin
* Date: 2007-9-11
* Time: 14:45:25
* <<Java與模式>> 單例模式-餓漢式單例
*/
public class EagerSingleton {
/**
* 私有的(private)唯一(static final)實例成員,在類載入的時候就創建好了單例對象
*/
private static final EagerSingleton m_instance = new EagerSingleton();
/**
* 私有構造方法,避免外部創建實例
*/
private EagerSingleton() {
}
/**
* 靜態工廠方法,返回此類的唯一實例.
* @return EagerSingleton
*/
public static EagerSingleton getInstance() {
return m_instance;
}
}
三、登記式單例
這個單例實際上維護的是一組單例類的實例，將這些實例存放在一個Map（登記薄）中，對於已經登記過的實例，則從工廠直接返回，對於沒有登記的，則先登記，而後返回。
/**
* Created by IntelliJ IDEA.
* User: leimin
* Date: 2005-9-11
* Time: 15:20:16
* <<Java與模式>> 單例模式- 登記式單例
*/
public class RegSingleton {
/**
* 登記薄,用來存放所有登記的實例
*/
private static Map<String, RegSingleton> m_registry = new HashMap();
//在類載入的時候添加一個實例到登記薄
static {
RegSingleton x = new RegSingleton();
m_registry.put(x.getClass().getName(), x);
}
/**
* 受保護的默認構造方法
*/
protected RegSingleton() {
}
/**
* 靜態工廠方法,返回指定登記對象的唯一實例;
* 對於已登記的直接取出返回,對於還未登記的,先登記,然後取出返回
* @param name
* @return RegSingleton
*/
public static RegSingleton getInstance(String name) {
if (name == null) {
name = "RegSingleton";
}
if (m_registry.get(name) == null) {
try {
m_registry.put(name, (RegSingleton) Class.forName(name).newInstance());
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
return m_registry.get(name);
}
/**
* 一個示意性的商業方法
* @return String
*/
public String about() {
return "Hello,I am RegSingleton!";
}
}

單列的列子

第一種形式:
public class Singleton {
private Singleton(){}

private static Singleton instance = new Singleton();
public static Singleton getInstance() {
return instance;
}
}

第二種形式:
public class Singleton {
private static Singleton instance = null;
public static synchronized Singleton getInstance() {
if (instance==null)
instance＝new Singleton();
return instance;
}
}

⑵ Java中單例模式和靜態類的區別

單例模式與靜態類（一個類，所有方法為靜態方法）是另一個非常有趣的問題，在《Java中有關單例模式的面試問題》博文中露掉了，由於單例模式和靜態類都具有良好的訪問性，它們之間有許多相似之處，例如，兩者可以直接使用而無須創建對象，都可提交唯一實例，在一個非常高的高度上看起來它們都為是用於同樣的任務。由於它們具有較多的相似性，面試官常常會問一些類似為神馬使用單例模式替換靜態方法？你能使用靜態類替換單例模式嗎？Java中單例模式與靜態的區別有那些？等這樣的問題，為回答這些問題，記住他們單例模式和靜態方法之間基本的區別是非常重要的，前者給你一個Object，後者僅僅提供靜態方法，由於對像比方法具有較強的能力，可以指導你神馬時候使用單例模式與靜態方法。

在本文中，我們會了解神馬Java中的神馬地方使用單例模式，神馬時候使用靜態類更好，順便說下，JDK中有幾個關於兩者的例子，並且這例子非常聰明的，例如java.lang.Math是一個final類，並且其方法為靜態方法，另一方面java.lang.Runtime是一個單例的類。對於那些不熟悉單例模式或靜態類的人，靜態類就是一個Java類，它僅包含靜態方法，一個非常好靜態類的例子就是java.lang.Math，它包括了許多為不同數據功能實現工具方法，例如sqrt()，而單例類，在整個應用生命周期內只有一個實例，例如java.lang.Runtime。

神馬時候在Java中使用靜態類替換單例

確實存在一些場景，靜態類比單例更適合，這個場景中主要的一個例子就是java.lang.Math，它不是單例的，其所有方法都是靜態方法，這里我給出幾個場景，我覺得使用靜態類比單例模式更適合。

1)
如果你的單例不需要維護任何狀態，僅僅提供全局訪問的方法，這種情況考慮使用靜態類，靜態方法比單例更快，因為靜態的綁定是在編譯期就進行的。但是要記住，不建議在靜態類中維護狀態信息，特別是在並發環境中，若無適當的同步措施而修改多線程並發時，會導致壞的競態條件。

如果你需要將一些工具方法集中在一起時，你可以選擇使用靜態方法，但是別的東西，要求單例訪問資源時，應該使用單例模式。

Java中單例與靜態的區別

這是回答關於單例與靜態的第二面試問題，如我早些提到過的，它們基本的區別一個表現類，一個表現方法，下面列幾條它們之間的區別。

1) 靜態類比單例具有更好的性能，因為靜態方法在編譯期綁定。

2) 再次，它們的區別是override的能力，因Java中的靜態方法是不可以覆蓋的，這就導致其木有太多的靈活性，另一面，你可通過繼承的方式覆蓋單例類中定義的方法。

3) 靜態類很難模擬，因此難於單例測試，單例更容易模擬，因為也比靜態類易於編寫單元測試，不論神馬單例期望神馬，你都可以傳遞模擬對象，例如構造方法或方法參數。

4) 如果你的需求中需要維護狀態信息，則單例比靜態類更適合，因為後者在維護狀態信息方面是非常可怕的，並導致狡滑的bug。

5) 如果是一個非常重的對象，單例可以懶載入，但是靜態類沒有這樣的優勢，並且非常熱切的載入。

6) 許多依賴注入的框架對單例都有良好的管理，例如Spring，使用它們非常容易。

兩者之間的這些區別，有助於我們在面對一些場景時做出選擇，下一節中了解神馬時候選擇單例而不是靜態類。

Java中，選擇單例而不是靜態類的優點

單例與靜態主要的優點是前者比後者更具有面向對象的能力，使用單例，可以通過繼承和多態擴展基類，實現介面和更有能力提供不同的實現，如果我們討論java.lang.Runtime，在Java中它是單例，調用getRuntime()方法，會基於不同的JVM返回不同的實現，但也保證了每個JVM中實有一個實例，如果java.lang.Runtime是一個靜態類，不太可能因不同的JVM返回不同的實現。

這就是Java中單例與靜態類的區別，當你需要一個全OO能力的對象時，選擇單例，如果僅僅是將一些靜態方法預售，使用靜態類。

⑶ java中的單例模式的代碼怎麼寫

單例模式(Singleton) ,屬於最常見的設計模式之一，大部分系統都會用到，目的是為了維護系統中唯一的一個實例。
可分為eager模式，示例代碼如下：
Java代碼
1.class EagerSingleton{
2. private static final EagerSingleton m_instance = new EagerSingleton();
3. private EagerSingleton(){}
4. public static EagerSingleton getInstance(){
5. return m_instance;
6. }
7.}
class EagerSingleton{
private static final EagerSingleton m_instance = new EagerSingleton();
private EagerSingleton(){}
public static EagerSingleton getInstance(){
return m_instance;
}
}
和 lazy模式，示例代碼如下：
Java代碼
1.class LazySingleton{
2. private static LazySingleton m_instance = null;
3. private LazySingleton(){}
4. public synchronized static getInstance(){
5. if(m_instance == null){
6. m_instance = new LazySingleton();
7. }
8. return m_instance;
9. }
10.}
class LazySingleton{
private static LazySingleton m_instance = null;
private LazySingleton(){}
public synchronized static getInstance(){
if(m_instance == null){
m_instance = new LazySingleton();
}
return m_instance;
}
}
java源碼中，Runtime.getRuntime()就是單例的一個例子。
單例模式的精神就是整個系統中維護一個實例，推廣開來，如果在一個系統中需要維護多個示例，那麼就產生了多例模式(multiton)。
多例模式(Multiton) ,通過聚集對象了保留自身的多個示例，根據客戶端的參數返回所需要的實例。
示例代碼如下：
Java代碼
1.class Multiton{
2. private final int INSTANCE_SIZE = 10;
3. private static Map instances = new HashMap(INSTANCE_SIZE);
4. private String name;
5. private Multiton(){}
6. private Multiton(String name){
7. this.name = name;
8. }
9. public synchronized static getInstance(String name){
10. if(instances.containsKey(name)){
11. return instances.get(name);
12. }
13. else{
14. ins = new Multiton(name);
15. instances.put(name, ins);
16. return ins;
17. }
18. }
19.}
class Multiton{
private final int INSTANCE_SIZE = 10;
private static Map instances = new HashMap(INSTANCE_SIZE);
private String name;
private Multiton(){}
private Multiton(String name){
this.name = name;
}
public synchronized static getInstance(String name){
if(instances.containsKey(name)){
return instances.get(name);
}
else{
ins = new Multiton(name);
instances.put(name, ins);
return ins;
}
}
}
[nextpage]
一個實用的例子就是KeyGenerator, 示例代碼如下：
Java代碼
1.class KeyGenerator{
2. private final int POOL_SIZE = 20;
3. private static Map instances = new HashMap(16);
4. private KeyInfo keyinfo;
5. private KeyGenerator(){}
6. private KeyGenerator(String keyName){
7. this.keyinfo = new KeyInfo(POOL_SIZE, keyName);
8. }
9. public synchronized static getInstance(String keyName){
10. if(instances.containsKey(keyName)){
11. return (KeyGenerator)instances.get(keyName);
12. }
13. else{
14. keyGen = new KeyGenerator(keyName);
15. instances.put(name, keyGen);
16. return keyGen;
17. }
18. }
19. public synzhronized int getNextKey(){
20. return keyinfo.getNextKey();
21. }
22. }
class KeyGenerator{
private final int POOL_SIZE = 20;
private static Map instances = new HashMap(16);
private KeyInfo keyinfo;
private KeyGenerator(){}
private KeyGenerator(String keyName){
this.keyinfo = new KeyInfo(POOL_SIZE, keyName);
}
public synchronized static getInstance(String keyName){
if(instances.containsKey(keyName)){
return (KeyGenerator)instances.get(keyName);
}
else{
keyGen = new KeyGenerator(keyName);
instances.put(name, keyGen);
return keyGen;
}
}
public synzhronized int getNextKey(){
return keyinfo.getNextKey();
}
}