Java单例模式实现

Java单例模式实现

单例模式：

Q1：什么是单例模式呢？

A1：单例模式确保某个类只有一个实例，大家想用这个类的对象的时候，只能拿到一个共同的实例。单例类要自行创建实例。

Q2：为什么要用到单例模式？

A2：如果有一个复杂的类，我们总要使用它的对象，那我们岂不是总要new这个对象，这样，会消耗我们的内存，所以我们要选用单例模式。

 

下面通过一个简单的例子说明单例模式的实现方法：

//普通的类，通过new来创建新的对象，每次创建都会得到不同的实例。
public class SingletonDemo1{
  //构造方法
  public SingletonDemo1(){}

  //普通方法
  public void singleLove(){
    System.out.println("Persist for you!");
  }
}

 

 

//使用第一种方式的单例模式类，通过公共属性来创建对象
public class SingletonDemo2{
  //第一种实现单例模式的方法，通过公共属性来实现实例化
 //声明一个公共的静态属性，使只被实例化一次
  public static final SingletonDemo2 singletonDemo = new SingletonDemo2();

  //声明一个私有的构造方法，使别人不能随便new对象
  private SingletonDemo2(){}

  //普通的方法
  public void singleLove(){
    System.out.println("Always persist for you!");
  }
}

 

 

//使用第二种方式的单例模式类，通过.getInstance()来创建对象
public class SingletonDemo3{
  //第二种实现单例模式的方法，通过方法来实现实例化
 //声明一个私有的静态属性，使只被实例化一次
  private static final SingletonDemo3 singletonDemo = new SingletonDemo3();

  //声明一个私有的构造方法，使别人不能随便new对象
  //它只被调用一次，实例存在之后就不再调用了
  private SingletonDemo3(){}

  //声明一个公共的静态方法，外界通过调用这个方法来得到唯一的实例
  public static SingletonDemo3 getInstance(){
     return singletonDemo;
  }
 
  //普通的方法
  public void singleLove(){
    System.out.println("Persist for you always!");
  }
}

 

 

public class Test{

 //测试方法
 public static void main(String[] args){

    //测试1
    SingletonDemo1 singleton11 = new SingletonDemo1();
    singleton11.singleLove();
 
    SingletonDemo1 singleton12 = new SingletonDemo1();
    singleton12.singleLove();
 
    boolean flag = singleton11.equals(singleton12);
    System.out.println("用equals的方法来判断"); 
    System.out.println("此时的flag=" + flag);
  
    if(flag){  
      System.out.println("他们的内存地址是一样的哦,这说明他们是同一个实例，实现了单例模式！");
    }else{
      System.out.println("他们的内存地址不一样，则说明他们是不同的实例");
    }
 
 

    //测试2
    SingletonDemo2 singleton21 = SingletonDemo2.singletonDemo;
    singleton21.singleLove();
 
    SingletonDemo2 singleton22 = SingletonDemo2.singletonDemo;
    singleton22.singleLove();
 
    int addr1 = singleton21.hashCode();
    int addr2 = singleton22.hashCode();
    System.out.println("用hashCode来判断");
    if(addr1 == addr2){
      System.out.println("内存地址是一样的哦，则说明他们是同一个实例，实现了单例模式");
    }else{
      System.out.println("他们的内存地址不一样，则说明他们是不同的实例");
    }
 


    //测试3
    SingletonDemo3 single31 = SingletonDemo3.getInstance();
    single31.singleLove();
 
    SingletonDemo3 single32 = SingletonDemo3.getInstance();
    single32.singleLove();
 
    boolean flag3 = single31.equals(single32);
    System.out.println("用equals来判断");
    System.out.println("此时的flag=" + flag3);
  
    if(flag3){
      System.out.println("内存地址是一样的哦，则说明他们是同一个实例，实现了单例模式");
    }else{
      System.out.println("他们的内存地址不一样，则说明他们是不同的实例");
    }
  }
}

 

说明：根据个人使用经验，推荐使用方法三。

 

根据网友评论，在此给出枚举类型的单例模式。

public enum SingletonTest {
    himself; //定义一个枚举的元素，就代表SingletonTest的一个实例
    private String anotherField;

    SingletonTest() {
        //SingletonTest诞生要做的事情
        //这个方法也可以去掉。将构造时候需要做的事情放在instance赋值的时候：
        /** himself = SingletonTest() {
          *      //SingletonTest诞生要做的事情
          * }
          **/
    }

    public void test() {
        System.out.println(“这是一个测试");
    }
 }
 

Call：SingletonTest.himself.test();

 

 现在给出一个更好的单例模式

public class SingletonTest {
    public static void main(String[] args) {
        //创建Singleton对象不能通过构造器，
        //只能通过getInstance方法来得到实例
        Singleton s1 = Singleton.getInstance();
        Singleton s2 = Singleton.getInstance();

        //将输出true
        System.out.println(s1 == s2);
    }
}

class Singleton {
    //使用一个变量来缓存曾经创建的实例
    private static Singleton instance;

    //对构造器使用private修饰，隐藏该构造器
    private Singleton() {

    }

    //提供一个静态方法，用于返回Singleton实例
    //该方法可以加入自定义控制，保证只产生一个Singleton对象
    public static Singleton getInstance() {
        //如果instance为null，则表明还未曾创建Singleton对象
        //如果instance不为null，则表明已经创建了Singleton对象
        //将不会重新创建新的实例
        if( instance == null ) {
            //创建一个Singleton对象，将其缓存起来
            instance = new Singleton();
        }
        return instance;
    }
}