Final和static的区别

首先 Final 和static 是完全没有关系的。

  final 作用：

1.    final 修饰属性，表示属性【只能赋值一次】，（1）基本类型：值不能被修改；（2）引用类型：引用不可以被修改该。

   如:public final int rows = 1;

   此时变量rows不管在什么地方引用，都不能被再次赋值。

    但是，可以先只定义变量，不赋值。

      private final int id //只定义ID。

        private static int taskCount =0;
        private final int id = --taskCount; //给ID赋值。此时id在类中值是 -1 。并且不能再改变。

public class Father{
    
    public static int taskCount =0;
    // id 必须被初始化，不然会报错，但是可以动态初始化
    public final int id = --taskCount;     
    public int  rows = 10;    
    public final String fun(){
        /*错误，不能被二次赋值
        id = id++;*/
        System.out.println("Father id:"+ id);
        System.out.println("Father: This is a test method");
        return "";
    }
    
}

2 . final 修饰方法，表示方法不可以重写，但是可以被子类访问（如果方法不是 private 类型话）。

public class Son extends Father{
 
    /*子类不能重写父类方法
    public  final String fun(){
        System.out.println("Son: This is a test method");
        return "";
    }*/
    private String str="";
    private  int id=1;
    public Son(){
        super();
    }
    public Son(String str,int id){        
         this.str=str;
         this.id=id;
    }
    
    /*
     * 注意，此时的子类是可以重载父类的方法的
     */
    public  final String fun(String str){
        System.out.println("Son: This is a test method");
        return str;
    }
    
    //子类调用父类方法
    public static void main(String[] args) {
        /*Son son = new Son();        
         *son.fun();
         *注意：System.out.println("id:"+son.id+"||rows:"+ son.rows);
         *因为在子类构造方法中通过super调用父类，所以结果执行父类方法
         *Father id:-1   
         *Father: This is a test method
         *id:1||rows:10
         *System.out.println("id:"+son.id+"||rows:"+ son.rows)
         *输出中为什么不是-1而是1，因为子类同样存在ID属性，所以直接调用子类的ID
         *
         */

         /*
           * 被重新赋值，输出：id:3||rows:12
           */

         Son son = new Son();
          int a = son.id+2;
          int b= son.rows+2;        
          System.out.println("id:"+a+"||rows:"+ b);

        /*
           * 向上转型
           */

       Father aFather = new Son();
          aFather.fun();          
          int u = aFather.id;
          System.out.println("id:"+u+"||rows:"+ aFather.rows); 

         
    
}

3.   final 修饰类，表示类不可以被继承。

二. static

1..static 含义：静态的，被 static 修饰的方法和属性只属于类不属于类的任何对象。所以通过static 修饰的变量和方法可以直接通过类名调用。因此通过static修饰的变量和方法共享一片类存空间。

2..static 可以修饰【内部类】、方法和成员变量。
3..static【不可以修饰外部类】、【不可以修饰局部变量】（因为 static 本身就是定义为类级别的，所以局部级别的变量是不可以用 static 修饰的）。

public class StaticBase {
    private static int id =1;
    
    public void fun(){
        /*
         * 不能修饰局部变量
         * static ip = 0;
         */        
        ++id;
        System.out.println(id);
    }
    
    public static void main(String[] args) {
        
        StaticBase base1 = new StaticBase();
        StaticBase base2 = new StaticBase();
        System.out.println(base1.id);
        System.out.println(base2.id);
        /*
         * 共享一片内存，所以base1改变值，base2值同时变化
         */
        base1.fun();
        System.out.println(base2.id);
        
    }
}