java单例模式？？？

Question

求一个java单例模式，要完整的，面试时可能会用到？？在单例模式中是不是一定要重写clone()方法呀？
在线等啊??
最好可以分享一下大家面试java的经验

Answer 1

http://freish.iteye.com/admin/blogs/1008304单例是不需要继承Cloneable接口

Answer 2

private static XXX x = null;
public XXX getXXX() {
   if (null == x) {
       x = new XXX();
   }
   return x;
}

Answer 3

摘抄自<研磨设计模式>单例模式示例代码        在Java中，单例模式的实现又分为两种，一种称为懒汉式，一种称为饿汉式，其实就是在具体创建对象实例的处理上，有不同的实现方式。下面分别来看这两种实现方式的代码示例。为何这么写，具体的在后面再讲述。
       （1）懒汉式实现，示例代码如下：Java代码  
1./**  
2. * 懒汉式单例实现的示例  
3. */  
4.public class Singleton {   
5.    /**  
6.     * 定义一个变量来存储创建好的类实例  
7.     */  
8.    private static Singleton uniqueInstance = null;   
9.    /**  
10.     * 私有化构造方法，好在内部控制创建实例的数目  
11.     */  
12.    private Singleton(){   
13.        //   
14.    }   
15.    /**  
16.     * 定义一个方法来为客户端提供类实例  
17.     * @return 一个Singleton的实例  
18.     */  
19.    public static synchronized Singleton getInstance(){   
20.        //判断存储实例的变量是否有值   
21.        if(uniqueInstance == null){   
22.            //如果没有，就创建一个类实例，并把值赋值给存储类实例的变量   
23.            uniqueInstance = new Singleton();   
24.        }   
25.        //如果有值，那就直接使用   
26.        return uniqueInstance;   
27.    }   
28.    /**  
29.     * 示意方法，单例可以有自己的操作  
30.     */  
31.    public void singletonOperation(){   
32.        //功能处理   
33.    }   
34.    /**  
35.     * 示意属性，单例可以有自己的属性  
36.     */  
37.    private String singletonData;   
38.    /**  
39.     * 示意方法，让外部通过这些方法来访问属性的值  
40.     * @return 属性的值  
41.     */  
42.    public String getSingletonData(){   
43.        return singletonData;   
44.    }   
45.}  
/**
 * 懒汉式单例实现的示例
 */
public class Singleton {
/**
 * 定义一个变量来存储创建好的类实例
 */
private static Singleton uniqueInstance = null;
/**
 * 私有化构造方法，好在内部控制创建实例的数目
 */
private Singleton(){
//
}
/**
 * 定义一个方法来为客户端提供类实例
 * @return 一个Singleton的实例
 */
public static synchronized Singleton getInstance(){
//判断存储实例的变量是否有值
if(uniqueInstance == null){
//如果没有，就创建一个类实例，并把值赋值给存储类实例的变量
uniqueInstance = new Singleton();
}
//如果有值，那就直接使用
return uniqueInstance;
}
/**
 * 示意方法，单例可以有自己的操作
 */
public void singletonOperation(){
//功能处理
}
/**
 * 示意属性，单例可以有自己的属性
 */
private String singletonData;
/**
 * 示意方法，让外部通过这些方法来访问属性的值
 * @return 属性的值
 */
public String getSingletonData(){
return singletonData;
}
}
  （2）饿汉式实现，示例代码如下：Java代码  
1./**  
2. * 饿汉式单例实现的示例  
3. */  
4.public class Singleton {   
5.    /**  
6.     * 定义一个变量来存储创建好的类实例，直接在这里创建类实例，只会创建一次  
7.     */  
8.    private static Singleton uniqueInstance = new Singleton();   
9.    /**  
10.     * 私有化构造方法，好在内部控制创建实例的数目  
11.     */  
12.    private Singleton(){   
13.        //   
14.    }   
15.    /**  
16.     * 定义一个方法来为客户端提供类实例  
17.     * @return 一个Singleton的实例  
18.     */  
19.    public static Singleton getInstance(){   
20.        //直接使用已经创建好的实例   
21.        return uniqueInstance;   
22.    }   
23.       
24.    /**  
25.     * 示意方法，单例可以有自己的操作  
26.     */  
27.    public void singletonOperation(){   
28.        //功能处理   
29.    }   
30.    /**  
31.     * 示意属性，单例可以有自己的属性  
32.     */  
33.    private String singletonData;   
34.    /**  
35.     * 示意方法，让外部通过这些方法来访问属性的值  
36.     * @return 属性的值  
37.     */  
38.    public String getSingletonData(){   
39.        return singletonData;   
40.    }   
41.}  
/**
 * 饿汉式单例实现的示例
 */
public class Singleton {
/**
 * 定义一个变量来存储创建好的类实例，直接在这里创建类实例，只会创建一次
 */
private static Singleton uniqueInstance = new Singleton();
/**
 * 私有化构造方法，好在内部控制创建实例的数目
 */
private Singleton(){
//
}
/**
 * 定义一个方法来为客户端提供类实例
 * @return 一个Singleton的实例
 */
public static Singleton getInstance(){
//直接使用已经创建好的实例
return uniqueInstance;
}

/**
 * 示意方法，单例可以有自己的操作
 */
public void singletonOperation(){
//功能处理
}
/**
 * 示意属性，单例可以有自己的属性
 */
private String singletonData;
/**
 * 示意方法，让外部通过这些方法来访问属性的值
 * @return 属性的值
 */
public String getSingletonData(){
return singletonData;
}
}
 
摘抄自<研磨设计模式>

Answer 4

public class Singleton {
public String name;
public int age; private Singleton(){
System.out.println("当前线程 "+Thread.currentThread().getName()+" 对象是 "+this.toString());
}

public static Singleton getInstance(){
return SingletonHolder.getInstance();
}

private static class SingletonHolder{
private static final Singleton instance = new Singleton();
public static Singleton getInstance(){
return instance;
}
} public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}

Answer 5

单例模式就是保存只有一个实例，为的是不出现混乱，你可以这样public TestClass test;
public static synchronized simp (
      //判断是否已存在
     if(test != null)
       {
         return test;
        }
      test = new TestClass();
      return test;
    
)

Answer 6

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

Answer 7

4L，6L的方法不太好，synchronized方法，容易造成堵塞，影响性能
7L的要把getInstance声明为static方法，这个是一般做法
5L的通过系统类加载器保证线程安全，可以滞后生成实例，省资源

Answer 8

1.提供一个私有的静态的该类成员。
2.提供一个私有的构造方法，主体为空。（只让本类new）
3.提供一个公有的静态的获得该实例的方法。饱汉和恶汉说的是静态成员变量是不是在定义的时候就new了。

Answer 9

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

Answer 10

private static XXX x = null;
public XXX getXXX() {
if (null == x) {
x = new XXX();
}
return x;
}不错，理解喽！~~