Java⾯向对象-封装、继承和多态的综合练习-------答案笔记
Java⾯向对象 - 封装、继承和多态的综合练习-------答案笔记
通关任务⼀
声明⼀个抽象类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，喵喵叫
波斯猫吃鱼！
具体实现代码：
import java.util.*;
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.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 {
String color;
public Dog(String name,String sex,String color){
this.sex=sex;
this.name=name;
}
@Override
void talk(){
System.out.println("名称："+name+"，性别："+sex+"，颜⾊："+color+"，汪汪叫");
}
@Override
void eat(){
System.out.println(name+"吃⾻头");
}
}
// Cat类继承⾃Pet类封装属性weight
// 构造函数初始化name、sex和weight
// 实现⾃⼰的talk()⽅法和eat()⽅法
// talk()输出'名称：name，性别：sex，体重：weight kg，喵喵叫'
/
/ eat()输出'name吃鱼'
class Cat extends Pet {
double weight;
public Cat(String catName, String catSex,double catWeight){
this.name=catName;
this.sex=catSex;
this.weight=catWeight;
}
@Override
void talk(){
System.out.println("名称："+name+"，性别："+sex+"，体重："+weight+"，喵喵叫");
}
@Override
System.out.println(name+"吃鱼");
}
}
通关任务⼆
编程要求
按照要求编写⼀个Java应⽤程序：
定义⼀个抽象类Person，包含抽象⽅法eat()，封装属性name、sex、age，声明包含三个参数的构造⽅法；
定义⼀个Chinese类，继承⾃Person类，重写⽗类的eat()⽅法，并定义⼀个⾃⼰特有的⽅法shadowBoxing()；
定义⼀个English类，继承⾃Person类，重写⽗类的eat()⽅法，并定义⼀个⾃⼰特有的⽅法horseRiding()；
编写测试类，定义⼀个showEat()⽅法，使⽤⽗类作为⽅法的形参，实现多态，分别调⽤showEat()⽅法，通过强制类型转换调⽤各⾃类特有的⽅法；
具体输出要求请看测试说明。
测试说明
测试输⼊：
张三
男
20
史蒂⽂
男
java面向对象的特征有哪些方面22
预期输出：
姓名：张三，性别：男，年龄：20，我是中国⼈，我喜欢吃饭!
姓名：史蒂⽂，性别：男，年龄：22，我是英国⼈，我喜欢吃三明治!
张三在练习太极拳!
史蒂⽂在练习骑马！
具体实现代码：
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 *********/
Test test=new Test();
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) person1).shadowBoxing();
((English) person2).horseRiding();
/********* end *********/
}
// 定义showEat⽅法，使⽤⽗类作为⽅法的形参，实现多态，传⼊的是哪个具体对象就调⽤哪个对象的eat()⽅法/********* begin *********/
static class Test
{
void showEat(Person person){
person.eat();
}
}
/********* end *********/
}
// 抽象类Person 封装属性name、sex和age
// 构造函数初始化name、sex和age
// 声明抽象⽅法eat()
abstract class Person {
/
********* begin *********/
String name;
String sex;
int age;
abstract void eat();
/********* end *********/
}
// Chinese类继承⾃Person类
// 构造函数初始化name、sex和age
// 重写⽗类⽅法eat() 输出'姓名：name，性别：sex，年龄：age，我是中国⼈，我喜欢吃饭！'
// 定义⼦类特有⽅法shadowBoxing()，当⽗类引⽤指向⼦类对象时⽆法调⽤该⽅法输出'name在练习太极拳！' class Chinese extends Person {
public Chinese(String cName, String cSex,int cAge){
this.age=cAge;
this.name=cName;
this.sex=cSex;
}
@Override
void eat(){
System.out.println("姓名："+name+"，性别："+sex+"，年龄："+age+"，我是中国⼈，我喜欢吃饭！"); }
void shadowBoxing()
{
System.out.println(name+"在练太极拳！");
}
}
// English类继承⾃Person类
// 构造函数初始化name、sex和age
// 重写⽗类⽅法eat() 输出'姓名：name，性别：sex，年龄：age，我是英国⼈，我喜欢吃三明治!'
// 定义⼦类特有⽅法horseRiding()，当⽗类引⽤指向⼦类对象时⽆法调⽤该⽅法输出'name在练习骑马！'
class English extends Person {
public English(String eName, String eSex,int eAge){
this.age=eAge;
this.name=eName;
this.sex=eSex;
}
@Override
void eat(){
System.out.println("姓名："+name+"，性别："+sex+"，年龄："+age+"，我是英国⼈，我喜欢吃三明治!"); }
void horseRiding(){
System.out.println(name+"在练习骑马！");
}
}
版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。
发表评论