static和final关键字

static和final是Java中最常用的关键字，本文介绍它们的所有用法以及含义。

static通常用来修饰类的成员变量和类的方法，它可以用在以下场合：

1.修饰类的成员变量：意味着这个成员变量作为整个类而不是类的某个特定对象而存在，可以通过类名直接引用它们。一个static成员变量对每个类来说都只有一份存储空间，而非static成员变量则是对每个对象有一份存储空间。
2.修饰方法：static方法可以通过类名直接访问。
3.静态导入：静态导入static成员变量和static方法。
4.静态程序块：通常用来做一些初始化，static{}。
5.修饰成员类型：如修饰嵌套类（nested class），嵌套类和普通的内部类的区别就在于static的修饰。普通的内部类不能包含static数据和static属性，也不能包含嵌套类，但是嵌套类可以包含所有东西。注意static不能用来修饰最顶层的类。

下面的代码显示了static的可用之处和不可用之处：

//导入静态成员，不常用 import static java.util.Calendar.AM; import java.util.HashMap; public class StaticTest { //静态成员变量，它只存有一份 private static int i = 123; private int j = 0; private static HashMap map = new HashMap(); //静态程序块，用来做一些初始化动作 static { map.put("userid", "admin"); } public void printI() { System.out.println("i=" + i); } //静态方法， public static void s() { int m = 0;//可以定义非静态变量 staticint n = 0;//错误代码，不能定义静态变量 System.out.println(i);//可以使用静态的成员变量 System.out.println(j);//错误代码，不能使用非静态的成员变量 } public static void main(String[] args) { //直接通过类引用静态成员变量和方法 StaticTest.s(); StaticTest.i++; //test1和test2打印出来的i值一样，因为它只有一份 StaticTest test1 = new StaticTest(); StaticTest test2 = new StaticTest(); test1.printI();//i=124 test2.printI();//i=124 } }

下面的代码显示了static修饰嵌套类：

public class StaticTest2 { //普通内部类 class InnerClass { static int i = 0;//错误代码，普通内部类不能使用静态成员变量 static final int j = 0;//正确代码，常量 } //嵌套类，与普通内部类的区别在于多了static的修饰 static class NestedClass { static int i = 0;//正确代码 } }

final关键字通常表示一个东西是不能改变的，它可以修饰的元素有：

1.修饰数据：通常用来定义常量。对于基本类型，final使数值恒定不变，而对于对象引用，final使引用恒定不变，一旦引用被初始化指向一个对象，就无法把它改为指向另一个对象，然而，对象其本身是可以被修改的。

2.修饰参数：和修饰数据一样。

3.修饰方法：通常用来防止方法被子类覆盖（overriden），一个类中的所有private方法都隐含是final的，因为它无法被子类读取，也就不会被覆盖。另外，编译器针对final方法的调用都采用内嵌（inline）调用，可提高效率，但不是final的主要用途。

4.修饰类：表明该类（class）不能被继承。在final类里，所有的方法都被隐含的指定为final的，因为永远不存在子类，也就不存在子类覆盖一说。final类的字段可以根据个人的意愿选择是或不是final，不论类是否定义为final，相同的规则都适用于final字段。

平日在编程中用的最多的应该是使用final修饰数据，尤其是定义常量。

下面的代码显示了final对各种元素的修饰：

//修饰类，类不能被继承 public final class FinalTest { //修饰数据，i不能被再次赋值 private final int i = 0; //修饰方法，该方法不能被子类覆盖 public final void f(String s) { System.out.println("FinalTest.f"); } //修饰参数，j不能被重新赋值 public void g(final int j) { j = 1;//这条语句是错误的 } }

下面的代码显示了父类不能覆盖子类的final方法：

public class FinalChild extends Final { //这个方法是错误的，它不能覆盖父类的final方法 public void f(){}; //这个方法正确，重载 public void f(String s){} } class Final { public final void f() {} }

对于对象引用的修饰容易让人迷惑，看下面的程序：

final int i = 0; i = 1;//错误的代码，不能重新赋值 final StringBuffer s = new StringBuffer("Java"); s.append("World!");//正确代码，可以改变对象内容 s = new StringBuffer("Hello");//错误的代码，不能给引用重新赋值，它不能指向别的对象

注意代码注释，对整型i的修饰很好理解，给了i初值后，不能再给它其它值。而对于对象引用s，虽然用了final修饰并赋了初值，但依然可以使用s来操纵对象，只不过，不能再将s指向其它对象。

不要以为在定义final数据成员时必须指定初值，也不要以为它只能给一个常数值，它还可以是一个表达式，如下面的代码是成立的：
final int j;
j = 2 * 3;
像上面这种未指定初值的声明final数据成员通常称为空白final。

对于类的成员变量，有无final修饰存在一点区别，对于没有final修饰的成员变量，它们都有一个默认的初值（如整型数据为0），而对于final修饰的成员变量，必须确保它被初始化。看下面的程序：

public class TestFinal { private int i;//默认值为0。如果是private final int i;程序就会报错 public void print() { System.out.println(i); } }

如果使用final修饰i，程序就会出错，因为它未被初始化。如果想用final修饰的同时又不想在声明时初始化，则可以在构造函数中赋值。如下面的程序是正确的：

public class TestFinal { private final int i; public TestFinal () { i = 0; } public void print() { System.out.println(i); } }

一个既是static又是final的字段只占据一段不能改变的存储空间。 带有恒定初始值（即，编译时常量）的static final基本类型全用大写字母命名，并且字与字之间用下划线隔开。如java.lang.byte类里对byte类型的最小值定义：
public static final byte MIN_VALUE = -128;