java的单例、static修饰符及static的继承

单例设计模型：

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 methodb.print();a.print();//call instance display methodb.display();a.display();//field staticSystem.out.println(b.a);System.out.println(a.a);//field instanceSystem.out.println(b.b);System.out.println(a.b);//static blockSystem.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 = Objectprivate static Map<String, SingletonC> map = new HashMap<String, SingletonC>();//提供protected的默认构造方法, 同包或子类可见protected SingletonC() {}//注册当前类的对象到mapstatic{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类名对应的对象未被登记到mapif(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

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

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

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

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

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