关键字final

修饰变量

public class Test1 {
    final int id ;
    public Test1(){
    }
    public Test1(int id){
        this.id = id;
    }
}

1. final修饰成员变量时，必须显式赋值

如果被final修饰以后，不赋初始值，那么其他的对象都有能力将该值修改一下。那么这就不是最终的了

public class Test1 {
    final int id = 10 ;           //给id赋值
    public Test1(int id){
        this.id = id;
    }
    public Test1(){
    }
}

上述代码的有参构造 public Test1(int id)中，系统会先给id赋予随机的默认值，然后再将final int id = 10;中的10赋给id.对于final这是不可行的

2. final修饰局部变量时意味着该变量只能被赋值一次

                 举例几种赋值方法
1. 添加构造函数形参
public class Test1 {
    public final int id;
    public Test1(int id){
        this.id = id;
    }
}
2.在构造函数中初始化
public class Test1 {
    public final int id;
    public Test1(){
        id = 10;
    }
}

3. 一个类的变量被final修饰但没被赋值，那么可以判断出它肯定会在构造函数里被赋值

/*
final修饰引用类型数据时只保证引用的地址不变
但引用的内容可变
 */
import java.util.ArrayList;
import java.util.Arrays;

class person{
    private String name;
    public person(){
    }
    public person(String name){
        this.name = name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getName(){
        return name;
    }
}


public class final1 {
    public static void main(String[] args) {
        //final修饰构造方法
        final person one = new person("山外");
        System.out.println(one.getName());
        one.setName("野夫子");
        System.out.println(one.getName());//可以修改
        //one = null;----不可行

        System.out.println();
        
        //final修饰ArrayList数组
        final int[] arr = {2,0,2,2};
        System.out.println(Arrays.toString(arr));
        arr[3] = 3;
        System.out.println(Arrays.toString(arr));//可以修改
        //arr = null;----不可行
    }
}

4. final修饰的成员属性是引用类型时，表示引用地址不可改变，但是引用类型中的内容是可以改变的

修饰方法

public class final2 {
    public final void outer(){
        System.out.println("山外");
    }
}

//重写父类方法失败
class test extends final2{
    @Override
    public void outer() {
        System.out.println("野夫子");
    }
}
/*
通过final可以保护一些我们希望不被重写的方法
*/

1. 被修饰的public方法不可以被重写

public class final2 {
    private final  void outer(){
        System.out.println("山外");
    }
}

//重写父类方法失败
class test extends final2{
    public void outer() {
        System.out.println("野夫子");
    }
}
/*
被private修饰的方法仅仅属于当前类
所以此时子类中重名的方法不算是重写，故可以运行
 */

修饰类

被修饰的类不能有子类，即该类不可被继承
可以利用这一特性保护我们不希望被继承的类