Java中的几种单例写法

一、饿汉式非线程安全

public class SingletonDemo1{
	private static SingletonDemo1 singleton = new SingletonDemo1();
	private SingletonDemo1(){
	}
	public static SingletonDemo1 getInstance(){
		return singleton;
}

二、懒汉式非线程安全

public class SingletonDemo2{
	private static SingletonDemo2 singleton;
	private SingletonDemo2(){
	}
	public static SingletonDemo2 getInstance(){
		if(singleton == null){
			sigleton = new SingletonDemo2();
		}
	}
}

三、线程安全且效率快，双重检查

public class SingletonDemo3{
	private static SingletonDemo3 singleton;
	private SingletonDemo3(){
	}
	public static SingletonDemo3 getInstance(){
		if(singleton == null){
			synchronized(SingletonDemo3.class){
				if(singleton == null){
					singleton = new SingletonDemo3();
				}
			}
	}
}

四、静态内部类方式

public class SingletonDemo4{
	private SingletonDemo4(){
	}
	private static class SingletonInstance{
		private static SingletonDemo4 singleton = new SingletonDemo4();
	}
	public static SingletonDemo4 getInstance(){
		return SingletonInstance.singleton;
	}
}

静态内部类一些特性介绍：
1.静态内部是在外部类首次加载的时候就已经存在的。
2.静态内部类只能访问外部类的静态变量。
3.外部类调用静态内部类的静态方法时无需创建对象。
4.若需调用静态内部类非静态方法时，需创建静态内部类对象。
5.创建静态内部类对象时，可直接通过外部类来创建。

public class StaticInternalClassDemo {
	private static int a = 10;
	private int c = 20;
	private static class InternalClass1{
		private static int a = 30;
		private int b = 40;
		//内部类静态方法
		private static void staticMethod(){
			System.out.println("内部类自身静态变量"+a);
			System.out.println("外部类静态变量"+StaticInternalClassDemo.a);
			//此处编译报错，静态内部类只能访问外部类静态成员
			//System.out.println(b);
		}
		//内部类非静态方法
		public void method(){
			System.out.println("内部类自身成员变量"+b);
			//此处编译报错，静态内部类只能访问外部类静态成员
			//System.out.println("外部类自身成员变量"+c);
		}
	}
	public static void main(String[] args) {
		//调用内部静态方法无需创建对象
		StaticInternalClassDemo.InternalClass1.staticMethod();
		//创建静态内部类对象
		InternalClass1 internal = new StaticInternalClassDemo.InternalClass1();
		internal.method();
	}
}

普通内部类一些特性介绍：
1.可访问外部类所有成员变量以及方法。
2.不可定义静态变量以及静态方法。
3.使用外部类来创建内部类对象时，需要先创建外部类对象。

public class InternalClassDemo {
	private static int a = 10;
	private int b = 20;
	private void outClassprint(){
		System.out.println("外部类方法");
	}
	private static void outClassStaticMethod(){
		System.out.println("外部类静态方法");
	}
	private class InternalClass{
		//此处编译报错，非静态内部类不允许定义静态变量
		//private static int c = 30;
		private int d = 40;
		
		private void print(){
			System.out.println("内部类成员变量:"+d);
			System.out.println("外部类静态成员变量:"+a);
			System.out.println("外部类成员变量:"+b);
			outClassprint();
			outClassStaticMethod();
		}
		//编译报错，不可定义静态方法
/*		private static void staticMethod(){
			
		}*/
	}
	public static void main(String[] args) {
		InternalClassDemo outClass = new InternalClassDemo();
		//通过外部类来创建内部类对象
		InternalClass internalClass = outClass.new InternalClass();
		internalClass.print();
	}
}

五、枚举方式

public enum SingletonDemo5 {
	INSTANCE;
	public SingletonDemo5 getInstance(){
		return INSTANCE;
	}
}