Java—final关键字总结

Java—final关键字总结

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类
}

2. 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...")
    }
 */
}

3. final修饰的局部变量变量只能赋值一次

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

4. 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.
}

5. 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;
    }
}

6. 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="中国";
}