Java中final是什么？作用是什么？如何使用？ ——关键字final

final

概述

含义: 最终的

可以修饰的内容

(1)修饰变量(局部变量 成员变量(实例变量 静态变量(类变量)))
(2)修饰方法(成员方法)(静态方法)
(3)修饰类(普通类)

1、修饰变量

（1）修饰局部变量

特点：
final 修饰的局部变量只能赋值一次，一旦赋值其值不可以改变

案例:

    public class Demo2 {
        public static void main(String[] args) {
    //        final int a = 10;//局部变量
    //        a = 20;//第二次赋值
    //        System.out.println(a);
    
            final int a;//声明
            a = 10;//第一次赋值
            //a = 20;//报错
            System.out.println(a);
        }
    }
    
    

（2）修饰成员变量

特点：
1.final修饰的实例变量没有默认值
2.final修饰的实例变量只能赋值⼀次
3.final修饰的实例变量可以在构造⽅法中初始化/构造代码块中/直接赋值 ,但是当使用构造方法赋值的时候要保证每个构造都必须能够为这个变量初始化

案例：

    //案例1:关于特点1  
    public class Demo2 {
        public static void main(String[] args) {
            Test test = new Test();
            System.out.println(test.a);//0
        }
    }
    
    class Test{
        final int a ;
    }
    
    //案例2: 关于特点2
    package com.ujiuye.day11;
    
    public class Demo2 {
        public static void main(String[] args) {
            Test test = new Test();
            System.out.println(test.a);//10
            
            //修改值
            test.a = 20;
            
        }
    }
    
    class Test{
        final int a = 10;//也只有一次赋值机会
    
    }
    
    //案例3: 
    package com.ujiuye.day11;
    
    public class Demo2 {
        public static void main(String[] args) {
            Test test = new Test();
            System.out.println(test.a);//10
           // test.a++;
    
    
        }
    }
    
    class Test{
    
        //1 直接赋值
        //final int a = 10;//也只有一次赋值机会
    
    
        // 2 构造代码块进行赋值
    //    final int a;//声明
    //
    //    {
    //        a = 10;
    //    }
    
        //3 构造方法赋值
        final  int a;
    
        public Test() {
            a = 10;
        }
    
        public Test(int a) {
            this.a = a;
        }
    }
    
    

（3）修饰静态变量

特点：
1.final修饰的类变量没有默认值
2.final修饰的类变量可以通过静态代码块进⾏初始化/ 也可直接进行初始化
3. 只能赋值一次

案例：

    //案例1: 关于特点1
    public class Demo2 {
        public static void main(String[] args) {
            System.out.println(Test.a);
    
    
        }
    }
    
    class Test {
        final  static int a;//静态变量
    }
    
    
    //案例2:关于特点2
    package com.ujiuye.day11;
    
    public class Demo2 {
        public static void main(String[] args) {
            System.out.println(Test.a);
    
    
    
        }
    }
    
    class Test {
        final  static int a ;//静态变量
    
        static {
            a = 10;
        }
    }
    
    

修饰方法

修饰成员方法和静态方法

特点：
1.final修饰的成员⽅法&静态 可以重载
2.final修饰的实例变量只能赋值⼀次
3. final修饰的静态方法 本来可以形成一个符合重写语法的方法,但是被final修饰之后,也不能定义符合重写语法的方法了.
案例：

    //案例1: 关于特点1
    public class Demo2 {
        public static void main(String[] args) {
            System.out.println(Test.a);
    
    
    
        }
    }
    
    class Test {
    
        public final void m1(){
            System.out.println("我是成员方法m1");
        }
    
        //重载m1
        public void m1(int a){
            System.out.println("我是重载m1方法");
        }
    
        public static void m2(){
            System.out.println("我是静态方法m2");
        }
        public static void m2(int a){
            System.out.println("我是重载静态方法m2");
        }
    }
    
    

修饰类

 语法：
 final class Animal{
 }

特点：
final修饰的类没有⼦类 俗称断⼦绝孙类 不能被继承
Java中常见的被final修饰的类 ： String Math System
案例：

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



    }
}

final   class Test{

}
class TestSub extends Test{//此处报错

}