Educoder--Java面向对象（第三章综合练习）-封装继承和多态的综合练习参考代码
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 *********/
Pet dog=new Dog(dogName,dogSex,dogColor);
dog.talk();
dog.eat();
/********* end *********/
// 通过有参构造函数实例化Cat类对象cat
// cat调用talk()方法
// cat调用eat()方法
/********* begin *********/
Pet cat=new Cat(catName,catSex,catWeight);
cat.talk();
cat.eat();
/********* end *********/
}
}
// 抽象类Pet 封装属性name和sex
// 构造函数初始化name和sex
// 声明抽象方法talk()
// 声明抽象方法eat()
abstract class Pet {
/********* begin *********/
String name;
String sex;
abstract void talk();
abstract void eat();
/********* end *********/
}
// Dog类继承自Pet类 封装属性color
// 构造函数初始化name、sex和color
// 实现自己的talk()方法和eat()方法
// talk()输出'名称：name，性别：sex，颜色：color，汪汪叫'
// eat()输出'name吃骨头'
class Dog extends Pet {
/********* begin *********/
String color;
Dog(String name,String sex,String color){
this.name=name;
this.sex=sex;
this.color=color;
}
void talk(){
System.out.println("名称："+name+"，性别："+sex+"，颜色："+color+"，汪汪叫");
}
void eat(){
System.out.println(name+"吃骨头！");
}
/********* end *********/
}
// Cat类继承自Pet类 封装属性weight
// 构造函数初始化name、sex和weight
// 实现自己的talk()方法和eat()方法
// talk()输出'名称：name，性别：sex，体重：weight kg，喵喵叫'
// eat()输出'name吃鱼'
class Cat extends Pet {
/********* begin *********/
double weight;
Cat(String name,String sex,double weight){
this.name=name;
this.sex=sex;
this.weight=weight;
}
void talk(){
System.out.println("名称："+name+"，性别："+sex+"，体重："+weight+"kg，喵喵叫");
}
void eat(){
System.out.println(name+"吃鱼！");
}
/********* end *********/
}
此处涉及Java继承中类型转换的两种方式
- 将子类对象转换成父类类型，例如：
Pet pet=new Dog();
此类型转换为自动转换
因为子类的功能比父类更加强大，因此可以自动转换完成 - 将父类对象转换为子类类型，例如：
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 test;
// 创建Person类对象person1,引用指向中国人,通过有参构造函数实例化中国人类对象
Person person1=new Chinese(cName,cSex,cAge);
// 通过showEat()方法调用Chinese的eat()方法
showEat(person1);
// 创建Person类对象person2,引用指向英国人,通过有参构造函数实例化英国人类对象
Person person2=new English(eName,eSex,eAge);
// 通过showEat()方法调用English的eat()方法
showEat(person2);
/********* begin *********/
/********* end *********/
// 强制类型转换(向下转型) 调用Chinese类特有的方法shadowBoxing()
Chinese d=(Chinese)person1;
d.shadowBoxing();
// 强制类型转换(向下转型) 调用English类特有的方法horseRiding()
English e=(English)person2;
e.horseRiding();
/********* begin *********/
/********* end *********/
}
// 定义showEat方法，使用父类作为方法的形参，实现多态，传入的是哪个具体对象就调用哪个对象的eat()方法
/********* begin *********/
public static void showEat(Person p){
p.eat();
}
/********* end *********/
}
// 抽象类Person 封装属性name、sex和age
// 构造函数初始化name、sex和age
// 声明抽象方法eat()
abstract class Person {
/********* begin *********/
public String name;
public String sex;
public int age;
abstract void eat();
/********* end *********/
}
// Chinese类继承自Person类
// 构造函数初始化name、sex和age
// 重写父类方法eat() 输出'姓名：name，性别：sex，年龄：age，我是中国人，我喜欢吃饭！'
// 定义子类特有方法shadowBoxing(),当父类引用指向子类对象时无法调用该方法 输出'name在练习太极拳！'
class Chinese extends Person {
/********* begin *********/
public String name;
public String sex;
public int age;
Chinese(String name,String sex,int age){
this.name=name;
this.sex=sex;
this.age=age;
}
void eat(){
System.out.println("姓名："+name+"，性别："+sex+"，年龄："+age+"，我是中国人，我喜欢吃饭！");
}
void shadowBoxing(){
System.out.println(name+"在练习太极拳！");
}
/********* end *********/
}
// English类继承自Person类
// 构造函数初始化name、sex和age
// 重写父类方法eat() 输出'姓名：name，性别：sex，年龄：age，我是英国人，我喜欢吃三明治!'
// 定义子类特有方法horseRiding(),当父类引用指向子类对象时无法调用该方法 输出'name在练习骑马！'
class English extends Person {
/********* begin *********/
public String name;
public String sex;
public int age;
English(String name,String sex,int age){
this.name=name;
this.sex=sex;
this.age=age;
}
void eat(){
System.out.println("姓名："+name+"，性别："+sex+"，年龄："+age+"，我是英国人，我喜欢吃三明治！");
}
void horseRiding(){
System.out.println(name+"在练习骑马！");
}
/********* end *********/
}
第三关
编程要求 教练和运动员案例：
乒乓球运动员和篮球运动员；
乒乓球教练和篮球教练；
跟乒乓球相关的人员都需要学习英语；
分析，这个案例中有哪些抽象类，哪些接口，哪些具体类。
分析过程如下：
具体输出要求请看测试说明。 测试说明 测试输入：
张继科
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(pppName+"---"+pppAge);
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(bpName+"---"+bpAge);
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(ppcName+"---"+ppcAge);
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(bcName+"---"+bcAge);
bc.sleep();
bc.eat();
bc.teach();
/********* end *********/
System.out.println("----------------");
}
}
// 说英语接口 声明抽象方法speak()
interface SpeakEnglish {
/********* begin *********/
abstract void speak();
/********* end *********/
}
// 定义人的抽象类Person 封装name和age
// 无参构造函数
// 有参构造函数初始化name和age
// 定义具体方法sleep() 输出'人都是要睡觉的'
// 抽象方法eat()（吃的不一样）
abstract class Person {
/********* begin *********/
String name;
int age;
Person(String name,int age){
this.name=name;
this.age=age;
}
void sleep(){
System.out.println("人都是要睡觉的");
}
abstract void eat();
/********* end *********/
}
// 定义运动员Player（抽象类）继承自Person类
// 无参构造函数
// 有参构造函数初始化name和age
// 运动员学习内容不一样，抽取为抽象 定义抽象方法study()
abstract class Player extends Person {
/********* begin *********/
Player(String name,int age){
super(name,age);
}
abstract void study();
/********* end *********/
}
// 定义教练Coach（抽象类）继承自Person类
// 无参构造函数
// 有参构造函数初始化name和age
// 教练教的不一样 定义抽象方法teach()
abstract class Coach extends Person {
/********* begin *********/
Coach(String name,int age){
super(name,age);
}
abstract void teach();
/********* end *********/
}
// 定义乒乓球运动员具体类PingPangPlayer 继承自Player类并实现SpeakEnglish类（兵乓球运动员需要说英语）
// 无参构造函数
// 有参构造函数初始化name和age
// 实现自己的eat()方法 输出'乒乓球运动员吃大白菜，喝小米粥'
// 实现自己的study()方法 输出'乒乓球运动员学习如何发球和接球'
// 实现自己的speak()方法 输出'乒乓球运动员说英语'
class PingPangPlayer extends Player implements SpeakEnglish {
/********* begin *********/
PingPangPlayer(String name,int age){
super(name,age);
}
void eat(){
System.out.println("乒乓球运动员吃大白菜，喝小米粥");
}
void study(){
System.out.println("乒乓球运动员学习如何发球和接球");
}
public void speak(){
System.out.println("乒乓球运动员说英语");
}
/********* end *********/
}
// 定义篮球运动员具体类BasketballPlayer 继承自Player类 不需要继承接口，因为他不需要说英语
// 无参构造函数
// 有参构造函数初始化name和age
// 实现自己的eat()方法 输出'篮球运动员吃牛肉，喝牛奶'
// 实现自己的study()方法 输出'篮球运动员学习如何运球和投篮'
class BasketballPlayer extends Player {
/********* begin *********/
BasketballPlayer(String name,int age){
super(name,age);
}
void eat(){
System.out.println("篮球运动员吃牛肉，喝牛奶");
}
void study(){
System.out.println("篮球运动员学习如何运球和投篮");
}
/********* end *********/
}
// 定义乒乓球教练具体类 PingPangCoach 继承自Coach类并实现SpeakEnglish类（兵乓球教练需要说英语）
// 无参构造函数
// 有参构造函数初始化name和age
// 实现自己的eat()方法 输出'乒乓球教练吃小白菜，喝大米粥'
// 实现自己的teach()方法 输出'乒乓球教练教如何发球和接球'
// 实现自己的speak()方法 输出'乒乓球教练说英语'
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("乒乓球教练教如何发球和接球");
}
public void speak(){
System.out.println("乒乓球教练说英语");
}
/********* end *********/
}
// 定义篮球教练具体类BasketballCoach 继承自Coach类 不需要继承接口，因为他不需要说英语
// 无参构造函数
// 有参构造函数初始化name和age
// 实现自己的eat()方法 输出'篮球教练吃羊肉，喝羊奶'
// 实现自己的teach()方法 输出'篮球教练教如何运球和投篮'
class BasketballCoach extends Coach {
/********* begin *********/
BasketballCoach(String name,int age){
super(name,age);
}
void eat(){
System.out.println("篮球教练吃羊肉，喝羊奶");
}
void teach(){
System.out.println("篮球教练教如何运球和投篮");
}
/********* end *********/
}
两个容易犯的错误
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 *********/
}
原因是父类已经定义了一个有参构造函数，子类在继承时应该通过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 *********/
}
报错内容：
Multiple markers at this line
- Cannot reduce the visibility of the inherited method from
SpeakEnglish
是因为speak是复写父类的方法,父类是 public ，子类为定义，默认变为了protected,违反了两同两小一大的一大原则。添加public后就不再报错了。
java中方法的重写的两同两小一大原则
方法名相同，参数类型相同
子类返回类型小于等于父类方法返回类型，
子类抛出异常小于等于父类方法抛出异常，
子类访问权限大于等于父类方法访问权限。