static

首先一个问题：

什么是实例变量？局部变量？类变量？final变量？

实例变量：变量时对象所有，每当实例化一个对象时，会创建一个副本并初始化，如果没有显示初始化，会有一个默认值，各个对象的实例变量互不影响。

局部变量：在方法中定义的变量，在使用前必须初始化。

类变量：用static 修饰的变量，变量归类所有，只要类被加载，这个变量就可以被使用（类名.变量名），所有实例化的对象共享类变量。

static 主要有四种使用情况：成员变量，成员方法，代码块，内部类

（1）成员变量

加static修饰的静态变量和不用static修饰的实例变量，静态变量属于类，在内存中只有一份

可用（类.静态变量）和（对象.静态变量）引用

非static只可用（对象.静态变量）引用

import static java.lang.System.out;

import java.util.Random;

class Test {
	int i = 1;
}

public class FinalData {
	static Random rand = new Random();
	private final int VALUE_1 = 9;
	private static final int VALUE_2 = 10;
	private final Test test = new Test();
	private Test test2 = new Test();
	private final static int[] a = { 1, 2, 3, 4, 5, 6 };
	private final int i4 = rand.nextInt(20);
	private static final int i5 = rand.nextInt(20);

	public String toString() {
		return i4 + "" + i5 + "";
	}

	public static void main(String[] args) {
		FinalData data = new FinalData();
		out.println(data.VALUE_1);// 9
		out.println(VALUE_2);// 10
		// data.test = new Test();//不能重新赋值
		// data.VALUE_2++;//不能重新赋值
		data.test2 = new Test();
		out.println(data.test2.i);// 1
		for (int i = 0; i < a.length; i++) {
			a[i] = 9;
			out.print(a[i] + " ");// 9 9 9 9 9 9
		}
		out.println(data);// 718
		out.println(data.i4);// 7
		out.println(i5);// 18
		out.println(new FinalData());// 718
	}
}



（2）成员方法

static方法是类的方法，非static方法是对象的方法。

可用（类.成员方法）和（对象.成员方法）引用

非static只可用（对象.成员方法）引用

static一个重要的用途是实现单例模式

public class Singleton {
	private static Singleton instance = null;

	private Singleton() {
	};

	public static Singleton getInstance() {
		if (instance == null) {
			instance = new Singleton();
		}
		return instance;
	}
}

（3）static代码块

（4）static内部类

package com.www.DP;

public class Test {
	public static int a = 0;

	static {
		a = 10;
		System.out.println("父类的静态代码块在执行a=" + a);
	}

	{
		a = 8;
		System.out.println("父类的非静态代码块在执行a=" + a);
	}

	public Test() {
		this("a在父类带参构造方法中的值：" + Test.a); // 调用另外一个构造方法
		System.out.println(a);
		System.out.println("父类无参构造方法在执行a=" + a);
	}

	public Test(String n) {
		System.out.println(n);
		System.out.println(a);

	}

	public static void main(String[] args) {
		Test tsc = null;
		System.out.println("!!!!!!!!!!!!!!!!!!!!!");
		tsc = new Test();
	}
}

输出：

父类的静态代码块在执行a=10
!!!!!!!!!!!!!!!!!!!!!
父类的非静态代码块在执行a=8
a在父类带参构造方法中的值：10
8
8
父类无参构造方法在执行a=8