final关键字的用法_c# final

1. final 关键字

final 可以修饰类，成员变量，成员方法，局部变量

1.1 final 修饰成员变量

final 修饰的成员变量要求必须进行初始化操作

【解决方案】

1. 直接初始化赋值
2. 【有参】数构造方法，实例化对象过程中初始化 final 修饰成员变量
3. final 修饰的成员变量一旦被赋值无法二次修改

class A {
    /*
    Variable 'msg' might not have been initialized
    msg 变量可能尚未初始化
    【解决方案】
        1. 直接初始化赋值
        2. 【有参】数构造方法，实例化对象过程中初始化 final 修饰成员变量
     */
    public final String msg = "直接赋值 final 修饰成员变量";
}

class B {
    public final String info;

    /**
     * 当前类有且只有有参数构造方法，并且当前有参数构造方法参数内容
     * 是给予当前类内 final 修饰的成员变量 info 进行初始化赋值操作
     * 可以满足在用户使用 info 之前可以已经赋值准备好对应的数据内容。
     *
     * @param info 赋值 final 修饰成员变量对应的参数
     */
    public B(String info) {
        this.info = info;
    }
}

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

        A a = new A();
        // final 修饰的成员变量无法进行二次赋值操作。
        // a.msg = "测试";
        System.out.println(a.msg);

        B b = new B("通过有参构造方法赋值 final 修饰成员变量");
        System.out.println(b.info);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

3.2 final 修饰成员方法

final 修饰成员方法不允许被子类重写

一般用于框架，业务核心代码内容修饰，不允许修改/重写代码内容

class C {
    public final void test() {
        System.out.println("C 类 test 成员方法");
    }
}

class D extends C {
    /*
    'test()' cannot override 'test()' in 'com.qfedu.b_final.C'; overridden method is final

    final 修饰的成员方法，子类不允许重写。
        一般用于框架，业务核心代码内容修饰，不允许修改/重写代码内容

    @Override
    public void test() {
        System.out.println("D 类继承 C 类重写 test 方法");
    }
    */
}

public class Test2 {
    public static void main(String[] args) {
        new D().test();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

1.3 final 修饰类

final 修饰类没有子类
在开发中基本类型不允许继承重新定义/制定规则。
例如：
Java 中是 String 类，基本数据类型的包装类 Integer Float Double

final class  E {

}

/*
Cannot inherit from final 'com.qfedu.b_final.E'
不能继承一个 final 修饰类
final 修饰类没有子类
   在开发中基本类型不允许继承重新定义/制定规则。
   例如：
        Java 中是 String 类，基本数据类型的包装类 Integer Float Double
 */
//class F extends E {
//
//}
public class Test3 {
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

3.4 final 修饰局部变量

final 修饰的局部变量首次赋值允许，后期不允许二次赋值

public class Test4 {
    public static void main(String[] args) {
        final int num ;
        /*
        final 修饰的局部变量，【首次】赋值没有任何的问题
            1. 定义时候初始化
            2. 后期代码赋值
         */
        num = 10;
        System.out.println(num);

        /*
        Cannot assign a value to final variable 'num'
        不能重新赋值一个 final 修饰的局部变量(local variable) num
         */
        num = 20;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

3.5 final 小面试题

class Person {
    public String name;
    public Integer age;

    public Person() {
    }

    public Person(String name, Integer age) {
        this.name = name;
        this.age = age;
    }
}

public class Test5 {
    public static void main(String[] args) {
        final Person person = new Person("张三", 66);

        System.out.println(person.name);
        System.out.println(person.age);
        /*
        以下代码错误的是:
            person.age = 20;
            person.name = "李四";
            person = new Person();
        答案
            全错
            1 2 错 3 对 
            1 2 对 3 错 【正确答案】
            【注意】
                final 修饰引用数据类型变量，指向不可变，指向数据空间内容可变
             从底层逻辑分析，final 修饰的为引用数据类型变量，当前变量存储数据不可变，变量			      
             存储内容是一个【地址】，表示地址无法修改，但是对应地址指向的数据空间内容，没有被 final 修饰，可以修改数据内容。
         */
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

3.6 final 使用总结

1. final 修饰类一般是架构中的底层核心代码，基本数据类型
2. final 修饰成员变量一般用于常量使用，并且在开发中大量存在，例如: 订单状态，用户状态，设备状态
3. final 修饰局部变量一般用于常量数据使用，同时是为了避免【生命周期问题】。
4. final 修饰成员方法是核心业务逻辑方法
1
2
3
4