Java—final关键字总结

淩亂°似流年 2022-10-12 12:15 99阅读 0赞

# Java—final关键字总结 #

### 文章目录 ###

*  Java—final关键字总结
 *   *  1.1、final修饰的类无法继承
     *  1.2、final修饰局部变量
     *  1.3、final修饰引用
     *  1.4、final修饰实例变量
     *  1.5、常量(static final)
     *  1.6、fianl总结

## 1.1、final修饰的类无法继承 ##

> final修饰的类无法继承。

## 1.2、final修饰局部变量 ##

> final修饰的**局部变量**变量只能赋值一次,一旦赋值，不能重复赋值。

## 1.3、final修饰引用 ##

> final修饰的变量只能赋值一次(万变不离其宗)

> “引用”是不是一个变量呢？
> 
> 答：**是**

***final修饰的引用：***

*  该引用只能指向1个对象，并且它只能永远指向该对象，无法指向其他对象。
 *  并且在该方法执行过程中，该引用指向对象后，该对象不会被垃圾回收器回收。至到当前方法结束，才会释放空间。
 *  虽然final的引用指向对象后，不能再重新指向对象B。但是对象A内部的数据可以被修改。

***局部变量没有初始值，只有成员变量才有初始值***

## 1.4、final修饰实例变量 ##

*  final修饰**实例变量**时，变量必须手动赋值。
 *  final修饰的**实例变量**，系统不负责赋默认值，要求程序员必须手动赋值，在变量后赋值可以，在构造方法中赋值也可以。
 *  实例变量在什么时候赋值(初始化)？
    
    构造方法执行的过程中赋值。(new的时候赋值)

> final修饰的实例变量一般添加static修饰。

## 1.5、常量(static final) ##

*  **终极结论：**

**static final**联合修饰的变量成为“常量“。

常量名建议全部大写，每个单词之间采用下划线衔接。

**例**：static final String COUNTRY = ”中国“

**常量**：实际上常量和静态变量一样，区别在于：

常量的值不能变。

常量和静态变量，都是储存在方区，并且都是在类加载时初始化。

常量一般是都是公开的(public)。

**例**：public static final String COUNTRY = “中国”

## 1.6、fianl总结 ##

> 1.  final修饰的**类**无法继承
> 
>     final class A{
>          
>         //A 是没有子孙的
>     }
>     class B extends A{
>          
>         //错误的, 无法从最终类A进行继承
>         //B类继承A类 相当于对A类功能进行扩展
>         //如果不希望别人对A类进行扩展，可以给A类加final关键字，如String类
>     }

> 1.  final修饰的**方法**无法覆盖
> 
>     class C{
>          
>         public final void doSome(){
>          
>            System.out.println("C's doSome...")
>         } 
>     }
>     class D extends C{
>          
>      //ERROR，无法覆盖
>      /*   public  void doSome(){
>          System.out.println("D's doSome...")
>         }
>      */
>     }

> 1.  final修饰的**局部变量**变量只能赋值一次
> 
>     public class Test01{
>          
>         public static void main(String[]args){
>          
>             //局部变量
>             int i=100;
>             //重新赋值, 没问题
>             i=200;
>             
>             // 再定义一个局部变量 
>             final int k=100;
>             //重新赋值
>             //错误: 无法为最终变量k分配值
>            // k=300;
>         }
>     }

> 1.  final修饰的**实例变量**必须手动初始化，不能采用系统默认值
> 
>     class User{
>          
>         //实例变量
>         //编译器报错
>         //final int age;
>         
>         //1.
>         //实例变量
>         //可以，因为手动赋值了
>         final double height = 1.8;
>         
>         //2.
>         //实例变量
>         final double weight;
>         //构造方法
>         poublic User{
>          
>             this.weight = 80;
>             //this.weight = 81; //这个不可以
>         }
>         //把有参构造去掉就会报错，因为去掉有参构造，就默认无参构造，而无参构造默认值为0.
>     }

> 1.  final修饰的**引用**一旦指向某个对象，则不能重新只想其他对象，但该引用指向对象内部的数据可以修改。
> 
>     /*
>     final修饰的变量 如果这个变量是一个"引用"会怎么样？
>       final修饰的变量只能赋一次值
>       "引用"是否是一个变量 ：是
>       
>       总结：final修饰的引用
>            1.该引用只能指向1个对象 并且它只能永远指向该对象,无法再指向其他对象
>            
>            2.在该方法执行过程中，该应用指向该对象之后，该对象不会被垃圾回收器回收，直到当前方法结束，才会释放空间
>            
>            3.虽然final的引用指向对象A后，不能重新指向对象B,但对象A内部的数据可以被修改
>     */
>     public class Test02{
>          
>         public static void main(String[] args){
>          
>             Person p1 = new Person(20);
>             System.out.println(p1.age);
>         //代码不管怎么变化，p也是一个变量。（只不过他有一个特殊的名字：引用）
>         final Person p = new Person(30);
>     	//错误：无法位最终变量p分配值
>         p = new Person(30);
>         //对象内部数据可以改变
>         p.age = 40;
>             System.out.println(p.age);
>             /*
>             final int i = 10;
>             //不允许的
>             i = 20;
>             */
>         }
>     }
>     
>     Class Person{
>          
>         int age;
>         public Person{
>          
>             //无参构造
>         }
>         public Person(int age){
>          
>             this.age = age;
>         }
>     }

> 1.  final修饰的实例变量一般和static联合使用，称为**常量**。
>     
>     例：public static final double PI = 3.1415926;
> 
>     /*
>     final修饰的实例变量一般添加static修饰 变成静态的，存储在方法区，节省空间。
>     
>     结论：static final联合修饰的变量成为“常量”
>          常量名要全部大写，每个单词之间采用下划线衔接
>          
>     常量：实际上和静态变量一样 区别在于：常量的值不能变。
>          
>          常量和静态变量，都是存储在方法区，并且都是在类加载时初始化
>          
>          常量一般都是公开的：public
>     */
>     
>     public class Test03{
>          
>         public static void main(String[]args){
>          
>             System.out.println(Chinese.COUNTRY);
>             //错误：无法为最终变量COUNTRY赋值
>             //Chinese.COUNTRY="美国"; //常量是无法被重新赋值的
>         }
>     }
>     
>     class Chinese{
>          
>         String idCard;
>         String name;
>         String birth;
>         //国家的值是一个固定值："中国"
>         //实例对象在堆中，一个对象一份 一百个对象一百份
>         //实例变量既然用final修饰了，说明该实例变量值不会随着对象的变化而变化
>     public static  final String COUNTRY="中国";
>     }