final关键字

继承的代码体现

由于继承中方法有一个现象：方法重写。
所以，父类的功能，就会被子类给覆盖调。
有些时候，我们不想让子类去覆盖掉父类的功能，只能让他使用。
这个时候，针对这种情况，Java就提供了一个关键字：final

final:最终的意思。常见的是它可以修饰类，方法，变量。

class Fu {
public final void show() {
System.out.println("这里是绝密资源,任何人都不能修改");
}
}

class Zi extends Fu {
// Zi中的show()无法覆盖Fu中的show()
public void show() {
System.out.println("这是一堆垃圾");
}
}

class ZiDemo {
public static void main(String[] args) {
Zi z = new Zi();
z.show();
}
}

特点

final可以修饰类，方法，变量

特点：
final可以修饰类，该类不能被继承。
final可以修饰方法，该方法不能被重写。(覆盖，复写)
final可以修饰变量，该变量不能被重新赋值。因为这个变量其实常量。

常量：
A:字面值常量
"hello",10,true
B:自定义常量
final int x = 10;

//final class Fu //无法从最终Fu进行继承

class Fu {
public int num = 10;
public final int num2 = 20;

/*
public final void show() {

}
*/
}

class Zi extends Fu {
// Zi中的show()无法覆盖Fu中的show()
public void show() {
num = 100;
System.out.println(num);

//无法为最终变量num2分配值
//num2 = 200;
System.out.println(num2);
}
}

class FinalDemo {
public static void main(String[] args) {
Zi z = new Zi();
z.show();
}
}

面试题

/*
面试题：final修饰局部变量的问题
基本类型：基本类型的值不能发生改变。
引用类型：引用类型的地址值不能发生改变，但是，该对象的堆内存的值是可以改变的。
*/
class Student {
int age = 10;
}

class FinalTest {
public static void main(String[] args) {
//局部变量是基本数据类型
int x = 10;
x = 100;
System.out.println(x);
final int y = 10;
//无法为最终变量y分配值
//y = 100;
System.out.println(y);
System.out.println("--------------");

//局部变量是引用数据类型
Student s = new Student();
System.out.println(s.age);
s.age = 100;
System.out.println(s.age);
System.out.println("--------------");

final Student ss = new Student();
System.out.println(ss.age);
ss.age = 100;
System.out.println(ss.age);

//重新分配内存空间
//无法为最终变量ss分配值
ss = new Student();
}
}

/*
final修饰变量的初始化时机
A:被final修饰的变量只能赋值一次。
B:在构造方法完毕前。(非静态的常量)
*/
class Demo {
//int num = 10;
//final int num2 = 20;

int num;
final int num2;

public Demo() {
num = 100;
num2 = 200; //num2 = 200
}
}

class FinalTest2 {
public static void main(String[] args) {
Demo d = new Demo();
System.out.println(d.num);
System.out.println(d.num2);
}
}