正文
java单例模式代码 java单例模式代码实现
小程序:扫一扫查出行
【扫一扫了解最新限行尾号】
复制小程序
【扫一扫了解最新限行尾号】
复制小程序
如何写一个简单的单例模式?
一、基本的实现思路:
单例的实现主要是通过以下两个步骤:
1、将该类的构造方法定义为私有方法,这样其他处的代码就无法通过调用该类的构造方法来实例化该类的对象,只有通过该类提供的静态方法来得到该类的唯一实例;
2、在该类内提供一个静态方法,当我们调用这个方法时,如果类持有的引用不为空就返回这个引用,如果类保持的引用为空就创建该类的实例并将实例的引用赋予该类保持的引用。
二、示范如下:
1、枚举实现单例:
2、懒汉式线程不安全:
3、懒汉式线程安全:
4、饿汉式:
5、双重校验锁:
6、静态内部类:
扩展资料:
一、单列模式简介:
单例模式是设计模式中最简单的形式之一。这一模式的目的是使得类的一个对象成为系统中的唯一实例。要实现这一点,可以从客户端对其进行实例化开始。因此需要用一种只允许生成对象类的唯一实例的机制,“阻止”所有想要生成对象的访问。使用工厂方法来限制实例化过程。这个方法应该是静态方法(类方法),因为让类的实例去生成另一个唯一实例毫无意义。
二、懒汉与饿汉:
1、懒汉方式:指全局的单例实例在第一次被使用时构建。
2、饿汉方式:指全局的单例实例在类装载时构建。
三、单例模式的三要点:
1、某个类只能有一个实例。
2、它必须自行创建这个实例。
3、它必须自行向整个系统提供这个实例。
四、优缺点:
1、优点:
①实例控制:单例模式会阻止其他对象实例化其自己的单例对象的副本,从而确保所有对象都访问唯一实例。
②灵活性:因为类控制了实例化过程,所以类可以灵活更改实例化过程。
2、缺点:
①开销:虽然数量很少,但如果每次对象请求引用时都要检查是否存在类的实例,将仍然需要一些开销。可以通过使用静态初始化解决此问题。
②可能的开发混淆:使用单例对象(尤其在类库中定义的对象)时,开发人员必须记住自己不能使用new关键字实例化对象。因为可能无法访问库源代码,因此应用程序开发人员可能会意外发现自己无法直接实例化此类。
③对象生存期:不能解决删除单个对象的问题。在提供内存管理的语言中(例如基于.NET Framework的语言),只有单例类能够导致实例被取消分配,因为它包含对该实例的私有引用。在某些语言中(如 C++),其他类可以删除对象实例,但这样会导致单例类中出现悬浮引用。
参考资料:百度百科单列模式
单例模式代码怎么写?
单例模式(Singleton) ,属于最常见的设计模式之一java单例模式代码,大部分系统都会用到java单例模式代码,目的是为了维护系统中唯一的一个实例。
可分为eager模式java单例模式代码,示例代码如下:
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单例模式怎么创建对象
1. 说明
1)单例模式:确保一个类只有一个实例java单例模式代码,自行实例化并向系统提供这个实例
2)单例模式分类:饿单例模式(类加载时实例化一个对象给自己java单例模式代码的引用)java单例模式代码,懒单例模式(调用取得实例的方法如getInstance时才会实例化对象)(java中饿单例模式性能优于懒单例模式,c++中一般使用懒单例模式)
3)单例模式要素:
a)私有构造方法
b)私有静态引用指向自己实例
c)以自己实例为返回值的公有静态方法
2.实例
饿单例模式:
复制代码代码如下:
package com.wish.modedesign;
public class HungrySingleton {
private static HungrySingleton instance = new HungrySingleton();
private HungrySingleton(){
}
public static HungrySingleton getInstance(){
return instance;
}
JAVA单例模式有哪些?
一、懒汉式单例\x0d\x0a在类加载java单例模式代码的时候不创建单例实例。只有在第一次请求实例java单例模式代码的时候的时候创建,并且只在第一次创建后,以后不再创建该类的实例。\x0d\x0a \x0d\x0apublic class LazySingleton {\x0d\x0a /**\x0d\x0a * 私有静态对象,加载时候不做初始化\x0d\x0a */\x0d\x0a private static LazySingleton m_intance=null;\x0d\x0a /**\x0d\x0a * 私有构造方法,避免外部创建实例\x0d\x0a */\x0d\x0a private LazySingleton(){\x0d\x0a }\x0d\x0a /**\x0d\x0a * 静态工厂方法,返回此类的唯一实例. \x0d\x0a * 当发现实例没有初始化的时候,才初始化.\x0d\x0a */\x0d\x0a synchronized public static LazySingleton getInstance(){\x0d\x0a if(m_intance==null){\x0d\x0a m_intance=new LazySingleton();\x0d\x0a }\x0d\x0a return m_intance;\x0d\x0a }\x0d\x0a}\x0d\x0a\x0d\x0a二、饿汉式单例\x0d\x0a在类被加载的时候,唯一实例已经被创建。\x0d\x0a \x0d\x0apublic class EagerSingleton {\x0d\x0a /**\x0d\x0a * 私有的(private)唯一(static final)实例成员,在类加载的时候就创建好了单例对象\x0d\x0a */\x0d\x0a private static final EagerSingleton m_instance = new EagerSingleton();\x0d\x0a /**\x0d\x0a * 私有构造方法,避免外部创建实例\x0d\x0a */\x0d\x0a private EagerSingleton() {\x0d\x0a }\x0d\x0a /**\x0d\x0a * 静态工厂方法,返回此类的唯一实例.\x0d\x0a * @return EagerSingleton\x0d\x0a */\x0d\x0a public static EagerSingleton getInstance() {\x0d\x0a return m_instance;\x0d\x0a }\x0d\x0a}\x0d\x0a \x0d\x0a************************************************************************************** 懒汉方式,指全局的单例实例在第一次被使用时构建; \x0d\x0a饿汉方式,指全局的单例实例在类装载时构建 \x0d\x0a**************************************************************************************\x0d\x0a\x0d\x0a三、登记式单例\x0d\x0a这个单例实际上维护的是一组单例类的实例,将这些实例存放在一个Map(登记薄)中,对于已经登记过的实例,则从工厂直接返回,对于没有登记的,则先登记,而后返回。\x0d\x0apublic class RegSingleton {\x0d\x0a /**\x0d\x0a * 登记薄,用来存放所有登记的实例\x0d\x0a */\x0d\x0a private static Map m_registry = new HashMap();\x0d\x0a //在类加载的时候添加一个实例到登记薄\x0d\x0a static {\x0d\x0a RegSingleton x = new RegSingleton();\x0d\x0a m_registry.put(x.getClass().getName(), x);\x0d\x0a }\x0d\x0a /**\x0d\x0a * 受保护的默认构造方法\x0d\x0a */\x0d\x0a protected RegSingleton() {\x0d\x0a }\x0d\x0a /**\x0d\x0a * 静态工厂方法,返回指定登记对象的唯一实例;\x0d\x0a * 对于已登记的直接取出返回,对于还未登记的,先登记,然后取出返回\x0d\x0a * @param name\x0d\x0a * @return RegSingleton\x0d\x0a */\x0d\x0a public static RegSingleton getInstance(String name) {\x0d\x0a if (name == null) {\x0d\x0a name = "RegSingleton";\x0d\x0a }\x0d\x0a if (m_registry.get(name) == null) {\x0d\x0a try {\x0d\x0a m_registry.put(name, (RegSingleton) Class.forName(name).newInstance());\x0d\x0a } catch (InstantiationException e) {\x0d\x0a e.printStackTrace();\x0d\x0a } catch (IllegalAccessException e) {\x0d\x0a e.printStackTrace();\x0d\x0a } catch (ClassNotFoundException e) {\x0d\x0a e.printStackTrace();\x0d\x0a }\x0d\x0a }\x0d\x0a return m_registry.get(name);\x0d\x0a }\x0d\x0a /**\x0d\x0a * 一个示意性的商业方法\x0d\x0a * @return String\x0d\x0a */\x0d\x0a public String about() {\x0d\x0a return "Hello,I am RegSingleton!";\x0d\x0a }\x0d\x0a}
JAVA static 单例模式
单例模式可以理解为是面向对象语言中对全局变量的一种实现,当然的作用不仅仅限于此。我们可以对单例模式实现的过程中的思路进行一下剖析,如此更加清楚的认识到设计模式究竟是什么,当然也可以证明一下基础知识的重要性(基础才是王道)。
首先我们分析一下单例的意义,在Java中为一个类只能有一个实例化对象。这显然不是我们平常所写的一个普通类所能够做到的事情。那么为了实现这一个要求该如何去做呢。实例化是一个类的初始化时候的问题,而初始化是构造方法去做的事情(当然这里面jvm也帮我们做了很多的事情)。构造方法,我们要设为私有。这样我们让该类不能被随意的初始化,那该在哪初始化,而它有怎样被调用呢。
一个不能初始化的类,也就是说不能够被实例化的类,我们想要调用。那么无疑让我们想到了static关键字,一个public static 的方法可以实现我们这个要求——即在不实例化类的情况下能够调用其中的方法。于是我们写下了一个public static 的方法,用于得到这个类的唯一实例。而这个实例我们是在类的内部实例,并同样定义为 static 的变量(一直用static 只是为了能够不实例化便可以使用。因为static可以在类初始化的时候便生成了,对于此不理解的同学们可以查看我的前一篇博客。。。)。到这里我们一个单例模式的实现框架其实已经搭好了。
关于java单例模式代码和java单例模式代码实现的介绍到此就结束了,不知道你从中找到你需要的信息了吗 ?如果你还想了解更多这方面的信息,记得收藏关注本站。