单例设计模型：
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
从上面执行结果，可以反映出：
使用“==”比较，基本类型，引用存储空间直接存储的真实值，所以比较的值；
对于其他类类型，在任何时候“==”比较的都是地址，这种比较永远不会被覆盖。
可以看出上边的单例都存在一个对象。
如果想让高并发下多线程在单例中生效，就要保证单例对象操作的方法为线程同步(对象锁)。
