final关键字的多种用法

输出结果：

fd1:i4 = 15, INT_5 = 18
Creating new Demo6
fd1:i4 = 15, INT_5 = 18
fd2:i4 = 13, INT_5 = 18

总结：

1.当我们使用final常量时并不能单纯的认为在编译时就可以知道他的值，在运行时通过随机生成的数值来初始化i4和INT_5就可以得出这个结论

2.只用final修饰的常量在当前对象的值是唯一的，但是当我们在创建一个对象时final的值是可以初始化不同的值的.

3.被final修饰的引用，只是说明引用的指向不能被改变，但是其对象本身是可以被改变的，通过上面代码的int类型的数组的值被改变就可以发现

4.空白final是指被声明为final但又未给定初值的域，无论什么属性，编译器都要确保空白final在被使用前被初始化，不信可以试试把构造器中对空白final初始化的代码注释掉试试

5.在构造器中对空白final进行初始化，可以让不同的对象有不同的final值，并且保持final恒定不变的特性，这就是为什么说final的值并不是固定的原因了。

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

思考一下能不能继承父类的private方法或者final方法？

当你重写父类的private方法时，真的是重写么？

class WithFinals{
    private final int i = 19;
    public int getI(){
        return i;
    }
    private final void f(){
        System.out.println("WithFinals.f()");
    }
    private void g(){
        System.out.println("WithFinals.g()");
    }
}
class OverridingPrivate extends WithFinals{
    // @Override
    private void f(){
        System.out.println("OverridingPrivate.f()");
    }
    private  void g(){
        System.out.println("OverridingPrivate.g()");
    }
}
class OverridingPrivate2 extends OverridingPrivate{
    // @Override
    public final void f(){
        System.out.println("OverridingPrivate2.f()");
    }
    public void g(){
        System.out.println("OverridingPrivate2.g()");
    }
}
public class Demo7 {
    public static void main(String[] args) {
        OverridingPrivate2 op2 = new OverridingPrivate2();
        op2.f();
        op2.g();
        System.out.println(op2.getI());
        OverridingPrivate op = op2;
        // op.f();
        // op.g();
        WithFinals wf = op2;
        // wf.f();
        // wf.g();
    }
}

输出结果：

OverridingPrivate2.f()
OverridingPrivate2.g()
19

 其实子类确实继承了父类的私有方法和属性，不然又怎么调用父类的方法去 *** 纵父类的私有属性呢，有人不信，说你怎么不举个例子证明一下呢？

代码如下:

import java.lang.reflect.AccessibleObject;
import java.lang.reflect.Method;

class Father {
    private String name = "father";
    public Father(){

    }
    private void printf(){
        System.out.println("father方法");
    }
}
class Test extends Father{

}
public class Demo8 extends Father{
    public static void main(String[] args) throws Exception{
        Class c = Test.class;
        Test test = new Test();
        Class f = c.getSuperclass();
        Method[] declaredMethods = f.getDeclaredMethods();
        AccessibleObject.setAccessible(declaredMethods,true);
        for(Method m :declaredMethods){
            System.out.println("子类调用父类的"+m.getName()+"方法");
            m.invoke(test);
        }
    }
}

输出结果：

子类调用父类的printf方法
father方法

通过反射可以看到子类确实继承了父类的private方法，只是因为访问权限的问题不能对私有的方法进行访问，当你用private和final同时修饰类中的方法时，你会发现编译器发出警告（private被声明未final）这也就间接的说明了其实private方法是被隐式的指定为final的，只是因为无法取用private方法所以没办法覆盖它，当然你也可以加上final修饰符，但是这个修饰符其实没有发挥任何意义。

方法可以声明为 final 方法，以防止子类覆盖或隐藏它。尝试重写或隐藏最终方法是编译时错误。
私有方法和在最终类中立即声明的所有方法的行为就像它们是最终方法一样，因为不可能重写它们。

当函数参数为final类型时，你可以读取使用该参数，但是无法改变该参数的值。

public class Test4 {
        public static void main(String[] args) {
                new Test4().f1(2);
        }

        public void f1(final int i) {
                //i++;    //i是final类型的,值不允许改变的.
                System.out.print(i);
        }
}

参考资料：Java关键字final、static使用总结_熔 岩的技术博客_51CTO博客