Educoder--Java面向对象（第三章综合练习）-封装继承和多态的综合练习参考代码_根据提示,在右侧编辑器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中方法的重写的两同两小一大原则

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