java关键字

            本篇文章持续更新...

1、final关键字

根据上下文关系，final关键字的含义，存在细微的差别，通常指“无法被改变的"；讨论final分为3各方面：

数据：
对于基本类型数据来说，final使其数值恒定不变，而对于引用来说，final使其引用恒定不变，但是其引用对象自身的值可以被改变；
但是对于基本类型，不能认为编译时就知道了，它的值，可以在运行中进行生成；

static final int d=new Random().nextInt(20);

同时，对与static final与final，前者(因为是static)在装载时已经被初始化，而不是每次创建新对象才被初始化；

public class grandFather {
    final int d=new Random().nextInt(20);
    static final int s=new Random().nextInt(30);
    }
   public static  void main(String args[]) {
        grandFather father=new grandFather("bob");
        grandFather grand=new grandFather("john");
        System.out.println("grandFather的值。。。");
        System.out.println(grand.d);
        System.out.println(father.d);
        System.out.println("grandFather的值。。。");
        System.out.println(grandFather.s);
        System.out.println(grand.s);
        System.out.println(father.s);
    }
    
grandFather的值。。。
16
9
grandFather的值。。。
6
6
6

同时,java允许生成空白final，即声明为final,但是又未给出给定初值的域，无论什么情况下，编译器必需确保final在使用前被初始化（通过构造器，代码块等进行初始化，不能采用默认值进行初始化）；

package com.test;

import com.anmial.Anmial;
import javafx.animation.Animation;

import java.util.LinkedList;
import java.util.List;
import java.util.Random;

public class grandFather {
    public String name;
    final String city; //空白final
     final static Object[] obj = new Object[12];
     final Anmial anmial; //空白final
     private static  final int lich ;//空白final
     final int d=new Random().nextInt(20);
     static final int s=new Random().nextInt(30);

    static {
        lich=12; //静态代码块进行初始化
    }
    public grandFather() {
        city="12"; //构造器进行初始化
        System.out.println("grandFather constructor start...");
        anmial = new Anmial(12);
        System.out.println(anmial);
        System.out.println(obj.toString());
        System.out.println("grandFather constructor has..."+city);
    }
    public grandFather(String name){
        city="12";
        System.out.println("grandFather constructor start...");
        this.name=name;
        anmial=new Anmial(20);
        System.out.println(obj[0]);
        System.out.println("grandFather constructor has..."+city);
    }
    
     //final参数，无法再更改其指向的对象或其数值，主要使用在内部类中
    public void moon(final int hleo){ 
        //hleo=12;   //Error
        System.out.println("hello erer"+hleo);
    }
}

方法
final方法，其事使用共有两个原因：第一个为把方法进行锁定，以防继承类修改它的含义即重写；
第二个原因为效率，

有意思的是，类中的private方法，都隐式的指定为final方法，因为它无法被覆盖（重写）；
因此可以对其增加final关键字进行修饰i，但是不会增加任何意义；

package com.test;

public class father {
   public int age;
    public father(){
    }
    public final void run(){
        System.out.println("father is running...");
    }

package com.test;

public class son extends father {

   public son(){
       System.out.println("son constructor start。。。");
    }
    public son(int name){
        System.out.println("son's name is "+name);
    }
    
   /* @Override
    public final void run(){
    }*/
    //错误，final方法无法被重写
}
}

类
final类，一个类指定为，final类型，代表此类无法被继承；如String类：

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {