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();
}
}