「java单例类的例子」java中单例

博主：adminadmin 2023-03-21 23:13:10 775

本篇文章给大家谈谈java单例类的例子，以及java中单例对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。

本文目录一览：

Java模式设计之单例模式（二）

在什么情况下使用单例模式

使用单例模式的条件

使用单例模式有一个很重要的必要条件

在一个系统要求一个类只有一个实例时才应当使用单例模式 反过来说 如果一个类可以有几个实例共存 那么就没有必要使用单例类 但是有经验的读者可能会看到很多不当地使用单例模式的例子 可见做到上面这一点并不容易 下面就是一些这样的情况

例子一

问 我的一个系统需要一些 全程 变量 学习了单例模式后 我发现可以使用一个单例类盛放所有的 全程 变量 请问这样做对吗？

答 这样做是违背单例模式的用意的 单例模式只应当在有真正的 单一实例 的需求时才可使用

一个设计得当的系统不应当有所谓的 全程 变量 这些变量应当放到它们所描述的实体所对应的类中去 将这些变量从它们所描述的实体类中抽出来 放到一个不相干的单例类中去 会使得这些变量产生错误的依赖关系和耦合关系

例子二

问 我的一个系统需要管理与数据库的连接 学习了单例模式后 我发现可以使用一个单例类包装一个Connection 对象 并在finalize（）方法中关闭这个Connection 对象 这样的话 在这个单例类的实例没有被人引用时 这个finalize（） 对象就会被调用 因此 Connection 对象就会被释放 这多妙啊

答 这样做是不恰当的 除非有单一实例的需求 不然不要使用单例模式 在这里Connection 对象可以同时有几个实例共存 不需要是单一实例

单例模式有很多的错误使用案例都与此例子相似 它们都是试图使用单例模式管理共享资源的生命周期 这是不恰当的

单例类的状态

有状态的单例类

一个单例类可以是有状态的（stateful） 一个有状态的单例对象一般也是可变（mutable） 单例对象

有状态的可变的单例对象常常当做状态库（repositary）使用 比如一个单例对象可以持有一个int 类型的属性 用来给一个系统提供一个数值惟一的序列号码 作为某个贩卖系统的账单号码 当然 一个单例类可以持有一个聚集 从而允许存储多个状态

没有状态的单例类

另一方面 单例类也可以是没有状态的（stateless） 仅用做提供工具性函数的对象 既然是为了提供工具性函数 也就没有必要创建多个实例 因此使用单例模式很合适 一个没有状态的单例类也就是不变（Immutable） 单例类 关于不变模式 读者可以参见本书的 不变（Immutable ）模式 一章

多个JVM 系统的分散式系统

EJB 容器有能力将一个EJB 的实例跨过几个JVM 调用 由于单例对象不是EJB 因此 单例类局限于某一个JVM 中 换言之 如果EJB 在跨过JVM 后仍然需要引用同一个单例类的话 这个单例类就会在数个JVM 中被实例化 造成多个单例对象的实例出现 一个J EE应用系统可能分布在数个JVM 中 这时候不一定需要EJB 就能造成多个单例类的实例出现在不同JVM 中的情况

如果这个单例类是没有状态的 那么就没有问题 因为没有状态的对象是没有区别的 但是如果这个单例类是有状态的 那么问题就来了 举例来说 如果一个单例对象可以持有一个int 类型的属性 用来给一个系统提供一个数值惟一的序列号码 作为某个贩卖系统的账单号码的话 用户会看到同一个号码出现好几次

在任何使用了EJB RMI 和JINI 技术的分散式系统中 应当避免使用有状态的单例模式

多个类加载器

同一个JVM 中会有多个类加载器 当两个类加载器同时加载同一个类时 会出现两个实例 在很多J EE 服务器允许同一个服务器内有几个Servlet 引擎时 每一个引擎都有独立的类加载器 经有不同的类加载器加载的对象之间是绝缘的

lishixinzhi/Article/program/Java/gj/201311/27644

java中怎么写一个单例的例子？

单例就是把构造方法私有化，在类里实例化对象，并且给一个共有的能返回这个对象的方法

public class Single{

private Single s = null;

private Single(){

}

public static synchronized Single getS(){

if (s == null) {

s = new Singleton();

}

return s;

}

}

如何实现单例模式？

这个模式保护类的创建过程来确保只有一个实例被创建，它通过设置类的构造方法为私有来达到这个目的。 要获得类的实例，单例类可以提供一个方法，如getInstance，来返回类的实例。该方法是唯一可以访问类来创建实例的方法。 下面是单例的一个例子：Java代码publicclassSingletonPattern{privatestaticSingletonPatterninstance;privateSingletonPattern(){}publicstatic synchronized SingletonPatterngetInstance(){if(instance==null){instance=newSingletonPattern();}returninstance;}} 当我们要实现单例的时候，有如下的规则需要遵循： 从上面的示例代码中可以看出，一个单例类有一个静态的属性来保存它唯一的实例 需要将类的构造方法设置为private。这样你不允许其他任何类来创建单例类的实例，因为它们不能访问单例类的构造方法。

java中哪些对象都是单例模式

下面列出一部分Java的单例类:

1)Runtime类

可以通过java.lang.Runtime#getRuntime()获取其实例

2)Desktop类

可以通过java.awt.Desktop#getDesktop()获取其实例

3)SecurityManager类,注意,虽然该类提供了公共无参构造函数,但其内部构造函数仍然以单例的模式在运行。可以说是单例的一种变形设计。

可以通过java.lang.System#getSecurityManager()获取其实例

JAVA单例模式有哪些？

一、懒汉式单例

在类加载的时候不创建单例实例。只有在第一次请求实例的时候的时候创建，并且只在第一次创建后，以后不再创建该类的实例。

public

class

LazySingleton

{

/**

*

私有静态对象,加载时候不做初始化

*/

private

static

LazySingleton

m_intance=null;

/**

*

私有构造方法,避免外部创建实例

*/

private

LazySingleton(){

}

/**

*

静态工厂方法,返回此类的唯一实例.

*

当发现实例没有初始化的时候,才初始化.

*/

synchronized

public

static

LazySingleton

getInstance(){

if(m_intance==null){

m_intance=new

LazySingleton();

}

return

m_intance;

}

}

二、饿汉式单例

在类被加载的时候，唯一实例已经被创建。

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（登记薄）中，对于已经登记过的实例，则从工厂直接返回，对于没有登记的，则先登记，而后返回。

public

class

RegSingleton

{

/**

*

登记薄,用来存放所有登记的实例

*/

private

static

Map

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!";

}

}

JAVA的单例模式到底有几种变现形式？请列举？

JAVA单例模式的几种实现方法

1.饿汉式单例类

package pattern.singleton;

//饿汉式单例类.在类初始化时，已经自行实例化

public class Singleton1 {

//私有的默认构造子

private Singleton1() {}

//已经自行实例化

private static final Singleton1 single = new Singleton1();

//静态工厂方法

public static Singleton1 getInstance() {

return single;

}

}

2.懒汉式单例类

package pattern.singleton;

//懒汉式单例类.在第一次调用的时候实例化

public class Singleton2 {

//私有的默认构造子

private Singleton2() {}

//注意，这里没有final

private static Singleton2 single;

//只实例化一次

static{

single = new Singleton2();

}

//静态工厂方法

public synchronized static Singleton2 getInstance() {

if (single == null) {

single = new Singleton2();

}

return single;

}

}

在上面给出懒汉式单例类实现里对静态工厂方法使用了同步化，以处理多线程环境。有些设计师在这里建议使用所谓的"双重检查成例".必须指出的是，"双重检查成例"不可以在Java 语言中使用。不十分熟悉的读者，可以看看后面给出的小节。 同样，由于构造子是私有的，因此，此类不能被继承。饿汉式单例类在自己被加载时就将自己实例化。即便加载器是静态的，在饿汉式单例类被加载时仍会将自己实例化。单从资源利用效率角度来讲，这个比懒汉式单例类稍差些。从速度和反应时间角度来讲，则比懒汉式单例类稍好些。然而，懒汉式单例类在实例化时，必须处

理好在多个线程同时首次引用此类时的访问限制问题，特别是当单例类作为资源控制器，在实例化时必然涉及资源初始化，而资源初始化很有可能耗费时间。这意味着出现多线程同时首次引用此类的机率变得较大。

饿汉式单例类可以在Java 语言内实现， 但不易在C++ 内实现，因为静态初始化在C++ 里没有固定的顺序，因而静态的m_instance 变量的初始化与类的加载顺序没有保证，可能会出问题。这就是为什么GoF 在提出单例类的概念时，举的例子是懒汉式的。他们的书影响之大，以致Java 语言中单例类的例子也大多是懒汉式的。实际上，本书认为饿汉式单例类更符合Java 语言本身的特点。

3.登记式单例类.

package pattern.singleton;

import java.util.HashMap;

import java.util.Map;

//登记式单例类.

//类似Spring里面的方法，将类名注册，下次从里面直接获取。

public class Singleton3 {

private static MapString,Singleton3 map = new HashMapString,Singleton3();

static{

Singleton3 single = new Singleton3();

map.put(single.getClass().getName(), single);

}

//保护的默认构造子

protected Singleton3(){}

//静态工厂方法,返还此类惟一的实例

public static Singleton3 getInstance(String name) {

if(name == null) {

name = Singleton3.class.getName();

System.out.println("name == null"+"---name="+name);

}

if(map.get(name) == null) {

try {

map.put(name, (Singleton3) Class.forName(name).newInstance());

} catch (InstantiationException e) {

e.printStackTrace();

} catch (IllegalAccessException e) {

e.printStackTrace();

} catch (ClassNotFoundException e) {

e.printStackTrace();

}

}

return map.get(name);

}

//一个示意性的商业方法

public String about() {

return "Hello, I am RegSingleton.";

}

public static void main(String[] args) {

Singleton3 single3 = Singleton3.getInstance(null);

System.out.println(single3.about());

}

}

关于java单例类的例子和java中单例的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。

标签：