Educoder/头歌JAVA——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 Pet(String n,String s){
        this.name=n;
        this.sex=s;
    }
    public void output(){
        System.out.print("名称："+this.name+"，性别："+this.sex);
    }
    public void putName(){
        System.out.print(name);
    }
    abstract public void talk();
    abstract public 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 Dog(String n,String s,String c){
        super(n,s);
        this.color=c;
    }
    public void talk(){
        //System.out.println("名称："+this.name+"，性别："+this.sex+"，颜色："+this.color+"，汪汪叫");
        super.output();
        System.out.println("，颜色："+this.color+"，汪汪叫");
    }
    public void eat(){
        putName();
        System.out.println("吃骨头！");
    }	
	/********* 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 Cat(String n,String s,double w){
        super(n,s);
        this.weight=w;
    }
    public void talk(){
        //System.out.println("名称："+name+"，性别："+sex+"，体重："+weight+"kg，喵喵叫");
        output();
        System.out.println("，体重："+weight+"kg，喵喵叫");
    }
    public void eat(){
        putName();
        System.out.println("吃鱼！");
    }
	/********* 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 chi=(Chinese) person1;
        chi.shadowBoxing();
        English eng=(English) person2;
        eng.horseRiding();

		/********* end *********/
	}
	// 定义showEat方法，使用父类作为方法的形参，实现多态，传入的是哪个具体对象就调用哪个对象的eat()方法
	/********* begin *********/
    public static void showEat(Person p){
        if (p instanceof Chinese) { 
            Chinese c = (Chinese) p;
            c.eat();
        } else if (p instanceof English) { 
            English c = (English) p;
            c.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 name;
    public String sex;
    public int age;
    abstract void eat();
    public Person(String n,String s,int age){
        this.name=n;
        this.sex=s;
        this.age=age;
    }
	/********* end *********/
}
// Chinese类继承自Person类
// 构造函数初始化name、sex和age
// 重写父类方法eat() 输出'姓名：name，性别：sex，年龄：age，我是中国人，我喜欢吃饭！'
// 定义子类特有方法shadowBoxing(),当父类引用指向子类对象时无法调用该方法 输出'name在练习太极拳！'
class Chinese extends Person {
	/********* begin *********/
    public Chinese(String n,String s,int age){
        super(n,s,age);
    }
    public void eat(){
        System.out.println("姓名："+this.name+"，性别："+this.sex+"，年龄："+this.age+"，我是中国人，我喜欢吃饭！");
    }
    public void shadowBoxing(){
        System.out.println(name+"在练习太极拳！");
    }

	/********* end *********/
}
// English类继承自Person类
// 构造函数初始化name、sex和age
// 重写父类方法eat() 输出'姓名：name，性别：sex，年龄：age，我是英国人，我喜欢吃三明治!'
// 定义子类特有方法horseRiding(),当父类引用指向子类对象时无法调用该方法 输出'name在练习骑马！'
class English extends Person {
	/********* begin *********/
    public English (String n,String s,int age){
        super(n,s,age);
    }   
    void eat(){
        System.out.println("姓名："+name+"，性别："+sex+"，年龄："+age+"，我是英国人，我喜欢吃三明治！");
    }
    public void horseRiding(){
        System.out.println(this.name+"在练习骑马！");
    }

	/********* end *********/
}

第3关：封装、继承和多态进阶（三）

测试说明

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(name+"---"+age);
        ppp.outInf();
        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(name+"---"+age);
        bp.outInf();
        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(name+"---"+age);
        ppc.outInf();
        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(name+"---"+age);
        bc.outInf();
        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(){
        name =" ";
        age =0;
    }
    Person(String n,int a){
        this.name=n;
        this.age=a;
    }
    public void sleep(){
        System.out.println("人都是要睡觉的");
    }
    public void outInf(){
        System.out.println(name+"---"+age);
    }
    abstract void eat();

	/********* end *********/
}
// 定义运动员Player（抽象类）继承自Person类
// 无参构造函数
// 有参构造函数初始化name和age
// 运动员学习内容不一样，抽取为抽象 定义抽象方法study()
abstract class Player extends Person {
	/********* begin *********/
    Player(){
        super();
    }
    Player(String n,int a){
        super(n,a);
    }
    abstract void study();

	/********* end *********/
}
// 定义教练Coach（抽象类）继承自Person类
// 无参构造函数
// 有参构造函数初始化name和age
// 教练教的不一样 定义抽象方法teach()
abstract class Coach extends Person {
	/********* begin *********/
    Coach(){
        super();
    }
    Coach(String n,int a){
        super(n,a);
    }
    abstract void teach();

	/********* end *********/
}
// 定义乒乓球运动员具体类PingPangPlayer 继承自Player类并实现SpeakEnglish类（兵乓球运动员需要说英语）
// 无参构造函数
// 有参构造函数初始化name和age
// 实现自己的eat()方法 输出'乒乓球运动员吃大白菜，喝小米粥'
// 实现自己的study()方法 输出'乒乓球运动员学习如何发球和接球'
// 实现自己的speak()方法 输出'乒乓球运动员说英语'
class PingPangPlayer extends Player implements SpeakEnglish {
	/********* begin *********/
    PingPangPlayer(){
        super();
    }
    PingPangPlayer(String n,int a){
        super(n,a);
    }
    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(){
        super();
    }
    BasketballPlayer(String n,int a){
        super(n,a);
    }
    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(){
        super();
    }
    PingPangCoach(String n,int a){
        super(n,a);
    }
    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(){
        super();
    }
    BasketballCoach(String n,int a){
        super(n,a);
    }
    public void eat(){
        System.out.println("篮球教练吃羊肉，喝羊奶");
    }
    public void teach(){
        System.out.println("篮球教练教如何运球和投篮");
    }
	/********* end *********/
}

文章出处登录后可见！

已经登录？立即刷新

Educoder/头歌JAVA——JAVA面向对象：封装、继承和多态的综合练习

第1关：封装、继承和多态进阶（一）

相关知识

面向对象思想

封装

继承

组合和继承

构造函数

`super()`和`this()`

编程要求

第2关：封装、继承和多态进阶（二）

相关知识

重写和重载

`abstract`(抽象类)和`interface`(接口)

`final`关键字

`static`关键字

`static`关键字的作用

多态

编程要求

第3关：封装、继承和多态进阶（三）

相关知识

测试说明

Educoder/头歌JAVA——JAVA面向对象：封装、继承和多态的综合练习

第1关：封装、继承和多态进阶（一）

相关知识

面向对象思想

封装

继承

组合和继承

构造函数

super()和this()

编程要求

第2关：封装、继承和多态进阶（二）

相关知识

重写和重载

abstract(抽象类)和interface(接口)

final关键字

static关键字

static关键字的作用

多态

编程要求

第3关：封装、继承和多态进阶（三）

相关知识

测试说明

相关推荐

`super()`和`this()`

`abstract`(抽象类)和`interface`(接口)

`final`关键字

`static`关键字

`static`关键字的作用