黑马程序员_源自梦想 静态、工具类、单例设计模式

 -------  android培训 、 java培训 、期待与您交流！ ---------

静态：static是一个修饰符，用于修饰成员(成员变量，成员函数).
   用法：  
   a.类名.静态成员。
   b.对象.静态成员(一般不用，竟然属于类变量，就应该用类去调用，更形象些）
static特点：
1.随着类的加载而加载。
      也就说：静态会随着类的消失而消失。说明它的生命周期最长。
2.优先于的对象存在
      明确一点：静态是先存在。对象是后存在的。
3.被所有对象所共享(可以用来计算创建多少对象）。
4.因为是类变量，可以被类名直接所调用。

实例变量和类变量的区别：
1.存放位置:
类变量随着类的加载而存在于方法区中。
实例变量随着对象的建立而存在于堆内存中。
2.生命周期：
类变量生命周期最长，随着类的消失而消失。
实例变量生命周期随着对象的消失而消失。
静态使用注意事项：
1.静态方法只能访问静态成员。
非静态方法既可以访问静态也可以访问非静态。
2.静态方法中不可以定义this，super关键字。
因为静态优先于对象存在。所以静态方法中不可以出现this。
静态利弊
利：对对象的共享数据进行单独空间的存储，节省空间。没有必要每一个对象中都存储一份。
可以直接被类名调用。
弊：生命周期过长。
 访问出现局限性。(静态虽好，只能访问静态。)

class Person{
	private int age;
	private String name;
	private static int count;
	private static int count1;
	private int sum;
	public Person(){
		count++;
	}
	public static void fun(){
		System.out.println(++count1);
		//this.age = 2;出错，static优先于的对象存在
	}
	public void test(){
		fun();
		System.out.println(++sum+","+count);
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getSum() {
		return sum;
	}
	public void setSum(int sum) {
		this.sum = sum;
	}
	
}
public class PersonDemo1 {
	public static void main(String[] args) {
		
		Person p = new Person();
		Person p1 = new Person();
		Person p2 = new Person();
		System.out.println("*********************");
		p.test();
		p1.test();
		p2.test();
		System.out.println("*********************");
		Person.fun();
	}
}
//----------------结果集-----------------
*********************
1
1,3
2
1,3
3
1,3
*********************
4

四大代码块

 a.静态代码块。
格式：
static
{
静态代码块中的执行语句。
}

特点：随着类的加载而执行，只执行一次,并优先于主函数。
用于给类进行初始化的。
  b.普通代码块
{
}
  c.构造代码块
  d.同步代码块

//静态代码块是在类加载时自动执行的，非静态代码块是在创建对象时自动执行的代码，
//不创建对象不执行该类的非静态代码块。
//且执行 顺序为静态代码块------非静态代码块----构造函数。
class Student{
	static{
		System.out.println("Student类静态 --static");
	}
	public Student(){
		
		System.out.println("构造代码块");
	}
	{
		System.out.println("代码块");
	}
	public static void fun(){
		System.out.println("静态fun方法");
	}
	static{
		System.out.println("静态块2");
	}
}
public class PerDemo {
	public static void main(String[] args) {
		Student.fun();
		System.out.println("**************************");
		Student stu = new Student();
	}
}
//-------------结果集----------------
Student类静态 --static
静态块2
静态fun方法
**************************
代码块
构造代码块

静态的应用-->工具类。

每一个应用程序中都有共性的功能，可以将这些功能进行抽取，独立封装。以便复用。

虽然可以通过建立ArrayTool的对象使用这些工具方法，对数组进行操作。
发现了问题：
1.对象是用于封装数据的，可是 ArrayTool对象并未封装特有数据。
2.操作数组的每一个方法 都没有用到ArrayTool对象中的特有数据。

这时就考虑，让程序更严谨，是不需要对象的。
可以将ArrayTool中的方法都定义成static的。直接通过类名调用即可。

为了更为严谨，强制让该类 不能建立对象。可以通过将 构造函数私有化完成。

单例设计模式

//饿汉式（建议使用饿汉式）。没有线程安全问题且简单
//SingleMode类一进内存，就已经创建好了对象。

class SingletonMode {
	private static SingletonMode instance = new SingletonMode();
	private SingletonMode(){}
	public static SingletonMode getInstance(){
		return instance;
	}
}

/*懒汉式。(效率低）双重判断且加锁
 * 对象是方法被调用时，才初始化，也叫做对象的延时加载。
   LazySingletonMode类进内存，对象还没有存在，只有调用了getInstance方法时，才建立对象。
*/

class LazySingletonMode{
	private static LazySingletonMode instance ;
	private LazySingletonMode(){}
	public static LazySingletonMode getInstance(){
		if(instance==null)
		{
			synchronized(LazySingletonMode.class)
			{				
				if(instance==null)
					instance = new LazySingletonMode();
			}
		}
		return instance;

	}
}
public class SingletonDemo{
	public static void main(String[] args) {
		SingletonMode s1 = SingletonMode.getInstance();
		SingletonMode s2 = SingletonMode.getInstance();
		System.out.println(s1==s2);
		
	}
}