上机实验3-3 Java面向对象编程（三）

实验1 中国人、北京人和美国人

一、实验目的

1.了解子类的继承性

2.掌握子类对象的创建过程

3.成员变量的继承与隐藏

4.掌握方法的继承与重写

二、实验内容

编写程序模拟中国人、美国人是人，北京人是中国人。除主类外，程序中还有4个类：People、ChinaPeople、AmericanPeople和BeijingPeople类。要求如下：

1.People类有权限是protected的double型成员变量height和weight，以及public修饰的speakHello()、averageHeight()和averageWeight()方法。

2.ChinaPeople类是People的子类，新增public修饰的chinaGongfu()方法，重写父类的三个方法

3.AmericanPeople类是People的子类，新增public修饰的americanBoxing()方法，重写父类的三个方法

4.Beijing类是ChinaPeople的子类，新增public修饰的beijingOPera()方法，重写父类继承People的三个方法

三、程序代码

1.People.java文件内容

class People {
	protected double weight,height;
	   public void speakHello() {
	      System.out.println("yayayaya");
	   }  
	   public void averageHeight() {
	       height=173;
	       System.out.println("average height:"+height);
	   }
	   public void averageWeight() {
	      weight=70;
	      System.out.println("average weight:"+weight);
	   }
}

2.ChinaPeople.java文件内容

class ChinaPeople extends People {
    public void speakHello() {   
       System.out.println("您好");
    }    
    public void averageHeight() { 
       height = 168.78;  
       System.out.println("中国人的平均身高:"+height+" 厘米");   
       System.out.println("中国人的平均体重:65公斤");}//【代码1】 //重写public void averageWeight()方法，输出:"中国人的平均体重：65公斤"
    public void chinaGongfu() {
       System.out.println("坐如钟,站如松,睡如弓");
    }
}

3.AmericanPeople.java文件内容

class AmericanPeople extends People {
	 public void speakHello() {   
	       System.out.println("How do you do");
	    }     //【代码2】 //重写public void speakHello()方法，输出"How do you do"
	     public void averageHeight() { 
	        System.out.println("American's average height:176 cm");
	     }//【代码3】 //重写public void averageHeight()方法，输出"American's average height:176 cm"
	     public void averageWeight() { 
	        weight = 75;  
	        System.out.println("American's average weight:"+weight+" kg");   
	     }
	     public void americanBoxing() {
	        System.out.println("直拳、钩拳、组合拳");
	     }
}

4.Beijing.java文件内容

class BeijingPeople extends ChinaPeople {
	   public void averageHeight() { 
        System.out.println("北京人的平均身高: 172.5厘米");
        }//【代码4】 //重写public void averageHeight()方法,输出:"北京人的平均身高: 172.5厘米"
	   public void averageWeight() {
	        System.out.println("北京人的平均体重：70公斤");   
	     }//【代码5】 //重写public void averageWeight()方法,输出:"北京人的平均体重：70公斤"
	   public void beijingOpera() { 
	       System.out.println("花脸、青衣、花旦和老生");
	   }
}

5.Example.java文件内容

public class Example {
	   public static void main(String args[]) {
	      ChinaPeople chinaPeople=new ChinaPeople();
	      AmericanPeople americanPeople=new AmericanPeople();
	      BeijingPeople beijingPeople=new BeijingPeople();
	      chinaPeople.speakHello();
	      americanPeople.speakHello();
	      beijingPeople.speakHello();
	      chinaPeople.averageHeight();
	      americanPeople.averageHeight();
	      beijingPeople.averageHeight();
	      chinaPeople.averageWeight();
	      americanPeople.averageWeight();
	      beijingPeople.averageWeight();
	      chinaPeople.chinaGongfu();
	      americanPeople.americanBoxing();
	      beijingPeople.beijingOpera() ;
	      beijingPeople.chinaGongfu();
	   }  
}

四、实验指导

1.如果子类可以继承父类的方法，子类就有权利重写这个方法，子类通过重写父类的方法以示自己的特殊性

2.方法重写时一定要保证方法的名字、返回值类型、参数个数和类型同父类的某个方法完全相同，只有这样，子类继承的这个方法才被隐藏

实验3 银行计算利息

一、实验目的

让学生掌握重写的目的以及怎样使用super关键字

二、实验内容

假设银行Bank已经有了按整年year计算利息的一般方法，其中year只能取正整数。

建设银行ConstructionBank是Bank的子类，准备隐藏继承的成员变量year，并重写计算利息的方法，即自己声明一个double型的year变量，比如当year取值是5.216时，表示要计算5年零216天的利息，但希望首先按银行Bank的computerInstrest()计算5整年的利息，然后自己计算216天的利息。那么，建设银行就必须把5.216的整数部分赋值给隐藏的year，并让super调用隐藏的、按整年计算利息的方法。

要求ConstructionBank和BankOfDalian类是Bank类的子类，ConstructionBank和BankOfDalian都是用super调用隐藏的成员变量和方法。

三、程序代码

1.Bank.java文件内容

class Bank {
	   int savedMoney;
	   int year;
	   double interest;
	   double interestRate = 0.29;
	   public double computerInterest() {
	      interest=year*interestRate*savedMoney;
	      return interest;
	   }
	   public void setInterestRate(double rate) {
	      interestRate = rate;
	   }
	}

2.Construction.java文件内容

class ConstructionBank extends Bank {
	   double year;
	   public double computerInterest() {
	      super.year=(int)year;
	      double r = year-(int)year;
	      int day=(int)(r*1000);
	      double yearInterest = super.computerInterest();//【代码1】 //super调用隐藏的computerInterest()方法
	      double dayInterest = day*0.0001*savedMoney;
	      interest= yearInterest+dayInterest;
	      System.out.printf("%d元存在建设银行%d年零%d天的利息:%f元\n",
	                         savedMoney,super.year,day,interest);
	      return interest;
	   }
	}

3.BankOfDalian.java文件内容

class BankOfDalian extends Bank {
	   double year;
	   public double computerInterest() {
	      super.year=(int)year;
	      double r = year-(int)year;
	      int day=(int)(r*1000);
	      double yearInterest = super.computerInterest();//【代码2】// super调用隐藏的computerInterest()方法
	      double dayInterest = day*0.00012*savedMoney;
	      interest= yearInterest+dayInterest;
	      System.out.printf("%d元存在大连银行%d年零%d天的利息:%f元\n",
	                         savedMoney,super.year,day,interest);
	      return interest;
	   }
	}

4.SavaMoney.java文件内容

public class SaveMoney {
	public static void main(String args[]) {
	      int amount=8000;
	      ConstructionBank bank1 = new ConstructionBank();
	      bank1.savedMoney = amount;
	      bank1.year = 8.236;
	      bank1.setInterestRate(0.035);
	      double interest1 = bank1.computerInterest();
	      BankOfDalian bank2 = new BankOfDalian();
	      bank2.savedMoney = amount;
	      bank2.year = 8.236;
	      bank2.setInterestRate(0.035);
	      double interest2=bank2.computerInterest();
	      System.out.printf("两个银行利息相差%f元\n",interest2-interest1);
	   }
	}

四、实验指导

1.当super调用被隐藏的方法时，该方法中出现的成员变量是被子类隐藏的成员变量或继承的成员变量

2.子类不继承父类的构造方法，因此，子类在其构造方法中需使用super来调用父类的构造方法，而且super必须是子类构造方法中的头一条语句，即如果在子类的构造方法中，没有明显地写出super关键字来调用父类的某个构造方法，那么默认的有“super();”。类中定义多个构造方法时，应当包括一个不带参数的构造方法，以防止子类省略super时出现错误。

实验4 公司支出的总薪水

一、实验目的

掌握向上转型对象的使用。在讲继承与多态时，我们通过子类对象的向上转型体现继承的多态性，即把子类创建的对象的引用放到一个父类的对象中时，得到该对象的一个向上转型的对象，那么这个向上转型对象在调用方法时，就可以具有多种形态，不同对象的向上转型对象调用同一个方法可能产生不同的行为

二、实验内容

有一个abstract类，类名为Employee。Employee的子类有YearWorker、MonthWorker、WeekWorker。YearWorker对象按年领取薪水，MonthWorker按月领取薪水，WeekWorker按周领取薪水。Employee类有一个抽象的方法：

public abstract earnings();

子类必须重写父类的earnings()方法，给出各自领取报酬的具体形式。

有一个Company类，该类用Employee对象数组作为成员，Employee对象数组的元素可以是YearWorker对象向上转型的对象、MonthWorker对象向上转型的对象、WeekWorker对象向上转型的对象。程序能输出Company对象一年需要支付的薪水总额。

三、程序代码

CompanySalary.java文件内容

abstract class Employee {
	   double salary;//员工每次发放的薪水。
	   public abstract double earnings();
	}
class Company {
	  Employee[] employee;
	   double salaries=0;
	   Company(Employee[] employee) {
	      this.employee=employee;
	   }
	   public double salariesPay() {
	       salaries=0;
	       for(int i=0;i<employee.length;i++) {
	    	   salaries=salaries+employee[i].earnings();
	       }//【代码4】 //计算salaries。
	       return salaries;
	   }    
}
class YearWorker extends Employee{
	   public YearWorker(){
	   salary=20000;//年薪
	}
	  public double earnings() {
		  salary=3000;
		  return 12*salary;
		  }//【代码1】 //重写earnings()方法
	}
class MonthWorker extends Employee{
	  public  MonthWorker(){
	   salary=12*5000;//月薪
	}
	  public double earnings() {
		  salary=3000;
		  return salary;
		  }//【代码2】 //重写earnings()方法
}
class WeekWorker extends Employee {
	   public WeekWorker(){
	   salary=500;//周薪
	}
	  public double earnings() {
		  salary=300;
		  return 12*4*salary;
		  }//【代码3】 //重写earnings()方法。
	}
class DayWorker extends Employee {
	   public DayWorker(){
	   salary=100;//日薪
	}
	  public double earnings() {
		  salary=90;
		  return 365*salary;
		  }
	}
public class CompanySalary {
 public static void main(String args[]) {
	      Employee [] employee=new Employee[29]; //公司有29名雇员
	      for(int i=0;i<employee.length;i++) {   //雇员简单地分成三类
	          if(i%4==0)
	              employee[i]=new WeekWorker();
	          else if(i%4==1)
	              employee[i]=new MonthWorker();
	          else if(i%4==2)
	              employee[i]=new YearWorker();
	          else if(i%4==3)
	              employee[i]=new DayWorker();
	      } 
	      Company company=new Company(employee);
	      System.out.println("公司薪水总额:"+company.salariesPay()+"元");
	   }
	}

实验5 编程题

设计一个动物声音“模拟器”，希望模拟器可以模拟许多动物的叫声。要求如下：

1. 编写抽象类Animal

Animal抽象类有2个抽象方法cry()和getAnimaName()，即要求各种具体的动物给出自己的叫声和种类名称。

1. 编写模拟器类Simulator

该类有一个playSound(Animal animal)方法，该方法的参数是Animal类型。即参数animal可以调用Animal的子类重写的cry()方法播放具体动物的声音、调用子类重写的getAnimalName()方法显示动物种类的名称。

1. 编写Animal类的子类：Dog，Cat类
2. 编写主类Application（用户程序）

abstract class Animal{
	public abstract void cry();
	public abstract String getAnimalName();
}
class Dog extends Animal{
	public void cry() {
		System.out.println("汪汪汪！");
	}
	public String getAnimalName() {
		return "小狗";
	}
}
class Cat extends Animal{
	public void cry() {
		System.out.println("喵喵喵！");
	}
	public String getAnimalName() {
		return "小猫";
	}
}
class Stimulator{
	public void playSound(Animal animal) {
		System.out.println("播放"+animal.getAnimalName()+"种类声音：");
		animal.cry();
	}
}
public class Application {
public static void main(String[] args) {
	Stimulator simulator = new Stimulator();
	simulator.playSound(new Dog());
	simulator.playSound(new Cat());
}
}

实验6 评价成绩

一、实验目的

   通过实验让学生掌握类怎样实现接口

二、实验内容

   体操比赛计算选手成绩的办法是去掉一个最高分和最低分再计算评价分，而学校考查一个班级的某科考试情况时，是计算全班同学的平均成绩。Gymnastics类和School类都实现了ComputerAverage接口，但实现方法不同。

三、程序代码

Estimator.java文件内容

public interface CompurerAverage {
	public double average(double x[]);
}
class Gymnastics implements CompurerAverage {
	   public double average(double x[]) {
	      int count=x.length;
	      double aver=0,temp=0;
	      for(int i=0;i<count;i++) {
	         for(int j=i;j<count;j++) {
	            if(x[j]<x[i]) {
	              temp=x[j];
	              x[j]=x[i];
	              x[i]=temp;  
	            } 
	         }
	      }
	      for(int i=1;i<count-1;i++) {
	         aver=aver+x[i];
	      }
	      if(count>2)
	         aver=aver/(count-2);
	      else
	         aver=0;
	      return aver;
	   }
	}
	class School implements CompurerAverage {//重写public double average(double x[]);返回数组x[]的元素的算术平均
		public double average(double x[]) {
		      int count=x.length;
		      double aver=0;
		for(int i=0;i<count;i++) {
	         aver=aver+x[i];
	      }
	      if(count>0)
	         aver=aver/(count);
	      else
	         aver=0;
	      return aver;
	   }//重写public double average(double x[])方法,返回数组x[]的元素的算术平均
	}

public class Estimator {
	public static void main(String args[]) {
	      double a[] = {9.89,9.88,9.99,9.12,9.69,9.76,8.97};
	      double b[] ={89,56,78,90,100,77,56,45,36,79,98};  
	      CompurerAverage computer;
	      computer=new Gymnastics();  
	      double result= computer.average(a); //computer调用average(double x[])方法，将数组a传递给参数x
	      System.out.printf("%n");
	      System.out.printf("体操选手最后得分:%5.3f\n",result);
	      computer=new School();  
	      result=computer.average(b);//【代码3】 //computer调用average(double x[])方法，将数组b传递给参数x
	      System.out.printf("班级考试平均分数:%-5.2f",result);
	   } 
}

四、实验指导

1.可以把实现某一接口的类创建的对象的地址复制给该接口声明的接口引用变量，那么该接口引用变量就可以调用被类实现的方法。

2.接口产生的多态就是指不同的子类在实现同一个接口时可能具有不同的实现方式。

实验7 创建和使用抽象类

学校员工实训

import java.util.Scanner;
abstract class EEmployee{//定义抽象类
	private String name,sex;//声明私有字段
	protected EEmployee (String name,String sex) {//受保护的构造方法
		this.name = name;
		this.sex = sex;
	}
	public String toString() {//重写从Object类继承来的toString（）方法
		return name+","+sex;
	}
	abstract public double subsidy();//声明用于计算津贴的抽象方法
	abstract public boolean important();//声明用于判断是否是骨干员工的抽象方法
}
class Teacher extends EEmployee{//构造方法
	private String title;
	public Teacher (String name,String sex,String title) {
		super(name,sex);
		this.title = title;
	}
	public double subsidy() {//实现subsidy（）抽象方法
		switch(title) {
		case "教授":
			return 1000;
		case "副教授":
			return 800;
		case "讲师":
			return 500;
		default:
			return 300;
		}
		}
	public boolean important() {//实现important（）抽象方法
		return title.equals("教授")||title.equals("副教授");
	}}
class Worker extends EEmployee{//定义继承于EEmployee抽象类的Worker类
	private int workAge;
	protected Worker(String name,String sex,int workAge) {//构造方法
		super(name,sex);
		this.workAge = workAge;
	}
	public double subsidy() {
		return workAge*50;
	}
	public boolean important() {
		return workAge >= 10;
	}
}
public class SchoolEmployee {//主类
public static void main(String[] args) {//主方法
	Scanner val = new Scanner(System.in);
	System.out.println("输入姓名、性别、职称/工龄：");
	String n = val.next();//读取用户键盘输入（姓名）
	String s = val.next();//读取用户键盘输入（性别）
	Teacher t;//声明一个Teacher类变量
	Worker w;//声明一个Worker类变量
	if(val.hasNextInt()) {//判断是否为整型
		w=new Worker(n,s,val.nextInt());
		System.out.println(w.toString()+","+w.subsidy()+","+w.important());
	}
	else {//如果不是整型
		t=new Teacher(n,s,val.next());//创建Teacher类对象
		System.out.println(t.toString()+","+t.subsidy()+","+t.important());
	}
	val.close();
}
}