欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

JAVA中的final关键字用法实例详解

程序员文章站 2024-03-08 14:11:04
本文实例讲述了java中的final关键字用法。分享给大家供大家参考,具体如下: 根据上下文环境,java的关键字final也存在着细微的区别,但通常指的是“这是无法改变...

本文实例讲述了java中的final关键字用法。分享给大家供大家参考,具体如下:

根据上下文环境,java的关键字final也存在着细微的区别,但通常指的是“这是无法改变的。”不想改变的理由有两种:一种是效率,另一种是设计。由于两个原因相差很远,所以关键子final可能被误用。

接下来介绍一下使用到final的三中情况:数据,方法,类

final数据

许多编程语言都有某种方法,来向编译器告知一块数据是恒定不变的。有时数据的恒定不变是很有用的,例如:

1. 一个编译时恒定不变的常量
2. 一个在运行时初始化,而你不希望它被改变。

对于编译期常量的这种情况,编译器可以将该常量值代入任何可能用到它的计算式中,也就是说,可以在编译期就执行计算式,这减轻了一些运行时的负担。在java中,这类常量必须是基本类型,并且以final表示。在对这个常量定义时,必须进行赋值。

一个即是static又是final的域只占一段不能改变的存储空间。

当final应用于对象引用时,而不是基本类型时,其含义有些让人疑惑。对基本类型使用final不能改变的是他的数值。而对于对象引用,不能改变的是他的引用,而对象本身是可以修改的。一旦一个final引用被初始化指向一个对象,这个引用将不能在指向其他对象。java并未提供对任何对象恒定不变的支持。这一限制也通用适用于数组,它也是对象。例如:

package finalpackage;
import java.util.*;
class value {
  int i;
  public value(int i) {
    this.i = i;
  }
}
/**
 * final数据常量
 * @author administrator
 * 对基本类型使用final不能改变的是它的数值。
 * 而对于对象引用,不能改变的是他的引用,而对象本身是可以修改的。
 * 一旦一个final引用被初始化指向一个对象,这个引用将不能在指向其他对象。 
 * 注意,根据惯例,即是static又是final的域(即编译器常量)将用大写表示,并用下划分割个单词。
 */
public class finaldata {
  private static random rand = new random(47);
  private string id;
  public finaldata(string id) {
    this.id = id;
  }
  // 编译时常量 can be compile-time constants:
  private final int valueone = 9;
  private static final int value_two = 99;
  // 典型的公共常量 typical public constant:
  public static final int value_three = 39;
  // 运行时常量 cannot be compile-time constants:
  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);
  // 数组 arrays:
  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.valueone++; // error: can't change value
    fd1.v2.i++; // object isn't constant!
    fd1.v1 = new value(9); // ok -- not final
    for (int i = 0; i < fd1.a.length; i++)
      fd1.a[i]++; // object isn't constant!
    // ! fd1.v2 = new value(0); // error: can't
    // ! fd1.val_3 = new value(1); // change reference
    // ! fd1.a = new int[3];
    system.out.println(fd1);
    system.out.println("creating new finaldata");
    finaldata fd2 = new finaldata("fd2");
    system.out.println(fd1);
    system.out.println(fd2);
  }
  /**
   * 输出结果:
   * fd1: i4 = 15, int_5 = 18
   * creating new finaldata
   * fd1: i4 = 15, int_5 = 18
   * fd2: i4 = 13, int_5 = 18
   */
}

由于valueone和value_two都是带有编译时数值的final基本类型,所以它们二者均可以用作编译期常量,并且没有重大区别。value_three是一种更加典型的对常量进行定义的方式:定义为public,可以被任何人访问;定义为static,则强调只有一份;定义为final,这说明它是个常量。请注意带有恒定初始值的final static基本类型全用大写字母命名,并且字母与字母之间用下划线隔开。

我们不能因为某些数据是final的就认为在编译时可以知道它的值。在运行时使用随机数来初始化i4和int_5的值说明了这一点。实例中fd1和fd2中i4的值是唯一的,每次都会被初始化为15,13。int_5的值是不可以通过创建第二个finaldata对象加以改变的。这是因为他是static的,在装载类时(也就是第一次创建这个类对象时)已经被初始化,而不是每次创建都初始化。

java也许生成"空白final",所谓空白final是指被声明为final但又未给初值的域。无论什么情况下编译器都会保证final域在使用前初始化。但空白final在final的使用上提供了很大的灵活性,为此,一个final域可以根据某些对象有所不同,却又保持恒定不变的特性。下面的事例说明了一点:

package finalpackage;
class poppet {
  private int i;
  poppet(int ii) {
    i = ii;
  }
  public int geti() {
    return i;
  }
  public void seti(int i) {
    this.i = i;
  }
}
/**
 * 空白final
 * @author administrator
 * 所谓空白final是指被声明为final但又未给初值的域。无论什么情况下编译器都会保证final域在使用前初始化。
 */
public class blankfinal {
  private final int i = 0; // initialized final
  private final int j; // blank final
  private final poppet p; // blank final reference
  // blank finals must be initialized in the constructor:
  public blankfinal() {
    j = 1; // initialize blank final
    p = new poppet(1); // initialize blank final reference
  }
  public blankfinal(int x) {
    j = x; // initialize blank final
    p = new poppet(x); // initialize blank final reference
  }
  public static void main(string[] args) {
    blankfinal b1=new blankfinal();
    blankfinal b2=new blankfinal(47);
    system.out.println("b1.j="+b1.j+"\t\t b1.p.i="+b1.p.geti());
    system.out.println("b2.j="+b2.j+"\t\t b2.p.i="+b2.p.geti());
  }
  /**
   * 输出结果:
   * b1.j=1     b1.p.i=1
   * b2.j=47     b2.p.i=47
   */
} 

final参数

java中也许将参数列表中的参数以声明的方式声指明为final。这意味着你无发改变参数所指向的对象。例如:

package finalpackage;
class gizmo {
  public void spin(string temp) {
    system.out.println(temp+" method call gizmo.spin()");
  }
}
/**
 * final参数
 * @author administrator
 * 如果将参数列表中的参数指明为final,这意味着你无发改变参数所指向的对象的引用。
 */
public class finalarguments {
  void with(final gizmo g) {
    // ! g = new gizmo(); // illegal -- g is final
  }
  void without(gizmo g) {
    g = new gizmo(); // ok -- g not final
    g.spin("without");
  }
  // void f(final int i) { i++; } // can't change
  // you can only read from a final primitive:
  int g(final int i) {
    return i + 1;
  }
  public static void main(string[] args) {
    finalarguments bf = new finalarguments();
    bf.without(null);
    bf.with(null);
    system.out.println("bf.g(10)="+bf.g(10));
  }
  /**
   * 输出结果:
   * withoutmethod call gizmo.spin()
   * bf.g(10)=11
   */
} 

使用final方法有两个原因。第一个原因是把方法锁定,以防止任何继承它的类修改它的含义。这是出于设计的考虑:想要确保在继承中使用的方法保持不变,并且不会被覆盖。

过去建议使用final方法的第二个原因是效率。在java的早期实现中,如果将一个方法指明为final,就是同意编译器将针对该方法的所有调用都转为内嵌调用。当编译器发现一个final方法调用命令时,它会根据自己的谨慎判断,跳过插入程序代码这种正常的调用方式而执行方法调用机制(将参数压入栈,跳至方法代码处执行,然后跳回并清理栈中的参数,处理返回值),并且以方法体中的实际代码的副本来代替方法调用。这将消除方法调用的开销。当然,如果一个方法很大,你的程序代码会膨胀,因而可能看不到内嵌所带来的性能上的提高,因为所带来的性能会花费于方法内的时间量而被缩减。

在最近的java版本中,虚拟机(特别是hotspot技术)可以探测到这些情况,并优化去掉这些效率反而降低的额外的内嵌调用,因此不再需要使用final方法来进行优化了。事实上,这种做法正逐渐受到劝阻。在使用java se5/6时,应该让编译器和jvm去处理效率问题,只有在想明确禁止覆盖式,才将方法设置为final的。

final和private关键字

类中的所有private方法都是隐式的制定为final的。由于你无法访问private方法你也就无法覆盖它。可以对private方法添加final修饰词,但这毫无意义。例如:

package finalpackage;
/**
 * final和private关键字 
 * 
 * 类中的所有private方法都是隐式的制定为final的。
 * 由于你无法访问private方法,所以你也就无法覆盖它。
 * 可以对private方法添加final修饰词,但这毫无意义。
 */
class withfinals {
  // identical to "private" alone:
  private final void f() {
    system.out.println("withfinals.f()");
  }
  // also automatically "final":
  private void g() {
    system.out.println("withfinals.g()");
  }
}
class overridingprivate extends withfinals {
  private final void f() {
    system.out.println("overridingprivate.f()");
  }
  private void g() {
    system.out.println("overridingprivate.g()");
  }
}
class overridingprivate2 extends overridingprivate {
  public final void f() {
    system.out.println("overridingprivate2.f()");
  }
  public void g() {
    system.out.println("overridingprivate2.g()");
  }
}
public class overidefinal {
  public static void main(string[] args) {
    withfinals w1 = new withfinals();
    // ! w1.f(); //error,无法访问私有方法
    // ! w1.g(); //error,无法访问私有方法
    overridingprivate w2 = new overridingprivate();
    // ! w2.f(); //error,无法访问私有方法
    // ! w2.g(); //error,无法访问私有方法
    overridingprivate2 w3 = new overridingprivate2();
    w3.f();
    w3.g();
  }
  /**
   * 输出结果:
   * overridingprivate2.f()
   * overridingprivate2.g()
   */
}

"覆盖"只有在某方法是基类接口的一部分时才会发生。即,必须将一个对象向上转型为它的基类并调用相同的方法。如果某方法是private的,它就不是基类接口的一部分。它仅是一些隐藏于类中的程序代码,如果一个基类中存在某个private方法,在派生类中以相同的名称创建一个public,protected或包访问权限方法的话,该方法只不过是与基类中的方法有相同的名称而已,并没有覆盖基类方法。由于private方法无法触及而且能有效隐藏,所以除了把它看成是因为它所归属的类的组织结构的原因而存在外,其他任何事物都不需要考虑它。

final 类

当将类定义为final时,就表明了你不打算继承该类,而且也不许别人这样做。换句话说,出于某种考虑,你对该类的设计永不需要做任何变动,或者出于安全的考虑,你不希望他有子类。例如:

package finalpackage;
class smallbrain {
}
final class dinosaur {
  int i = 7;
  int j = 1;
  smallbrain x = new smallbrain();
  void f() {
    system.out.println("dinosaur.f()");
  }
}
// ! class further extends dinosaur {}
// error: cannot extend final class 'dinosaur'
/**
 * final 类
 * 
 * final类中的属性可以选择是否定义为final
 * final类中的方法都隐式的制定为final方法,因此你无法覆盖他们
 */
public class jurassic {
  public static void main(string[] args) {
    dinosaur n = new dinosaur();
    n.f();
    n.i = 40;
    n.j++;
    system.out.println("n.i="+n.i);
    system.out.println("n.j="+n.j);
  }
  /**
   * 输出结果为:
   * dinosaur.f()
   * n.i=40
   * n.j=2
   */
}

请注意,final类的域可以根据个人的意愿选择是或不是final。不论类是否被定义为final,相同的规则同样适用于定义为final的域。然而,由于final是无法继承的,所以被final修饰的类中的方法都隐式的制定为fianl,因为你无法覆盖他们。在fianl类中可以给方法添加final,但这不会产生任何意义。

结论:

根据程序上下文环境,java关键字final有“这是无法改变的”或者“终态的”含义,它可以修饰非抽象类、非抽象类成员方法和变量。你可能出于两种理解而需要阻止改变:设计或效率。
final类不能被继承,没有子类,final类中的方法默认是final的。
final方法不能被子类的方法覆盖,但可以被继承。
final成员变量表示常量,只能被赋值一次,赋值后值不再改变。
final不能用于修饰构造方法。
注意:父类的private成员方法是不能被子类方法覆盖的,因此private类型的方法默认是final类型的。

希望本文所述对大家java程序设计有所帮助。