关键字final、static

Java关键字final、static

final关键字

    Java关键字final具有“无法改变的”或者“终态的”等含义，可以用来修饰非抽象类，非抽象类成员变量和方法。你可能处于两种理解而需要阻止改变：设计或效率。

• final类不能被继承，没有子类，final类中的方法默认是final的。
• final方法不能被子类的方法覆盖，但是可以被继承。
• final成员变量表示常量，只能被赋值一次，赋值之后不可以再被改变。
• final不能用于修饰构造方法

1. final类

    final类不能被继承，因此final类的成员方法没有机会被覆盖，默认都是final的。在设计类的时候，如果不需要发展子类了，类的实现细节不许改变，并且确定类不会被扩展，那么就直接可以设计成final类。例如：

final class SuperClass1 {
    private final void f() {
        System.out.println("SuperClass1---f()");
    }
    public void g() {
        f();
    }
}
public class JavaTest extends SuperClass1{
}
编译器会直接报错
The type JavaTest cannot subclass the final class SuperClass1

2. final方法

    如果一个类不允许其子类覆盖某个方法，则可以把这个方法声明为final方法，使用final方法的原因有两个：

1. 把方法锁定，防止任何继承类修改它的意义和实现。
2. 高效。编译器在遇到final方法的时候会转入内嵌机制，大大提高执行的效率。但是在近期的Java版本中，虚拟机已经对这些情况做出了优化，final这种做法渐渐消失。（在Java的早起实现中，如果将一个方法指明为final,编译器会根据自己的判断，跳过插入程序代码中俄中正常的方式而执行方法调用机制，并且以实际方法代码的副本来代替方法调用，但其性能会随着代码的膨胀而被缩减）。

3. final变量(常量)

    用final修饰的成员变量表示常量，值一旦给定就无法改变了。final修饰的变量有三种：静态变量、实例变量和局部变量，分别表示三种类型的常量。一旦给final变量初值之后，值就不能再改变。例如：

public class Test {
    public final int a = 5;
    public final String b = "dada";
    public static final String = "string";
    public static void main(String[] args) {
        Test t = new Test();
        //t.a += 5; 尝试修改final 类型变量，编译器直接报错。 
    }
}

    final变量定义的时候，可以先声明，而不给初值，这种变量也成为final空白，无论什么情况下，编译器都确保空白final在使用前必须被初始化。空白final变量保证了变量的不变性，同时也可以保证可以和多个对象(或者基本类型)相关联。例如：

public class JavaTest{
    public final int a = 5;
    public final int b;
    public final String s;

    public JavaTest(int bb, String ss) {

        s = ss;
        b = bb;
    }
    public static void main(String[] args) {

        JavaTest jt = new JavaTest(10, "dada");

        System.out.println("b : " + jt.b + "\n" + "s : " + jt.s + "\n");
    }
}

4.final参数

    Java中允许在参数列表中以声明的方式将参数指明为final。当函数参数为final类型时，可以读取使用该参数，但是无法改变该参数的值。但是在这里需要说明的是，Java中许多参数都是对象的引用，这种情况下不能改变传进来的引用的指向，即和它们关联的对象，但是可以改变它们目前所指向的可访问的数据。例如：

class TestClass {
    public int age;
    public void func(final TestClass tc) {

        // tc = new TestClass(); 由于tc为final修饰的，故不能修改tc指向的对象，编译器报错

        //但是这里不同，虽然tc为final类型，tc的值不可以改变，但是其指向的对象的值还是可以改变的，因为tc为对象引用。
        tc.age += 100;
        System.out.println(tc.age);
    }
}

public class JavaTest{
    public static void main(String[] args) {

        TestClass tc = new TestClass();
        tc.age = 10;
        tc.func(tc);
    }
}

5.final和private

    父类的private成员方法是不能被子类方法覆盖的，因此private类型的方法默认是final类型的。即使尝试去覆盖，编译器不会报错，但这不叫覆盖了。仅仅是有相同名字的两个private方法而已，例如：

class BaseClass {
    private final void f() {
        System.out.println("BaseClass---f()");
    }
}

class SuperClass1 extends BaseClass {
    private final void f() {
        System.out.println("SuperClass1---f()");
    }
    public void g() {
        f();
    }
}
public class JavaTest extends SuperClass1{
    public static void main(String[] args) {
    SuperClass1 sc = new SuperClass1();
    sc.g();
    }
}
输出结果：SuperClass1---f()

    方法的覆盖只有在某方法是基类的接口的一部分时才会出现。即必须能讲一个对象向上转型为它的基本类型并调用相同的方法。也就是说，在上面的例子中，需要能实现如下代码才可以覆盖：

BaseClass bs = new SuperClass1();
bs.f(); //f方法为private,不能调用，故也不能在父类中覆盖。

static关键字

    static表示“全局”或者“静态”的意思，用来修饰成员变量和成员方法，也可以形成静态static代码块，但Java语言中没有全局变量的概念。

    被static修饰的成员变量和成员方法独立于该类的任何对象。不依赖于实例，被类的所有实例共享。只要这个类被加载，Java虚拟机就能根据类名在运行时数据区或方法区内找到。

    用public修饰的static成员变量和成员方法本质时全局变量和全局方法，当声明它类的对象时，不声称static变量的副本，所有类的实例公用一个static变量。

    static变量可以用private修饰，表示这个变量可以在类的静态代码块中，或者类的其他静态成员方法中使用,但是不能在其他类中通过类名来直接引用。

    用static喜事的代码块表示静态代码块，当Java虚拟机(JVM)加载类时，就会执行静态代码块(用处很大)。

1. static变量

    成员变量为静态和非静态变量，两者的区别是：

• 前者内存中只有一个拷贝(节省内存)，在加载类的过程中完成静态变量的内存分配，推荐用类名直接访问，也可以用(不推荐)对象来访问。
• 后者内存中有多少个该类的实例对象，就会分配多少次内存，实例变量可以在内存中有多个拷贝，互不影响。

2. static方法

    static方法直接通过类名调用，任何实例也能调用(不推荐)，因此静态方法中不能出现this和super关键字，不能直接访问所属类的实例变量和实例方法(没有被static修饰的变量和方法)。

    由于static方法独立于任何的实例，所以static方法必须被实现，而不能是抽象的abstract。

3. static代码块

    static代码块也叫静态代码块，是在类中独立于类成员的static语句块，可以有多个，位置任意摆放(放在一起还是比较好的)，JVM加载类的时候会执行这些静态的代码块，如果static有多个，则按照排列的先后顺序依次执行，每个代码块只会被执行一次。利用静态代码块，可以给static变量赋值。

4. static和final一起使用

    static final用来修饰成员变量和方法，可简单的理解为“全局变量”，对于变量，表示一旦赋值就不可改变，可通过类名直接访问，独立于实例。对于方法来说，表示不可覆盖，并且通过类名可以直接访问。