类的继承和super关键字

类的继承和super关键字

100

• 任务要求
• 参考答案
• 重置记录
• 评论12

• 任务描述
• 相关知识
  • 1. 继承的描述
  • 2. super关键字&函数覆盖
• 编程要求
• 测试说明

---

任务描述

本关任务：认识java继承，了解super关键字的用法及父类方法的重写

1.编写Dog类继承Animal类，并在构造方法中调用父类构造方法

2.重写父类shout方法，方法体为打印输出：String.format("%s发出汪汪叫", this.name)

3.添加public void superShout()方法，方法体为：调用父类shout方法

相关知识

1. 继承的描述

在现实生活中，继承一般指的是子女继承父辈的财产。在程序中，继承描述的是事物之间的所属关系，通过继承可以使多种事物之间形成一种关系体系。例如猫和狗都属于动物，程序中便可以描述为猫和狗继承自动物，同理，波斯猫和巴厘猫继承自猫，而沙皮狗和斑点狗继承自狗。这些动物之间会形成一个继承体系，具体如下图所示。

在Java中，类的继承是指在一个现有类的基础上去构建一个新的类，构建出来的新类被称作子类，现有类被称作父类，子类会自动拥有父类所有可继承的属性和方法。在程序中，如果想声明一个类继承另一个类，需要使用extends关键字。

通过 extends 关键字让类与类之间产生继承关系。

多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。多个类可以称为子类，单独这个类称为父类或者超类。

注意事项：

• 子类可以直接访问父类中的非私有的属性和行为。
• 子类无法继承父类中私有的内容。
• 父类怎么来的？共性不断向上抽取而来的。

示例：

1. class Person{
2. String name;
3. int age ;
4. }
5. class Student extends Person{
6. void study(){
7. System.out.println("student study..." + age);
8. }
9. }
10. class Worker extends Person{
11. void work(){
12. System.out.println("worker work..." + age);
13. }
14. }
15. class ExtendDemo{
16. public static void main(String[] args){
17. Student s = new Student();
18. s. name = "zhangsan" ;
19. s. age = 20;
20. s.study();
21. Worker w = new Worker();
22. w. name = "lisi" ;
23. w. age = 30;
24. w.work();
25. }
26. }

运行结果：

好处：

• 继承的出现提高了代码的复用性。
• 继承的出现让类与类之间产生了关系，提供了多态的前提。

2. super关键字&函数覆盖

在继承关系中，子类会自动继承父类中定义的方法，但有时在子类中需要对继承的方法进行一些修改，即对父类的方法进行重写。需要注意的是，在子类中重写的方法需要和父类被重写的方法具有相同的方法名、参数列表以及返回值类型。

当子类重写父类的方法后，子类对象将无法访问父类被重写的方法，为了解决这个问题，在Java中专门提供了一个super关键字用于访问父类的成员。例如访问父类的成员变量、成员方法和构造方法。

在子父类中，成员的特点体现：

成员变量

• this和super的用法很相似
• this代表本类对象的引用
• super代表父类的内存空间的标识
• 当本类的成员和局部变量同名用this区分
• 当子父类中的成员变量同名用super区分父类

示例：

1. class Fu{
2. private int num = 4;
4. public int getNum(){
5. return num ;
6. }
7. }
9. class Zi extends Fu{
10. private int num = 5;
12. void show(){
13. System.out.println(this.num + "..." + super.getNum());
14. }
15. }
17. class ExtendDemo{
18. public static void main(String[] args){
19. Zi z = new Zi();
20. z.show();
21. }
22. }

运行结果

成员函数

当子父类中出现成员函数一模一样的情况，会运行子类的函数。这种现象，称为覆盖操作，这是函数在子父类中的特性。

在子类覆盖方法中，继续使用被覆盖的方法可以通过super.函数名获取。

函数两个特性：

1. 重载，同一个类中。

2. 覆盖，子类中，覆盖也称为重写，覆写，override。

示例：

1. class Fu{
2. public void show(){
3. System.out.println("fu show run" );
4. }
5. }
7. class Zi extends Fu{
8. public void show(){
9. System.out.println("zi show run" );
10. }
11. }
13. class ExtendDemo{
14. public static void main(String[] args){
15. Zi z = new Zi();
16. z.show();
17. }
18. }

运行结果：

什么时候使用覆盖操作？

当子类需要父类的功能，而功能主体子类有自己特有内容时，可以复写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容。

示例：

1. class Phone{
2. void call(){}
3. void show(){
4. System.out.println("number" );
5. }
6. }
8. class NewPhone extends Phone{
9. void show(){
10. System.out.println("name" );
11. System.out.println("pic" );
12. super.show();
13. }
14. }
16. class ExtendDemo{
17. public static void main(String[] args){
18. NewPhone p = new NewPhone();
19. p.show();
20. }
21. }

运行结果：

注意事项：

• 父类中的私有方法不可以被覆盖
• 父类为static的方法无法覆盖
• 覆盖时，子类方法权限一定要大于等于父类方法权限

编程要求

根据提示，在右侧编辑器补充代码，认识java继承，了解super关键字的用法及父类方法的重写

1.编写Dog类继承Animal类，并在构造方法中调用父类构造方法

2.重写父类shout方法，方法体为打印输出：String.format("%s发出汪汪叫", this.name)

3.添加public void superShout()方法，方法体为：调用父类shout方法

package step1;


class Animal{

    String name;
    public void shout(){
        System.out.println(this.name + "发出叫声");
    }

    public Animal(String name) {
        this.name = name;
    }
}

// ---------------------Begin------------------------
//编写Dog类继承Animal类，重写shout方法，增加superShout方法
public class Dog extends Animal{
    public void shout(){
        System.out.println(String.format("%s发出汪汪叫",this.name));
    }
    public void superShout(){
        super.shout();
    }
    Dog(String na){
        super(na);
    }
}


// ---------------------End------------------------