EduCoder Java语言 - 封装、继承和多态的综合练习
第1关：通关任务一
编程要求
根据提示，在右侧编辑器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()方法； -
具体输出要求请看测试说明。
测试说明
通关代码
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;
}
Pet(String name, String sex) {
this.name = name;
this.sex = 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 *********/
private String color;
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
Dog(String name, String sex, String color) {
super(name, sex);
this.color = color;
}
public void talk() {
System.out.println("名称：" + getName() + "，性别：" + getSex() + "，颜色：" + getColor() + "，汪汪叫");
}
public void eat() {
System.out.println(getName() + "吃骨头！");
}
/********* end *********/
}
// Cat类继承自Pet类 封装属性weight
// 构造函数初始化name、sex和weight
// 实现自己的talk()方法和eat()方法
// talk()输出'名称：name，性别：sex，体重：weight kg，喵喵叫'
// eat()输出'name吃鱼'
class Cat extends Pet {
/********* begin *********/
double weight;
public double getWeight() {
return weight;
}
public void setWeight(double weight) {
this.weight = weight;
}
Cat(String name, String sex, double weight) {
super(name, sex);
this.weight = weight;
}
public void talk() {
System.out.println("名称：" + getName() + "，性别：" + getSex() + "，体重：" + getWeight() + "kg，喵喵叫");
}
public void eat() {
System.out.println(getName() + "吃鱼！");
}
/********* end *********/
}第2关：通关任务二
编程要求
按照要求编写一个Java应用程序：
-
定义一个抽象类
Person，包含抽象方法eat()，封装属性name、sex、age，声明包含三个参数的构造方法； -
定义一个
Chinese类，继承自Person类，重写父类的eat()方法，并定义一个自己特有的方法shadowBoxing()； -
定义一个
English类，继承自Person类，重写父类的eat()方法，并定义一个自己特有的方法horseRiding()； -
编写测试类，定义一个
showEat()方法，使用父类作为方法的形参，实现多态，分别调用showEat()方法，通过强制类型转换调用各自类特有的方法； -
具体输出要求请看测试说明。
测试说明
通关代码
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 *********/
Person person1 = new Chinese(cName, cSex, cAge);
showEat(person1);
Person person2 = new English(eName, eSex, eAge);
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 static void showEat(Person person) {
person.eat();
}
/********* end *********/
}
// 抽象类Person 封装属性name、sex和age
// 构造函数初始化name、sex和age
// 声明抽象方法eat()
abstract class Person {
/********* begin *********/
abstract void eat();
private String name;
private String sex;
private int age;
Person(String name, String sex, int age) {
this.name = name;
this.sex = sex;
this.age = 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;
}
/********* end *********/
}
// Chinese类继承自Person类
// 构造函数初始化name、sex和age
// 重写父类方法eat() 输出'姓名：name，性别：sex，年龄：age，我是中国人，我喜欢吃饭！'
// 定义子类特有方法shadowBoxing(),当父类引用指向子类对象时无法调用该方法 输出'name在练习太极拳！'
class Chinese extends Person {
/********* begin *********/
Chinese(String name, String sex, int age) {
super(name, sex, age);
//name = super.getName();
//sex = super.getSex();
//age = super.getAge();
}
public void eat() {
System.out.println("姓名：" + getName() + "，性别：" + getSex() + "，年龄：" + getAge() + "，我是中国人，我喜欢吃饭！");
}
void shadowBoxing() {
System.out.println(getName() + "在练习太极拳！");
}
/********* end *********/
}
// English类继承自Person类
// 构造函数初始化name、sex和age
// 重写父类方法eat() 输出'姓名：name，性别：sex，年龄：age，我是英国人，我喜欢吃三明治!'
// 定义子类特有方法horseRiding(),当父类引用指向子类对象时无法调用该方法 输出'name在练习骑马！'
class English extends Person {
/********* begin *********/
English(String name, String sex, int age) {
super(name, sex, age);
//name = super.getName();
//sex = super.getSex();
//age = super.getAge();
}
public void eat() {
System.out.println("姓名：" + getName() + "，性别：" + getSex() + "，年龄：" + getAge() + "，我是英国人，我喜欢吃三明治！");
}
void horseRiding() {
System.out.println(getName() + "在练习骑马！");
}
/********* end *********/
}第3关：通关任务三
编程要求
教练和运动员案例：
-
乒乓球运动员和篮球运动员；
-
乒乓球教练和篮球教练；
-
跟乒乓球相关的人员都需要学习英语；
-
分析，这个案例中有哪些抽象类，哪些接口，哪些具体类。
分析过程如下：
- 具体输出要求请看测试说明。
测试说明
测试输入：
张继科
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 *********/
void speak();
/********* end *********/
}
// 定义人的抽象类Person 封装name和age
// 无参构造函数
// 有参构造函数初始化name和age
// 定义具体方法sleep() 输出'人都是要睡觉的'
// 抽象方法eat()（吃的不一样）
abstract class Person {
/********* begin *********/
private String name;
private int age;
Person() {
}
Person(String name, int age) {
this.name = name;
this.age = age;
}
public void sleep() {
System.out.println("人都是要睡觉的");
}
abstract void eat();
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;
}
/********* end *********/
}
// 定义运动员Player（抽象类）继承自Person类
// 无参构造函数
// 有参构造函数初始化name和age
// 运动员学习内容不一样，抽取为抽象 定义抽象方法study()
abstract class Player extends Person {
/********* begin *********/
Player() {
}
Player(String name, int age) {
super(name, age);
name = super.getName();
age = super.getAge();
}
abstract void study();
/********* end *********/
}
// 定义教练Coach（抽象类）继承自Person类
// 无参构造函数
// 有参构造函数初始化name和age
// 教练教的不一样 定义抽象方法teach()
abstract class Coach extends Person {
/********* begin *********/
Coach() {
}
Coach(String name, int age) {
super(name, age);
name = super.getName();
age = super.getAge();
}
abstract void teach();
/********* end *********/
}
// 定义乒乓球运动员具体类PingPangPlayer 继承自Player类并实现SpeakEnglish类（兵乓球运动员需要说英语）
// 无参构造函数
// 有参构造函数初始化name和age
// 实现自己的eat()方法 输出'乒乓球运动员吃大白菜，喝小米粥'
// 实现自己的study()方法 输出'乒乓球运动员学习如何发球和接球'
// 实现自己的speak()方法 输出'乒乓球运动员说英语'
class PingPangPlayer extends Player implements SpeakEnglish {
/********* begin *********/
PingPangPlayer() {
}
PingPangPlayer(String name, int age) {
super(name, age);
name = super.getName();
age = super.getAge();
}
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 *********/
BasketballPlayer() {
}
BasketballPlayer(String name, int age) {
super(name, age);
name = super.getName();
age = super.getAge();
}
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 *********/
PingPangCoach() {
}
PingPangCoach(String name, int 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 *********/
BasketballCoach() {
}
BasketballCoach(String name, int age) {
}
public void eat() {
System.out.println("篮球教练吃羊肉，喝羊奶");
}
public void teach() {
System.out.println("篮球教练教如何运球和投篮");
}
/********* end *********/
}