Educoder---Java面向对象（第三章）- 综合练习

大家注意啦！！ 因为这一期代码量大，所以每一道题都是全部代码！！
什么？用Eclipse的你还在敲键盘打代码吗？

第一题

编程要求

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 a = new Dog(dogName, dogSex, dogColor);
		a.talk();
		a.eat();
		/********* end *********/
		// 通过有参构造函数实例化Cat类对象cat
		// cat调用talk()方法
		// cat调用eat()方法
		/********* begin *********/
		Cat b = new Cat(catName, catSex, catWeight);
		b.talk();
		b.eat();/********* end *********/
	}
}

// 抽象类Pet 封装属性name和sex
// 构造函数初始化name和sex
// 声明抽象方法talk()
// 声明抽象方法eat()
abstract class Pet {
	/********* begin *********/
	private String name;
	private String sex;

	public void setName(String name) {
		
		this.name=name;
	}
	
	public String getName() {
		return name;
	}
	
	public void setSex(String sex) {
		this.sex=sex;
	}

	public String getSex() {
		
		return sex;
	}

	public 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;

	 Dog( String name,String sex,String color){
		super(name,sex);
		this.color=color;
	}
  
	void talk() {
		System.out.println("名称：" + getName() + "，性别：" + getSex() + "，颜色：" + color + "，汪汪叫");
	}

	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 *********/
	private double weight;

	 Cat(String name,String sex, double weight) {
		super(name,sex);
		this.weight = weight;
	}

	void talk() {
		System.out.println("名称：" + getName() + "，性别：" + getSex() + "，体重：" + weight + "kg，喵喵叫");
	}

	void eat() {
		System.out.println(getName() + "吃鱼！");
	}
	/********* end *********/
}

第二题

编程要求

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 test;
         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 a=(Chinese) person1;
		 a.shadowBoxing();
		 English b=(English) person2;
		 b.horseRiding();
		/********* end *********/
	}

	// 定义showEat方法，使用父类作为方法的形参，实现多态，传入的是哪个具体对象就调用哪个对象的eat()方法
	/********* begin *********/
   public static   void showEat(Person a){
		  a.eat();
	  }
	/********* end *********/
}

// 抽象类Person 封装属性name、sex和age
// 构造函数初始化name、sex和age
// 声明抽象方法eat()
abstract class Person {
	/********* begin *********/
     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 void setName(String name) {
		
		this.name=name;
	}
	
	public String getName() {
		return name;
	}
	
	public void setSex(String sex) {
		this.sex=sex;
	}

	public String getSex() {
		
		return sex;
	}
	public void setAge(int age) {
		this.age=age;
	}

	public int getAge() {
		
		return age;
	}
	 abstract	void eat();
	/********* 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);
		 
	 }

	 public void eat(){
		 System.out.println("姓名："+getName()+"，性别："+getSex()+"，年龄："+getAge()+"，我是中国人，我喜欢吃饭！");
	 }

	 public 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);
		 
	 }

	 public void eat(){
		 System.out.println("姓名："+getName()+"，性别："+getSex()+"，年龄："+getAge()+"，我是英国人，我喜欢吃三明治！");
	 }

	 public void horseRiding(){
		 System.out.println(getName()+"在练习骑马！");
	 }
	/********* end *********/
}

第三题

编程要求

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 *********/
      private String name;
	  private int age;
	  public Person(){}
	  public Person(String name,int age){
		  this.name=name;
		  this.age=age;
	  }
         public void setName(String name) {
		
		this.name=name;
	}
	
	public String getName() {
		return name;
	}
	public void setAge(int age) {
		this.age=age;
	}

	public int getAge() {
		
		return age;
	}
	  public void sleep(){
		 System.out.println("人都是要睡觉的");
	  }
	  

	  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);
	 }

	 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);
	}

	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 *********/
}

点击我的个人页面，还有前两期参考答案！
上期回顾Educoder—Java面向对象（第二章）封装、继承和多态
什么？用Eclipse的你还在敲键盘打代码吗？
大家一同努力！ 共勉！

飞来山上千寻塔，闻说鸡鸣见日升。
不畏浮云遮望眼，自缘身在最高层。-------------王安石