Java中static、final关键字与static代码块_JAVA_编程开发_程序员俱乐部

class="java">
可以修饰类，属性，方法。

1. static修饰属性时，无论多少引用都公用一个属性。
一个成员变量是static的，可以通过 类名.成员变量名 来使用。
public class StaticTest {
    public static void main(String[] args){
        MyStatic myStatic = new MyStatic();
        MyStatic.a = 10; // 类名，不是引用名
        System.out.println(myStatic.a);
    }
}
class MyStatic{
    static int a;
}
10

2. 一个方法是static的，可以通过 类名.方法名 来使用。
public class StaticTest2 {
    public static void main(String[] args){
        // MyStatic2 test = new MyStatic2();
        // test.output();
        MyStatic2.output();
    }
}
class MyStatic2{
    public static void output(){
        System.out.println("output");
    }
}
output

3. 子类是不能重写父类的静态方法的。（只能继承）：是隐藏不是继承。
1) 父类对象指向子类的引用，调用父类的静态方法。
2) 子类对象指向子类的引用，调用子类的静态方法。
3) 父类对象指向子类的引用，调用子类的非静态方法。
4) 子类对象指向子类的引用，调用子类的非静态方法。
public class StaticTest3 {
    public static void main(String[] args){
        M m = new N();
        m.output();
    }
}
class M{
    public static void output(){
        System.out.println("M");
    }
}
class N extends M{
    public static void output(){
        System.out.println("N");
    }
}
M

可以修饰类，属性，方法。

1. Final修饰类的时候，该类是一个终态类，不能被继承。
public class FinalTest{
    public static void main(String[] args){
        F f = new F();
    }
}
final class E // 该类不能被继承{
}
class F extends E{
}
Exception in thread "main" java.lang.Error: Unresolved compilation problem: 
	The type F cannot subclass the final class E

2. Final修饰方法的时候，该方法是一个终态方法，不能被重写（Override）。
public class FinalTest2{
    public static void main(String[] args){
        H h = new H();
        h.output();
    }
}
class G{
    public final void output(){
        System.out.println("G");
    }
}
class H extends G{
    public void output(){
        System.out.println("H");
    }
}
Exception in thread "main" java.lang.VerifyError: class org02.H overrides final method output.()

3. Final修饰属性的时候，该属性不能被改写。
public class FinalTest3{
    public static void main(String[] args){
        People people = new People();
        // The final field People.age cannot be assigned
        // people.age = 20;
        // people.address = new Address();
        people.address.name = "shanghai";
        System.out.println(people.address.name);
    }
}
class People{
    final int age = 10;
    final Address address = new Address();
}
class Address{
    String name = "beijing";
}
Shanghai

补充：
final类型的变量必须赋初值。（可以直接赋值，可以在构造方法中赋值。（但是不能两者都存在））
如果是有参数的构造方法，必须给final类型的变量赋值（因为不知道会调用哪个方法）。
对于final类型的成员变量，一般有两种类型的赋值方法：
a) 在声明final成员变量时就赋值。
b) 在声明final成员变量时不赋值，在类的所有构造方法中都为其赋值。

代码块是在加载的时候执行的，所有无论生成几个对象，只会执行一次代码块。

不能在静态的方法中访问非静态的成员变量。（可以通过类去调用静态方法，但不知道要操作的成员变量是哪个对象中的）
静态方法只能访问静态变量，非静态方法既可以访问静态方法，也可以访问非静态方法。
this不能引用static属性，this是非静态的，只能是当前对象。
public class StaticTest4{
    public static void main(String[] args){
        new S();
        new S();
    }
}
class P{
    static{
        System.out.println("P static block");	
    }
    public P(){
        System.out.println("P constructor");
    }	
}
class Q extends P{
    static{
        System.out.println("Q static block");
    }
    public Q(){
        System.out.println("Q constructor");
    }
}
class S extends Q{
    static{
        System.out.println("S static block");
    }
    public S(){
        System.out.println("S constructor");
    }
}
P static block
Q static block
S static block
P constructor
Q constructor
S constructor
P constructor
Q constructor
S constructor