目录

• 1.final 润饰的类无奈继承
• 2.final 润饰的办法无奈笼罩
• 3.final 润饰局部变量
• 4.final 润饰援用
• 5.final 润饰实例变量
• 6. 常量
• 7. 总结：

1.final 润饰的类无奈继承

final 关键字
1.final 是 java 语言的一个关键字
2.final 示意最终的，不可变的。
3.final 能够润饰变量以及办法、还有类
4.final 润饰的变量？
5.final 润饰的办法？
final 润饰的办法无奈笼罩，无奈重写。
6.final 润饰的类？
final 润饰的类无奈继承。
final class A{
}
// B 类继承 A 类，相当于对 A 类的性能进行扩大，如果你不心愿他人对 A 类进行扩大，你能够给 A 类自豪 final 关键字，这样的话 A 类就无奈继承了。
class B extends A{
}

如 String 类就是最终类

2.final 润饰的办法无奈笼罩

`class C{public final void dosome(){System.out.println("c 的 dosome");
    }
}
class D extends C{public void dosome(){System.out.println("d 的 dosome");
    }
}` 

*   1
*   2
*   3
*   4
*   5
*   6
*   7
*   8
*   9
*   10

3.final 润饰局部变量

`public static void main(String[] args) {
        // 局部变量
        int i=100;
        // 从新赋值
        i=200;
        
        // 局部变量
        final int k=100;
        // 从新赋值
        k=300;
    }` 

*   1
*   2
*   3
*   4
*   5
*   6
*   7
*   8
*   9
*   10
*   11

final 润饰的局部变量，一旦赋值不能从新赋值。

`final int m;
        // 第一次赋值
        m=200;
        // 从新赋值
        m=300;` 

*   1
*   2
*   3
*   4
*   5

重点：final 润饰的变量，只能赋一次值。

4.final 润饰援用

final 润饰的变量，只能赋一次值。
援用是不是一个变量呢？？？，是的

`public class FinalTest02 {public static void main(String[] args) {Person p1=new Person(20);
        System.out.println(p1.age);
        // 代码不管怎么变动，p 也是一个变量（只不过这里它有一个非凡的名字，援用）final Person p=new Person(30);
        p=new Person(30);
    }
}
class Person{
    int age;
    public Person(){}
    public Person(int age){this.age=age;}
}` 

*   1
*   2
*   3
*   4
*   5
*   6
*   7
*   8
*   9
*   10
*   11
*   12
*   13
*   14
*   15
*   16

谬误：无奈为最终变量 p 调配值
留神：局部变量没有初始值。
final 润饰的援用：
该援用只能指向 1 个对象，并且它只能永远指向该对象。无奈再指向其余对象。并且在该办法执行过程中，该援用指向该对象之后，该对象不会被垃圾回收器回收。直到以后办法完结，才会开释空间。
尽管 final 的援用指向 A 后，不能再从新指向对象 B，然而对象 A 的数据能够被批改。

5.final 润饰实例变量

final 润饰的实例变量
万变不离其宗。final 润饰的变量只能赋值一次 。（这句话到哪里都好使）
你是否还记得：实例变量如果没有手动赋值的话，零碎会赋默认值 。
java 程序设计，甩锅甩的很好。
实例变量在什么时候赋值（初始化）
构造方法执行的过程中赋值（new 的时候赋值）

终极论断：
final 润饰的实例变量，零碎不负责赋默认值，要求程序员必须手动赋值（定义的时候就必须赋值）。
这个手动赋值，在变量前面赋值能够，在构造方法中赋值也能够

`public class FinalTest03 {public static void main(String[] args) {}}
class User{
    // 编译器报错
//    final int age;
    // 能够, 因为程序员手动赋值了
    final double height=1.8;
    
    // 以下这一堆代码全副联结起来，weight 变量也是赋值了 1 次。// 实例变量
    final double weight;
    // 构造方法
    public User(){
        // 只有我赶在零碎赋默认值之前赋值就行。this.weight=80;
    }
}` 

*   1
*   2
*   3
*   4
*   5
*   6
*   7
*   8
*   9
*   10
*   11
*   12
*   13
*   14
*   15
*   16
*   17
*   18
*   19
*   20

6. 常量

final 润饰的实例变量
final 润饰的实例变量个别增加 static 润饰
终极润饰：
static final 联结润饰的变量称为常量
常量名倡议全副大写，每个单词之间采纳下划线连贯
常量：实际上常量和动态变量一样，区别在于：常量的值不能扭转，常他们都是存储在办法区，并且都是在类附加时初始化
常量无奈从新赋值
常量个别是公开的，是 public 的

`public class FinalTest04 {public static void main(String[] args) {}}
class Chinese{
    // 身份证，每个人都不一样，对象级别的
    String idCard;
    // 姓名, 对象不同姓名不一样
    String name;
    // 国家的值就是一个固定值，"中国"
    // 既然这里的值不会扭转，还有必要申明为实例变量吗
    // 实例变量在堆中，一个对象一份，100 个对象 100 份
    // 实例变量既然应用 final 润饰了，阐明该实例变量不会随着对象的变动而变动。// 该实例变量后面应该增加：static 关键字，变为动态的，存储在办法区。//    static final String country="中国";
    static final String COUNTRY="中国";
    // i 永远都是 10，创立 100 个对象，i 也是 10
    // i 是 10 是永远不会变动的，既然这样，没必要申明为实例变量，最好是动态的，节俭内存空间。}
class MyMath{public static final double PI=3.1415926;}` 

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

7. 总结：

1、final 关键字

• 1.1、final 润饰的类无奈继承。
• 1.2、final 润饰的办法无奈笼罩。
• 1.3、final 润饰的变量只能赋一次值。
• 1.4、**final 润饰的援用一旦指向某个对象，则不能再从新指向其它对象，但该援用
  指向的对象外部的数据是能够批改的。**
• 1.5、final 润饰的实例变量必须手动初始化，不能采纳零碎默认值。
• 1.6、final 润饰的实例变量个别和 static 联结应用，称为常量。
  public static final double PI = 3.1415926;