单例设计模型：

static修饰符：

①：static静态只有一份(同一个虚拟机中) (节省资源)，类代码被装载内存时，静态代码分配内存，并执行，并且常驻内存。

可参考：类加载顺序

②：Static修饰成员变量，成为"类变量",属于整个类，类的共享变量。注：不能修饰局部变量。

         static是一块为整个类共有一块存储区域，静态变量只有一份，值变化后，所有访问值变化生效。

         java中用类名调用static变量和方法(对象调用也可以)：类名.变量(方法名)

③：static修饰类方法，属于类方法,继承中子类可以定义相同方法，静态不支持覆盖，此时不存在继承间的多态。

④：static静态块(定义和方法平行)，在类加载时执行一次，以后不再执行，一般用于初始化静态成员。

④：类的方法继承与否取决于4大访问修饰符，和static修饰符无关（static不会发生继承多态）。

        注：main()主方法定义成static，是因为加载类代码入内存的时候还没有对象这个概念。

类A：

package ca.singleton;

public class A {
	//static属性
	public static int a = 5;
	//实例变量
	public int b = 3;
	public static String c;
	//静态块
	static{
		c="initial c field";
	}
	//静态方法
	public static void print(){
		System.out.println("A static print method");
	}
	//实例方法
	public void display(){
		System.out.println("A instance display method");
	}
}

类B继承A：

package ca.singleton;

public class B extends A{
	//static属性
	public static int a = 2;
	//实例变量
	public int b = 8;
	public static String c;
	//静态块
	static{
		c="initial xxxxx";
	}
	//静态方法
	public static void print(){
		System.out.println("B static print method");
	}
	//实例方法
	public void display(){
		System.out.println("B instance display method");
	}
	public static void main(String[] args) {
		B b = new B();
		A a = new B();
		//call static print method
		b.print();
		a.print();
		//call instance display method
		b.display();
		a.display();
		//field static
		System.out.println(b.a);
		System.out.println(a.a);
		//field instance
		System.out.println(b.b);
		System.out.println(a.b);
		//static block
		System.out.println(b.c);
		System.out.println(a.c);
	}
}

输出结果为：

B static print method
A static print method
B instance display method
B instance display method
2
5
8
3
initial xxxxx
initial c field

static继承：

从上面执行结果，可以反映出：

①：静态属于所有它的类，不会被继承。

②：类的继承层次模型下的多态只发生在方法(成员方法)上。

③：类的成员属性，以及静态变量，静态方法，静态块，都不发生继承。

Singleton模型：
Static通常用于单例设计，Singleton是一种设计模式，高于语法，可以保证一个类在整个系统中(同一个虚拟机中)仅有一个对象。

在计算机系统中，线程池、缓存、日志对象、对话框、打印机、显卡的驱动程序对象常被设计成单例,具有资源管理器功能。

单例类原则:  ①只有一个实例对象;  ②自己创建自己的这一个对象;  ③通过方法提供仅有的对象给其他对象使用。

                  综之:  单例模式确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例。

实现的三种方式：

1:饿汉式单例

package ca.singleton;
/**
 * 饿汉式单例类
 * 单例类被第一次装载入内存时候，已经产生了单例对象
 * */
public class SingletonA {
	//在类初始化时(装载类时,非new),单例对象，已经被初始化
	private static SingletonA instance = new SingletonA();
	//默认构造方法为私有，防止其他地方实例化
	private SingletonA(){}
	//静态工厂方法，对外提供获取单例对象的获取接口
	/**
	 * 获取SingletonA类的单例对象
	 * */
	public static SingletonA getInstance(){
		return instance;
	}
}

2：懒汉式单例类

package ca.singleton;
/**
 * 懒汉式单例类
 * 延迟(懒)加载，在第一次调用getInstance()方法获取单例对象的时候创建单例对象
 * */
public class SingletonB {
	//其他类第一次获取单例对象时候创建
	private static SingletonB instance = null;
	//默认构造方法为私有，防止其他地方实例化
	private SingletonB(){}
	//静态工厂方法，对外提供获取单例对象的获取接口
	/**
	 * 获取SingletonB类的单例对象
	 * */
	public synchronized static SingletonB getInstance(){
		if(instance == null){
			instance = new SingletonB();
		}
		 return instance;
	}
}

3：登记式单例类

package ca.singleton;

import java.util.HashMap;
import java.util.Map;

/**
 * 登记式单例类
 * 使用类名注册，下次直接从里面获取
 * */
public class SingletonC {
	//登记类，键值对（类名- 类对象）保存map   ?if SingletonC = Object
	private static Map<String, SingletonC> map = new HashMap<String, SingletonC>();
	//提供protected的默认构造方法, 同包或子类可见
	protected SingletonC() {}
	//注册当前类的对象到map
	static{
		SingletonC scInstance = new SingletonC();
		map.put(scInstance.getClass().getName(), scInstance);
	}
	/**
	 * 静态工厂方法，返回类在map中被登记的唯一实例
	 * */
	public static SingletonC getInstance(String name){
		//name输入为空，使用当前类名称
		if(name == null){
			name = SingletonC.class.getName();
			System.out.println("name is null,name to "+name);
		}
		//name类名对应的对象未被登记到map
		if(map.get(name) == null){
			try {
				map.put(name,(SingletonC) Class.forName(name).newInstance());
			} catch (InstantiationException e) {
				System.out.println("Instantiation Exception"+e);
			} catch (IllegalAccessException e) {
				System.out.println("Illegal Access Exception"+e);
			} catch (ClassNotFoundException e) {
				System.out.println("Class Not Found Exception"+e);
			}
		}
		return map.get(name);
	}
	//一个示意性的商业方法???
	public String about(){
		return "Hello,I am a schematic of the commercial method";
	}
}

singletonD继承singletonC：

package ca.singleton;

public class SingletonD extends SingletonC{
	
}

测试类：

package ca.singleton;

public class SingleTest extends A {
	public static void main(String[] args) {
		//
		SingletonA s1 = SingletonA.getInstance();
		SingletonA s2 = SingletonA.getInstance();
		String ss = s1==s2 ? "1&2 T" : "1&2 F";
		System.out.println(ss); 
		//
		SingletonB s3 = SingletonB.getInstance();
		SingletonB s4 = SingletonB.getInstance();
		System.out.println(s3==s4 ? "3&4 T" : "3&4 F"); 
		//
		SingletonC s5 = SingletonC.getInstance(null);
		SingletonC s6 = SingletonC.getInstance(null);
		System.out.println(s5==s6 ? "5&6 T" : "5&6 F");
		System.out.println(s5.about());
		
		SingletonD s7 = (SingletonD) SingletonC.getInstance("ca.singleton.SingletonD");
		SingletonD s8 = (SingletonD) SingletonC.getInstance("ca.singleton.SingletonD");
		System.out.println(s7==s8 ? "7&8 T" : "7&8 F");
		System.out.println(s7.about());
		System.out.println(s5==s7 ? "5&7 T" : "5&7 F");
	}
}

输出结果为:

1&2 T
3&4 T
name is null,name to ca.singleton.SingletonC
name is null,name to ca.singleton.SingletonC
5&6 T
Hello,I am a schematic of the commercial method
7&8 T
Hello,I am a schematic of the commercial method
5&7 F

从上面执行结果，可以反映出：

使用“==”比较，基本类型，引用存储空间直接存储的真实值，所以比较的值；

对于其他类类型，在任何时候“==”比较的都是地址，这种比较永远不会被覆盖。

可以看出上边的单例都存在一个对象。

如果想让高并发下多线程在单例中生效，就要保证单例对象操作的方法为线程同步(对象锁)。