当前位置:   article > 正文

Educoder--Java面向对象(第三章综合练习)-封装继承和多态的综合练习参考代码_根据提示,在右侧编辑器begin-end处补充代码: 声明一个抽象类pet,封装属性name和se

根据提示,在右侧编辑器begin-end处补充代码: 声明一个抽象类pet,封装属性name和se

Educoder–Java面向对象(第三章综合练习)-封装继承和多态的综合练习【笔记+参考代码】

第一关

编程要求
根据提示,在右侧编辑器Begin-End处补充代码:

声明一个抽象类Pet,封装属性name和sex,声明一个带有两个参数的构造函数,声明抽象方法void talk()和void eat();

声明一个Dog类继承自Pet,封装属性color,声明带有三个参数的构造函数,复写talk()和eat()方法;

声明一个Cat类继承自Pet,封装属性weight,声明带有三个参数的构造函数,复写talk()和eat()方法;

编写测试类,通过有参构造函数实例化Dog类对象,调用talk()方法和eat()方法;通过有参构造函数实例化Cat类对象
,调用talk()方法和eat()方法;

具体输出要求请看测试说明。


测试说明 测试输入:

泰迪

male

brown

波斯猫

male

2.5

预期输出:

名称:泰迪,性别:male,颜色:brown,汪汪叫

泰迪吃骨头!

名称:波斯猫,性别:male,体重:2.5kg,喵喵叫

波斯猫吃鱼!

参考代码

package case1;
import java.util.Scanner;
public class Task1 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String dogName = sc.next();
        String dogSex = sc.next();
        String dogColor = sc.next();
        String catName = sc.next();
        String catSex = sc.next();
        double catWeight = sc.nextDouble();
        // 通过有参构造函数实例化Dog类对象dog
        // dog调用talk()方法
        // dog调用eat()方法
        /********* begin *********/
        Dog dog = new Dog(dogName, dogSex, dogColor);
        dog.talk();
        dog.eat();
        /********* end *********/
        // 通过有参构造函数实例化Cat类对象cat
        // cat调用talk()方法
        // cat调用eat()方法
        /********* begin *********/
        Cat cat = new Cat(catName, catSex, catWeight);
        cat.talk();
        cat.eat();
        /********* end *********/
    }
}
// 抽象类Pet 封装属性name和sex
// 构造函数初始化name和sex
// 声明抽象方法talk()
// 声明抽象方法eat()
abstract class Pet {
    /********* begin *********/
    private String name;
    private String sex;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    public Pet(String name, String sex) {
        this.name = name;
        this.sex = sex;
    }
    public abstract void talk();
    public abstract void eat();
    /********* end *********/
}
// Dog类继承自Pet类 封装属性color
// 构造函数初始化name、sex和color
// 实现自己的talk()方法和eat()方法
// talk()输出'名称:name,性别:sex,颜色:color,汪汪叫'
// eat()输出'name吃骨头'
class Dog extends Pet {
    /********* begin *********/
    private String color;
    public String getColor() {
        return color;
    }
    public void setColor(String color) {
        this.color = color;
    }
    public Dog(String name, String sex, String color) {
        super(name, sex);
        this.color = color;
    }
    public void talk() {
        System.out.println("名称:" + this.getName() + ",性别:" + this.getSex()
                + ",颜色:" + this.getColor() + ",汪汪叫");
    }
    public void eat() {
        System.out.println(this.getName() + "吃骨头!");
    }
    /********* end *********/
}
// Cat类继承自Pet类 封装属性weight
// 构造函数初始化name、sex和weight
// 实现自己的talk()方法和eat()方法
// talk()输出'名称:name,性别:sex,体重:weight kg,喵喵叫'
// eat()输出'name吃鱼'
class Cat extends Pet {
    /********* begin *********/
    private double weight;
    public double getWeight() {
        return weight;
    }
    public void setWeight(double weight) {
        this.weight = weight;
    }
    public Cat(String name, String sex, double weight) {
        super(name, sex);
        this.weight = weight;
    }
    public void talk() {
        System.out.println("名称:" + this.getName() + ",性别:" + this.getSex()
                + ",体重:" + this.getWeight() + "kg" + ",喵喵叫");
    }
    public void eat() {
        System.out.println(this.getName() + "吃鱼!");
    }
    /********* end *********/
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111

此处涉及Java继承中类型转换的两种方式
  1. 将子类对象转换成父类类型,例如:
    Pet pet=new Dog();
    此类型转换为自动转换
    因为子类的功能比父类更加强大,因此可以自动转换完成
  2. 将父类对象转换为子类类型,例如:
    Pet pet=new Pet();
    Dog dog=(Dog)pet;
    此类型转换为强制转换
    因为父类的功能要弱于子类,因此需要强制转换


第二关

编程要求

按照要求编写一个Java应用程序:

定义一个抽象类Person,包含抽象方法eat(),封装属性name、sex、age,声明包含三个参数的构造方法;

定义一个Chinese类,继承自Person类,重写父类的eat()方法,并定义一个自己特有的方法shadowBoxing();

定义一个English类,继承自Person类,重写父类的eat()方法,并定义一个自己特有的方法horseRiding();

编写测试类,定义一个showEat()方法,使用父类作为方法的形参,实现多态,分别调用showEat()方法,通过强制类型转换调用各自类特有的方法;

具体输出要求请看测试说明。


测试说明 测试输入:

张三

20

史蒂文

22


预期输出:

姓名:张三,性别:男,年龄:20,我是中国人,我喜欢吃饭!

姓名:史蒂文,性别:男,年龄:22,我是英国人,我喜欢吃三明治!

张三在练习太极拳!

史蒂文在练习骑马!


参考代码

package case2;
import java.util.Scanner;
public class Task2 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String cName = sc.next();
        String cSex = sc.next();
        int cAge = sc.nextInt();
        String eName = sc.next();
        String eSex = sc.next();
        int eAge = sc.nextInt();
        // 创建测试类对象test
        // 创建Person类对象person1,引用指向中国人,通过有参构造函数实例化中国人类对象
        // 通过showEat()方法调用Chinese的eat()方法
        // 创建Person类对象person2,引用指向英国人,通过有参构造函数实例化英国人类对象
        // 通过showEat()方法调用English的eat()方法
        /********* begin *********/
        Task2 test = new Task2();
        Person person1 = new Chinese(cName, cSex, cAge);
        test.showEat(person1);
        Person person2 = new English(eName, eSex, eAge);
        test.showEat(person2);
        /********* end *********/
        // 强制类型转换(向下转型) 调用Chinese类特有的方法shadowBoxing()
        // 强制类型转换(向下转型) 调用English类特有的方法horseRiding()
        /********* begin *********/
        Chinese chinese = (Chinese) person1;
        chinese.shadowBoxing();
        English english = (English) person2;
        english.horseRiding();
        /********* end *********/
    }
    // 定义showEat方法,使用父类作为方法的形参,实现多态,传入的是哪个具体对象就调用哪个对象的eat()方法
    /********* begin *********/
    public void showEat(Person person) {
        person.eat();
    }
    /********* end *********/
}
// 抽象类Person 封装属性name、sex和age
// 构造函数初始化name、sex和age
// 声明抽象方法eat()
abstract class Person {
    /********* begin *********/
    private String name;
    private String sex;
    private int age;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public Person(String name, String sex, int age) {
        this.name = name;
        this.sex = sex;
        this.age = age;
    }
    public abstract void eat();
    /********* end *********/
}
// Chinese类继承自Person类
// 构造函数初始化name、sex和age
// 重写父类方法eat() 输出'姓名:name,性别:sex,年龄:age,我是中国人,我喜欢吃饭!'
// 定义子类特有方法shadowBoxing(),当父类引用指向子类对象时无法调用该方法 输出'name在练习太极拳!'
class Chinese extends Person {
    /********* begin *********/
    public Chinese(String name, String sex, int age) {
        super(name, sex, age);
    }
    public void eat() {
        System.out.println("姓名:" + this.getName() + ",性别:" + this.getSex()
                + ",年龄:" + this.getAge() + ",我是中国人,我喜欢吃饭!");
    }
    public void shadowBoxing() {
        System.out.println(this.getName() + "在练习太极拳!");
    }
    /********* end *********/
}
// English类继承自Person类
// 构造函数初始化name、sex和age
// 重写父类方法eat() 输出'姓名:name,性别:sex,年龄:age,我是英国人,我喜欢吃三明治!'
// 定义子类特有方法horseRiding(),当父类引用指向子类对象时无法调用该方法 输出'name在练习骑马!'
class English extends Person {
    /********* begin *********/
    public English(String name, String sex, int age) {
        super(name, sex, age);
    }
    public void eat() {
        System.out.println("姓名:" + this.getName() + ",性别:" + this.getSex()
                + ",年龄:" + this.getAge() + ",我是英国人,我喜欢吃三明治!");
    }
    public void horseRiding() {
        System.out.println(this.getName() + "在练习骑马!");
    }
    /********* end *********/
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109



第三关

编程要求 教练和运动员案例:

乒乓球运动员和篮球运动员;

乒乓球教练和篮球教练;

跟乒乓球相关的人员都需要学习英语;

分析,这个案例中有哪些抽象类,哪些接口,哪些具体类。

分析过程如下:


具体输出要求请看测试说明。 测试说明 测试输入:

张继科

30

易建联

31

刘国梁

42

杜锋

37


预期输出:

张继科—30

人都是要睡觉的

乒乓球运动员吃大白菜,喝小米粥

乒乓球运动员学习如何发球和接球

乒乓球运动员说英语


易建联—31

人都是要睡觉的

篮球运动员吃牛肉,喝牛奶

篮球运动员学习如何运球和投篮


刘国梁—42

人都是要睡觉的

乒乓球教练吃小白菜,喝大米粥

乒乓球教练教如何发球和接球

乒乓球教练说英语


杜锋—37

人都是要睡觉的

篮球教练吃羊肉,喝羊奶

篮球教练教如何运球和投篮


参考代码

package case3;
import java.util.Scanner;
public class Task3 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String pppName = sc.next();
        int pppAge = sc.nextInt();
        String bpName = sc.next();
        int bpAge = sc.nextInt();
        String ppcName = sc.next();
        int ppcAge = sc.nextInt();
        String bcName = sc.next();
        int bcAge = sc.nextInt();
        // 测试运动员(乒乓球运动员和篮球运动员)
        // 乒乓球运动员
        // 通过带参构造函数实例化PingPangPlayer对象ppp
        // 输出'name---age'
        // 分别调用sleep()、eat()、study()、speak()方法
        /********* begin *********/
        PingPangPlayer ppp = new PingPangPlayer(pppName, pppAge);
        System.out.println(ppp.getName() + "---" + ppp.getAge());
        ppp.sleep();
        ppp.eat();
        ppp.study();
        ppp.speak();
        /********* end *********/
        System.out.println("----------------");
        // 篮球运动员
        // 通过带参构造函数实例化BasketballPlayer对象bp
        // 输出'name---age'
        // 分别调用sleep()、eat()、study()方法
        /********* begin *********/
        BasketballPlayer bp = new BasketballPlayer(bpName, bpAge);
        System.out.println(bp.getName() + "---" + bp.getAge());
        bp.sleep();
        bp.eat();
        bp.study();
        /********* end *********/
        System.out.println("----------------");
        // 测试教练(乒乓球教练和篮球教练)
        // 乒乓球教练
        // 通过带参构造函数实例化PingPangCoach对象ppc
        // 输出'name---age'
        // 分别调用sleep()、eat()、teach()、speak()方法
        /********* begin *********/
        PingPangCoach ppc = new PingPangCoach(ppcName, ppcAge);
        System.out.println(ppc.getName() + "---" + ppc.getAge());
        ppc.sleep();
        ppc.eat();
        ppc.teach();
        ppc.speak();
        /********* end *********/
        System.out.println("----------------");
        // 篮球教练
        // 通过带参构造函数实例化BasketballCoach对象bc
        // 输出'name---age'
        // 分别调用sleep()、eat()、teach()方法
        /********* begin *********/
        BasketballCoach bc = new BasketballCoach(bcName, bcAge);
        System.out.println(bc.getName() + "---" + bc.getAge());
        bc.sleep();
        bc.eat();
        bc.teach();
        /********* end *********/
        System.out.println("----------------");
    }
}
// 说英语接口 声明抽象方法speak()
interface SpeakEnglish {
    /********* begin *********/
    public abstract void speak();
    /********* end *********/
}
// 定义人的抽象类Person 封装name和age
// 无参构造函数
// 有参构造函数初始化name和age
// 定义具体方法sleep() 输出'人都是要睡觉的'
// 抽象方法eat()(吃的不一样)
abstract class Person {
    /********* begin *********/
    private String name;
    private int age;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public Person() {
    }
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public void sleep() {
        System.out.println("人都是要睡觉的");
    }
    public abstract void eat();
    /********* end *********/
}
// 定义运动员Player(抽象类)继承自Person类
// 无参构造函数
// 有参构造函数初始化name和age
// 运动员学习内容不一样,抽取为抽象 定义抽象方法study()
abstract class Player extends Person {
    /********* begin *********/
    public Player() {
    }
    public Player(String name, int age) {
        super(name, age);
    }
    public abstract void study();
    /********* end *********/
}
// 定义教练Coach(抽象类)继承自Person类
// 无参构造函数
// 有参构造函数初始化name和age
// 教练教的不一样 定义抽象方法teach()
abstract class Coach extends Person {
    /********* begin *********/
    public Coach() {
    }
    public Coach(String name, int age) {
        super(name, age);
    }
    public abstract void teach();
    /********* end *********/
}
// 定义乒乓球运动员具体类PingPangPlayer 继承自Player类并实现SpeakEnglish类(兵乓球运动员需要说英语)
// 无参构造函数
// 有参构造函数初始化name和age
// 实现自己的eat()方法 输出'乒乓球运动员吃大白菜,喝小米粥'
// 实现自己的study()方法 输出'乒乓球运动员学习如何发球和接球'
// 实现自己的speak()方法 输出'乒乓球运动员说英语'
class PingPangPlayer extends Player implements SpeakEnglish {
    /********* begin *********/
    public PingPangPlayer() {
    }
    public PingPangPlayer(String name, int age) {
        super(name, age);
    }
    public void eat() {
        System.out.println("乒乓球运动员吃大白菜,喝小米粥");
    }
    public void study() {
        System.out.println("乒乓球运动员学习如何发球和接球");
    }
    public void speak() {
        System.out.println("乒乓球运动员说英语");
    }
    /********* end *********/
}
// 定义篮球运动员具体类BasketballPlayer 继承自Player类 不需要继承接口,因为他不需要说英语
// 无参构造函数
// 有参构造函数初始化name和age
// 实现自己的eat()方法 输出'篮球运动员吃牛肉,喝牛奶'
// 实现自己的study()方法 输出'篮球运动员学习如何运球和投篮'
class BasketballPlayer extends Player {
    /********* begin *********/
    public BasketballPlayer() {
    }
    public BasketballPlayer(String name, int age) {
        super(name, age);
    }
    public void eat() {
        System.out.println("篮球运动员吃牛肉,喝牛奶");
    }
    public void study() {
        System.out.println("篮球运动员学习如何运球和投篮");
    }
    /********* end *********/
}
// 定义乒乓球教练具体类 PingPangCoach 继承自Coach类并实现SpeakEnglish类(兵乓球教练需要说英语)
// 无参构造函数
// 有参构造函数初始化name和age
// 实现自己的eat()方法 输出'乒乓球教练吃小白菜,喝大米粥'
// 实现自己的teach()方法 输出'乒乓球教练教如何发球和接球'
// 实现自己的speak()方法 输出'乒乓球教练说英语'
class PingPangCoach extends Coach implements SpeakEnglish {
    /********* begin *********/
    public PingPangCoach() {
    }
    public PingPangCoach(String name, int age) {
        super(name, age);
    }
    public void eat() {
        System.out.println("乒乓球教练吃小白菜,喝大米粥");
    }
    public void teach() {
        System.out.println("乒乓球教练教如何发球和接球");
    }
    public void speak() {
        System.out.println("乒乓球教练说英语");
    }
    /********* end *********/
}
// 定义篮球教练具体类BasketballCoach 继承自Coach类 不需要继承接口,因为他不需要说英语
// 无参构造函数
// 有参构造函数初始化name和age
// 实现自己的eat()方法 输出'篮球教练吃羊肉,喝羊奶'
// 实现自己的teach()方法 输出'篮球教练教如何运球和投篮'
class BasketballCoach extends Coach {
    /********* begin *********/
    public BasketballCoach() {
    }
    public BasketballCoach(String name, int age) {
        super(name, age);
    }
    public void eat() {
        System.out.println("篮球教练吃羊肉,喝羊奶");
    }
    public void teach() {
        System.out.println("篮球教练教如何运球和投篮");
    }
    /********* end *********/
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122
  • 123
  • 124
  • 125
  • 126
  • 127
  • 128
  • 129
  • 130
  • 131
  • 132
  • 133
  • 134
  • 135
  • 136
  • 137
  • 138
  • 139
  • 140
  • 141
  • 142
  • 143
  • 144
  • 145
  • 146
  • 147
  • 148
  • 149
  • 150
  • 151
  • 152
  • 153
  • 154
  • 155
  • 156
  • 157
  • 158
  • 159
  • 160
  • 161
  • 162
  • 163
  • 164
  • 165
  • 166
  • 167
  • 168
  • 169
  • 170
  • 171
  • 172
  • 173
  • 174
  • 175
  • 176
  • 177
  • 178
  • 179
  • 180
  • 181
  • 182
  • 183
  • 184
  • 185
  • 186
  • 187
  • 188
  • 189
  • 190
  • 191
  • 192
  • 193
  • 194
  • 195
  • 196
  • 197
  • 198
  • 199
  • 200
  • 201
  • 202
  • 203
  • 204
  • 205
  • 206
  • 207
  • 208
  • 209
  • 210
  • 211
  • 212
  • 213
  • 214
  • 215
  • 216
  • 217
  • 218
  • 219
  • 220
  • 221
  • 222
  • 223

两个容易犯的错误

1、在写子类的构造函数时下方写法报错:Implicit super constructor Person() is undefined. Must explicitly invoke another constructor

abstract class Player extends Person {
	/********* begin *********/
	Player(String name,int age){
		this.name=name;
		this.age=age;
	}
	abstract void study();
	/********* end *********/
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

原因是父类已经定义了一个有参构造函数,子类在继承时应该通过super关键字调用父类的有参构造函数

【继承中构造函数情况总结】

Ⅰ.父类有无参构造函数时(显示或隐式),子类的有参和无参构造函数都是默认调用父类的无参构造函数;
Ⅱ.当父类只有有参构造函数时,子类可以有有参和无参构造函数,子类有参构造函数必须显式调用父类的有参构造函数,子类无参构造函数也必须显式调用父类的有参构造函数,但需给父类有参构造函数赋实参。



2、此处若函数Sting speak()像下方代码不加public属性则会报错

class PingPangCoach extends Coach implements SpeakEnglish {
	/********* begin *********/
	PingPangCoach(String name,int age){
		super(name,age);
	}
	void eat(){
		System.out.println("乒乓球教练吃小白菜,喝大米粥");
	}
	void teach(){
		System.out.println("乒乓球教练教如何发球和接球");
	}
	String speak(){
		return "乒乓球教练说英语";
	}
	/********* end *********/
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

报错内容:
Multiple markers at this line
- Cannot reduce the visibility of the inherited method from
SpeakEnglish
在这里插入图片描述
是因为speak是复写父类的方法,父类是 public ,子类为定义,默认变为了protected,违反了两同两小一大的一大原则。添加public后就不再报错了。

java中方法的重写的两同两小一大原则

方法名相同,参数类型相同
子类返回类型小于等于父类方法返回类型,
子类抛出异常小于等于父类方法抛出异常,
子类访问权限大于等于父类方法访问权限。

声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/小小林熬夜学编程/article/detail/653750
推荐阅读
相关标签
  

闽ICP备14008679号