单例设计模型:

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

从上面执行结果,可以反映出:

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

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

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

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