单例模式

package com.jdk7.chapter2.singleton;

public class SingletonA {
    //java虚拟机会加载静态变量
    private static int id = 1;
    private static SingletonA instance = new SingletonA();
    
    //私有构造函数，不被其他类调用创建类的对象
    private SingletonA(){}
    
    //同步获取id值，同一时刻只有一个线程进入该方法
    public synchronized int getId() {
        return id;
    }
    
    public synchronized int next(){
        return id++;
    }
    //在其他类中只能调用类名+getInstance方法获取类的对象
    public static SingletonA getInstance() {
        return instance;
    };
}

package com.jdk7.chapter2.singleton;

public class SingletonB {
    //java虚拟机会加载静态变量
    private static int id = 1;
    private static SingletonB instance = null;
    
    //私有构造函数，不被其他类调用创建类的对象
    private SingletonB(){}
    
    //同步获取id值，同一时刻只有一个线程进入该方法
    public synchronized int getId() {
        return id;
    }

    public synchronized int next(){
        return id++;
    }
    
    //只创建一次对象，提供给后面每次使用
    public static SingletonB getInstance() {
        if(instance==null){
            instance = new SingletonB();
        }
        return instance;
    }
}

package com.jdk7.chapter2.singleton;

public class SingleTest {
    public static void main(String[] args) {
        System.out.println("调用next方法前");
        SingletonA single1 = SingletonA.getInstance();
        SingletonA single2 = SingletonA.getInstance();
        System.out.println("single1: "+single1);
        System.out.println("single2: "+single2);
        System.out.println("single1: "+single1.getId());
        System.out.println("single2: "+single2.getId());
        single1.next();
        System.out.println("调用next方法后");
        System.out.println("single1: "+single1.getId());
        System.out.println("single2: "+single2.getId());
        
        SingletonB b1 = SingletonB.getInstance();
        SingletonB b2 = SingletonB.getInstance();
        System.out.println("调用next方法前");
        System.out.println("b1: "+b1);
        System.out.println("b2: "+b2);
        System.out.println("b1: "+b1.getId());
        System.out.println("b2: "+b2.getId());
        System.out.println("调用next方法后");
        b1.next();
        System.out.println("b1: "+b1.getId());
        System.out.println("b2: "+b2.getId());
    }
}

执行结果：
调用next方法前
single1: com.jdk7.chapter2.singleton.SingletonA@64b6be69
single2: com.jdk7.chapter2.singleton.SingletonA@64b6be69
single1: 1
single2: 1
调用next方法后
single1: 2
single2: 2
调用next方法前
b1: com.jdk7.chapter2.singleton.SingletonB@32728d
b2: com.jdk7.chapter2.singleton.SingletonB@32728d
b1: 1
b2: 1
调用next方法后
b1: 2
b2: 2

package com.jdk7.chapter5;

public class Single {
    //私有的静态对象
    private static Single Instance = new Single();
    
    //私有的无参构造函数,在该类中可以new对象，但是在其他类中不可以new对象，保证了对象的唯一性
    private Single(){}
    
    //仅对外开放Instance变量的getter方法
    public static Single getInstance() {
        return Instance;
    }
    
    public static void main(String[] args) {
        Single s = new Single();
        System.out.println("s.hashcode>"+s.hashCode());
        System.out.println(Single.getInstance());
        System.out.println(Single.getInstance());
    }
}

执行结果：
s.hashcode>672568948
com.jdk7.chapter5.Single@62efae3b
com.jdk7.chapter5.Single@62efae3b