java單例
❶ java單例模式。
當一個class被new也就是實例化的時候,調用構造方法的同時也會實例化成員變數,你這里定義的Singleton s=new Singleton()相當於定義了一個名為s的Singleton類型的參數,初始值為new Singleton(); 所以肯定會執行的。 正確的singleton模式其中之一:
class Singleton {
private static Singleton s;
private Singleton(){ }
public static Singleton getInstance()
{
if(s==null) s=new Singleton();
return s;
}
}
❷ 簡述java的單例模式,順便來個例子
單例就是構造方法私有化.
構造方法私有化(加private),外部無法產生對象,因為new 類名(),會無法調用該類的的構造方法
class Sing{
public static Sing instance = new Sing();//內部實例化
private Sing(){super();}//加private,外部無法實例化,即無法訪問
public static Sing getInstance(){return instance;}
}
在主類中這樣調用
Sing s = Sing.getInstance();//實現實例化對象
❸ java怎麼實現單實例運行
Java實現單例的5種方式
1. 什麼是單例模式
單例模式指的是在應用整個生命周期內只能存在一個實例。單例模式是一種被廣泛使用的設計模式。他有很多好處,能夠避免實例對象的重復創建,減少創建實例的系統開銷,節省內存。
2. 單例模式和靜態類的區別
首先理解一下什麼是靜態類,靜態類就是一個類裡面都是靜態方法和靜態field,構造器被private修飾,因此不能被實例化。Math類就是一個靜態類。
知道了什麼是靜態類後,來說一下他們兩者之間的區別:
1)首先單例模式會提供給你一個全局唯一的對象,靜態類只是提供給你很多靜態方法,這些方法不用創建對象,通過類就可以直接調用;
2)單例模式的靈活性更高,方法可以被override,因為靜態類都是靜態方法,所以不能被override;
3)如果是一個非常重的對象,單例模式可以懶載入,靜態類就無法做到;
那麼時候時候應該用靜態類,什麼時候應該用單例模式呢?首先如果你只是想使用一些工具方法,那麼最好用靜態類,靜態類比單例類更快,因為靜態的綁定是在編譯期進行的。如果你要維護狀態信息,或者訪問資源時,應該選用單例模式。還可以這樣說,當你需要面向對象的能力時(比如繼承、多態)時,選用單例類,當你僅僅是提供一些方法時選用靜態類。
❹ java 單例模式例子
直接Singleton.getSigleton()就行了。靜態方法已經初始化好了。不用new Singleton()
❺ 如何在Java中實現單例模式
public class Demo {
// 餓漢式
private Demo demo = new Demo();
private Demo () {}
public Demo getInstance() {
return demo;
}
/*
* 其他的methods
*/
}
public class Demo {
// 懶漢式
private Demo demo;
private Demo () {}
public Demo getInstance() {
if(null == demo){
return new Demo();
}
return demo;
}
/*
* 其他的methods
*/
}
❻ java 單例模式
System.out.println (Singleton.getInstance());
System.out.println (Singleton.getInstance());
main 函數中有這兩句,一摸一樣。
第一句執行的時候,第一次調用getInstance(),意思是要獲取Singleton的一個對象實例。
而正常情況下,我們要獲取對象的話是用 new Singleton(),這個方法的,但是這個方法在Singleton裡面被聲明為:private ,意思是外界不能調用。
不能調用,我怎麼用你的對象?
Singleton裡面實現了生成對象的方法,getInstance(),你要用他的對象就必須調用這個方法。
而這個方法裡面你也看到了,如果
if(instance == null){
instance = new Singleton();
}
如果沒有實例則創建一個新的,但是已經創建過的話,就返回已經存在的實例。
所以輸出結果:
net.chelson.chapter5.Singleton@de6ced
net.chelson.chapter5.Singleton@de6ced
你兩次調用的這個對象的內存地址都是相同的,也就是說,是同一個東西(對象)
這個總的來說就是:
類的構造方法私有化(防止外界構造新對象)
提供獲取實例的方法(用於外界調用)
作用:用於提供只能有一個實例的對象。
❼ 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();
}
}
❽ Java單例模式是什麼意思
Java單例模式是確保某個類只有一個實例,而且自行實例化並向整個系統提供這個實例,在計算機系統中,線程池、緩存、日誌對象、對話框、列印機、顯卡的驅動程序對象常被設計成單例的模式;
Java單例模式分三種:懶漢式單例、餓漢式單例、登記式單例。
❾ java實現一個單例類
1、餓漢式
public class EagerSigleton(){
private static final EagerSigleton m_instatnce=new EagerSigleton();
//私有構造方法
private EagerSigleton(){
}
//靜態工廠方法
public EagerSigleton getInstance(){
return m_instatnce;
}
}
2、懶漢式
public class LazySigleton(){
private static final LazySigleton l_instatnce=null;
//私有構造方法
private LazySigleton(){
}
//靜態工廠方法
public synchronized LazySigleton getInstance(){
if(l_instatnce==null){
l_instatnce=new LazySigleton();
}
return l_instatnce;
}
}