黑马程序员_基础复习04_final关键字

 ------- android培训、java培训、期待与您交流！ ----------

1、final数据

被final修饰的数据不能被修改，被称为编译期常量。且初始化后不能再被改变

 1)如果基本类型被final修饰，在定义时必须对其进行赋值。  

    final int value = 9;

  如果即被static修饰，又被final修饰，则该基本类型域只占据一段不能改变的存储空间。

    static final int value = 10;

  如果被public static final 修饰，则该常量可以被任何人访问，且只有一份，不能被修改。

public static final int value = 10;

 2)如果对象引用被final修饰，则使其引用恒定不变，一旦被初始化指向某一个对象，则不能被改变去指向另一个对象，但是对象中的值是可以被修改的。数组也是一个引用，同样如此，不能改变引用，但数组中的值可以修改。

 所以final对基本类型的用处比较大。

 下面是以上各种情况的举例：

import java.util.*;

class Value{

  int i;

  public Value(int i){

    this.i = i;

  }

}

public class FinalData {

  private static Random rand = new Random(47);

  private String id;

  public FinalData(String id){

    this.id = id;

  }

  private final int valueOne = 9;//编译期常量

  private static final int VALUE_TWO = 99;//编译时常量

  public static final int VALUE_THREE = 39;//static只有一份，为常量

  private final int i4 = rand.nextInt(20);

  static final int INT_5 = rand.nextInt(20);

  private Value v1 = new Value(11);

  private final Value v2 = new Value(22);

  private static final Value VAL_3 = new Value(33);

  private final int[] a = {1,2,3,4,5,6};

  public String toString(){

    return id + ": " + "i4= " + i4 + " , INT_5 = " + INT_5;

  }

  public static void main(String[] args) {

 

     FinalData fd1 = new FinalData("fd1");

     fd1.v2.i ++;//可以改变v2引用对象的值

     fd1.v1 = new Value(9);//v1未被final修饰，可以重新赋值

     for(int i = 0;ia.length;i++){

        fd1.a[i]++;//可以改变数组引用a中的值

     }

     //fd1.v2 =  new Value(0);//error，不能再次指向其他对象

     //fd1.VAL_3 = new Value(1);//error，不能再次指向其他对象

     //fd1.a = new int[3];//error，被final修饰，不能再次指向其他对象

     //fd1.valueOne++;//error，被final修饰，不能修改值

     System.out.println(fd1);

     System.out.println("Creating new FinalData");

     FinalData fd2 = new FinalData("fd2");

     System.out.println(fd1);

     System.out.println(fd2);

  }

}

有结果可知，i4被final修饰，对创建的对象fd1初始化后，值不会改变。而INT_5被static修饰，值只有一份，不论创建多少个对象，值都是18。

 

空白final

 所谓空白final是指被声明为final但又未给定初值的域。这样可以做到一个类中的final域，根据对象的不同而有所不同，却又能保证其恒定不变的特性。无论什么情况，编译器都确保空白final在使用前被初始化。

其解决方法是在域定义处，或者每个构造器中对final进行赋值。

class Poppet{

   private int i;

   Poppet(int i){

    this.i = i;

   }

}

public class BlackFinal {

   private final int i = 0;

   private final int j;//空白final

   private final Poppet p;//空白final引用

   public BlackFinal(){

     j = 1;//初始化空白final j

     p = new Poppet(1);//初始化空白final引用

   }

   public BlackFinal(int x){

     j = x;

     p = new Poppet(x);

   }

   public static void main(String[] args) {

     new BlackFinal();

     new BlackFinal(47);

   }

}

上次中不同的构造方法使得可以创建不同的对象，不同对象都有各自相应的final值。

2、final方法

使用final方法的原因是把方法锁定，以防止任何继承类修改它和含义。即被final修饰的方法不能被重写。

注意：类中所有的private方法都隐式地指定为final。由于无法取到private方法，所有也就无法覆盖它。对private方法加上final词没有任何额外的意义。

下面举个例子

class WithFinals{

   private final void f(){

     System.out.println("withfinlas.f()");

   }

   private void g(){

     System.out.println("withfinals.g()");

   }

   public final void h(){

      System.out.println("withFinals.h()");

   }

}

class OverridingPrivate extends WithFinals{

    private final void f(){

      System.out.println("OverridingPrivate.f()");

    }

    private void g(){

      System.out.println("OverridingPrivate.g()");

    }

    public final void h(){

      System.out.println("OverridingPrivate.h()");

    }

}

class OverridingPrivate2 extends OverridingPrivate{

    public final void f(){

      System.out.println("OverridingPrivate2.f()");

    }

    public void g(){

      System.out.println("OverridingPrivate2.g()");

    }

    public final void h(){

      System.out.println("OverridingPrivate2.h()");

    }

}

public class FinalOverridingIllusion {

 

    public static void main(String[] args) {

       OverridingPrivate2 op2 = new OverridingPrivate2();

       op2.f();

       op2.g();

       op2.h();

       OverridingPrivate op = op2;

       //op.f();//私有的f()，不能访问

    }

}

OverridingPrivate2中的f()和g()方法看似是重写了继承的OverridingPrivate的方法，可是访问权限是public，而将op2向上转型后无法访问基类的f()和g()方法。

所以，我们在OverridingPrivate2中创建的是一个新的方法，而没有实现重写。因为重写只有在某方法是基类的接口的一部分时才会实现，而如果方法是private，它就不是接口的一部分，只是隐含在类中的程序代码。

例子中的h()方法是public的，用final修饰后，在子类中重写的话会编译时报错。无法重写：Exception in thread "main" java.lang.VerifyError: class unit7.OverridingPrivate overrides final method h.()V

3、final类

被final修饰的类不能被继承，final类中的域可以根据个人的意愿选择是或不是final，并且final类中的方法都隐式定义为final的，无法覆盖它们。

 

总结一下包括继承在内的初始化全过程：

首先加载public类，执行main方法，如果该类继承了别的类，就继续加载基类，直到加载到根基类。接下来根基类的static初始化，然后是下一个导出类，以此类推。

至此，必要的类都加载完毕后，对象就可以创建了。首先，对象中所有的基本类型会被设为默认值，对象引用设为null。然后基类的构造器被调用，调用完成之后，实例变量按次序初始化，最后构造器的其余部分被执行。