Java继承和多态之final关键字

学习-Java继承和多态之final关键字

• 简而言之：
• final放在类声明的前面，就代表其内所有方法均为final方法
• final类不可以被别人继承，也就是说他没有子类
• final方法不可以被重写
• final变量为常量且在定义时就应该赋初值并在之后不允许被改变。

100

特别注意下列代码：

• 声明成员变量一般来说是不需要赋初值的，但是，若是final型，则需要
• 尤其是final型对象，需要其引用型值。并且在声明时已经申请后不可以再次在main中申请
• 数组型直接赋值，不可以有具体的大小哦。a【】中不可以有具体数/

/**
 * 按照代码文件中提供的注释完成 Demo 类的编写，使得程序正常输出。
 */
class DemoTest{
    int i = 10;
}
// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
/********* Begin *********/

// 将Demo类改为 final形式
class Demo{
    // 定义一个final、static常量，名为PI，值为3.14
    static final double PI=3.14;
    // 声明一个final类型的DemoTest对象，命名为demoTest
    final DemoTest demoTest=new DemoTest();
    // 声明一个不为final类型的DemoTest对象，命名为demoTest2
    DemoTest demoTest2;
    // 声明一个final型的数组，类型为int，值为 1,2,3，命名为a
    final int a[]={9,9,9};
    // 删除主函数中错误的代码，使得程序能够正确输出
    public static void main(String[] args) {
        Demo demo = new Demo();
        //demo.demoTest = new Test();
        System.out.println(demo.PI);
        demo.demoTest2 = new DemoTest();
        System.out.println(demo.demoTest2.i);
        for (int i = 0; i < demo.a.length; i++){
            
            System.out.println(demo.a[i]);
        }
    }
}
/********** End **********/

 

• 任务要求
• 参考答案
• 评论32

• 任务描述
• 相关知识
  • final 关键字的使用
  • final 关键字修饰类、成员变量和成员方法
• 编程要求
• 测试说明

---

任务描述

本关任务：调试代码，对代码进行增添、删除和修改等操作，使得程序能够正常运行，输出结果请参照预期输出结果。

相关知识

为了完成本关任务，你需要掌握：1. final关键字的使用； 2. final 关键字修饰类、成员变量和成员方法。

final 关键字的使用

在 Java 中声明类、属性和方法时，可使用关键字 final 来修饰。

• final 标记的类不能被继承；

• final 标记的方法不能被子类复写；

• final 标记的变量（成员变量或局部变量）即为常量，只能赋值一次。

final 关键字修饰类、成员变量和成员方法

1. final 修饰类；

final 用来修饰一个类，意味着该类成为不能被继承的最终类。出于安全性的原因和效率上的考虑，有时候需要防止一个类被继承。例如，Java 类库中的 String类，它对编译器和解释器的正常运行有着很重要的作用，不能轻易改变它，因此把它修饰为 final 类，使它不能被继承，这就保证了 String 类的惟一性。同时，如果你认为一个类的定义己经很完美，不需要再生成它的子类，这时也应把它修饰为 final 类。 定义一个 final 类的格式如下:

1. final class ClassName{
2. ...
3. }

注意：声明为 final 的类隐含地声明了该类的所有方法为 final 方法。

下面是一个 final 类的例子:

1. final class A{
2. ...
3. }
4. class B extends A{// 错误！不能继承A
5. ...
6. }

1. final 修饰成员变量；

变量被声明为 final 后，成为常值变量(即常量)，一旦被通过某种方式初始化或赋值，即不能再被修改。通常 static 与 final 一起使用来指定一个类常量。例如:

1. static final int SUNDAY=0;

final 变量一般用大写字母和下划线来表示，这是一种编码规定。

1. final 修饰成员方法；

用 final 修饰的方法为最终方法，不能再被子类重写，可以被重载。 尽管方法重写是 Java 非常有力的特征，但有时却需要避免这种情况的发生。为了不允许一个方法被重写，在方法的声明中指定 final 属性即可。例如:

1. class A{
2. final void method(){}
3. }
4. class B extends A{// 定义A类的一个子类B
5. void method(){}// 错误，method()不能被重写
6. }

该例中，因为 method() 方法在 A 中被声明为 final ，所以不能在子类 B 中被重写。如果这样做，将导致编译错误。 方法被声明为 final 有时可以提高性能：编译器可以自由地内联调用它们，因为它“知道”它们不会被子类重写。

/**
 *  调试代码，对代码进行增添、删除和修改等操作，使得程序能够正常运行，输出结果请参照预期输出结果。
 */

// 请在下面的Begin-End之间编写正确的代码
/********* Begin *********/
public class Demo {
    public static void main(String args[]) {
        Bike1 obj = new Bike1();
        obj.run();
        Honda honda = new Honda();
        honda.run();
        Yamaha yamaha = new Yamaha();
        yamaha.run();
    }
}


class Bike1 {

     int speedlimit = 90; // 定义速度限制

    void run() {
    	// 修改速度限制为 120，并输出
        speedlimit = 120;
        System.out.println("speedlimit=120");
    }
}

class Bike2 {
	// 输出 running
    void run() {
        System.out.println("running");
    }
}
// 继承 Bike2 类
class Honda extends Bike2 {
	// 重写 run 方法
    void run() {
        System.out.println("running safely with 100kmph");
    }

}

 class Bike3 {
}
// 继承 Bike3 类
class Yamaha extends Bike3 {
    void run() {
        System.out.println("running safely with 10kmph");
    }
}
/********** End **********/