Java中的final关键字详解

Java中的final关键字详解

在一个运行时被初始化的值，你不希望它被改变，或者你需要一个编译时永不改变的常量，这时候就要用到final关键字。Final关键字的使用方式有以下几种：

1. final修饰变量，那么该变量相当于一个常量值，在初始化之后保持不变。

2. final修饰方法，那么该方法不能被重写，继承时不能被子类覆盖。

3. final修饰类，该类不能够被继承。

4. final用于对象引用时，使对象引用恒定不变，而该对象本身可以改变。

5. final与private的关系。

下面是结构图：



围绕着结构图来展开详细的讲解final:

一：final+类。

public final class FinalTest {
public FinalTest() {

}
}

class myFinalTest extends FinalTest {
public myFinalTest() {

}
}

定义myFinalTest 继承FinalTest此时编译器会报以下错误：

The type myFinalTest cannot subclass the final class FinalTest。就是说不能够继承final修饰的类。

二：final+方法。final修饰方法时，方法不能被重写和覆盖。

class Animal{
public final void bark()
{
System.out.println("animal bark!");
}
}
class Dog extends Animal{
public void bark()
{
System.out.println("dog bark");
}
}

编译器报出异常：

Multiple markers at this line

- overrides finalTest.Animal.bark

- Cannot override the final method from Animal

也就是说不能够重载父类的final方法

三：final+基本数据类型。相当于定义了一个常量值，该值一旦被初始化后就不能再被改变。

class Animal{
final int i=8;
public final void bark()
{
System.out.println("animal bark!");
}
}
public class FinalTest{
public static void main(String[] args) {
Animal animal=new Animal();
animal.i=6;
}
}

Aniaml 中定义了一个final类型的变量i初值为8，然后又在FinalTest中为其赋值为此时编译器会提示以下错误：

The final field Animal.i cannot be assigned。

也就是说final修饰的域初始化之后不能再赋值，final修饰的域只能在构造函数中为其赋值，也就是初始化的时候为其赋值。

四：final+对象引用。final修饰的对象引用只能指向唯一的对象，而对象本身的值可以改变。

class Animal{
int i=0;
String name="dog";
public final void bark()
{
System.out.println("animal bark!");
}
}
public class FinalTest{
public static void main(String[] args) {
final Animal animal=new Animal();
animal.i=10;//可以给animal.i赋值为10。
animal.name="pig";//给animal.name赋值为pig,也没有问题
animal=new Animal();//animal指向一个新的对象会报出异常。
}
}

animal=new Animal();此处会报出：

The final local variable animal cannot be assigned. It must be blank and not using a compound assignment

五：空白final。空白final在final关键字的使用上提供了更加灵活的方法，使一个类中的final域可以根据对象的不同而不同，但是每个对象一旦初始化final 域的值之后，该对象的final域的值不可变。

class dog {
private int dognum;
dog(int dognum) {
this.dognum = dognum;
System.out.println("dognum:" + dognum);
}
}

public class FinalTest {
private final int j;//定义一个空白的域
private final dog d;//定义一个空白的对象引用。该对象引用不能再指向其他对象。
public FinalTest(int x) {
j = x;
d = new dog(x);
}

public static void main(String[] args) {
FinalTest finaltest = new FinalTest(5);
}
}

六：Private与final的联系，所有的private方法都隐式指定为final都无法覆盖。

class Animal{
private int i=0;
private String name="dog";
private void bark()
{
System.out.println("animal bark!");
}
}
class Dog extends Animal{
public void bark()
{
System.out.println("dog bark!");
}
}
public class FinalTest{
public static void main(String[] args) {
final Animal dog=new Dog();
dog.bark();//此处有异常The method bark() from the type Animal is not visible
}
}

上面使用多态但是调用dog.bark()时报错，说明private修饰的方法并不能被子类覆盖。