一、实验目的:
1.掌握类的继承方法及上转型对象的方法调用。
2.掌握this和super的区别及使用。
3.理解抽象类的概念及作用,掌握接口的声明,实现及接口回调
二、实验代码
1(题目编号7173)、现定义一个类体系,基类为Dog,派生类为斑点狗SpottedDog类和非斑点狗UnspottedDog类,具体要求如下:
(1)在基类中记录狗的品种breed,体重weight以及颜色color等属性,定义一个方法show()显示Dog信息;
(2)在UnspottedDog类中,调用Dog类的构造方法,重写show()方法,只显示狗的品种;
(3)在SpottedDog类中,新增表示斑点颜色的spotColor属性,定义包含四个属性的构造方法,重写show()方法;
(4)定义测试类,构造斑点狗对象,分别显示斑点狗的品种、体重、颜色和品种、颜色、斑点颜色;构造非斑点狗对象,显示狗的品种、体重、颜色信息。
(说明:构造斑点狗对象和非斑点狗对象时要分别输入,各属性值之间用空格分割,输入完后按回车键确认,输入内容参照测试数据。)
import java.util.Scanner;
class Dog{
protected int weight;
protected String color,bread;
public Dog(String bread,int weight,String color){
this.weight=weight;
this.bread=bread;
this.color=color;
}
public void show(){
System.out.println("这是一只"+this.bread+"体重为"+this.weight+",颜色为"+this.color);
}
}
class SpottedDog extends Dog{
String spottedColor;
public SpottedDog(String bread,int weight,String color,String spottedColor){
super(bread, weight, color);
this.weight=weight;
this.bread=bread;
this.color=color;
this.spottedColor=spottedColor;
}
public void show(){
System.out.println("这是一只"+this.bread+",颜色为"+this.color+",斑点颜色为"+this.spottedColor);
}
}
class UnspottedDog extends Dog{
public UnspottedDog(String bread,int weight,String color){
super(bread, weight, color);
this.weight=weight;
this.bread=bread;
this.color=color;
}
public void show(){
System.out.println("这是一只"+this.bread+"犬");
}
}
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int weight;
String bread,color,spotColor;
bread = sc.next();
weight = sc.nextInt();
color = sc.next();
spotColor = sc.next();
Dog dog = new Dog(bread,weight,color);
dog.show();
SpottedDog spottedDog = new SpottedDog(bread,weight,color,spotColor);
spottedDog.show();
UnspottedDog unspottedDog = new UnspottedDog(sc.next(),sc.nextInt(),sc.next());
unspottedDog.show();
}
}
测试截图:
2(题目编号7174)、编写一个制造各种车辆的程序。包含三个类,具体要求如下:
(1)基类Vehicle,包含轮子数和汽车自身重量两个属性,一个两参数的构造方法,一个显示汽车信息的方法;
(2)小轿车类Car,增加载客数属性,重写构造方法和显示车辆信息的成员方法;
(3)卡车类Truck,增加载客数和载货量属性,重写构造方法和显示车辆信息的成员方法;
(4)主程序类,要求输入各种车辆的信息,并在控制台输出各种车辆信息。
import java.util.Scanner;
class Vehicle {
int wheelnum;
double weight;
public Vehicle(int wheelnum, double weight) {
this.wheelnum = wheelnum;
this.weight = weight;
}
public void getVehicle() {
System.out.println("汽车:\n" + "轮子数:" + this.wheelnum + "个\n" + "自身重量:" + this.weight + "吨");
}
}
class Car extends Vehicle {
int passgernum;
public Car(int wheelnum, double weight, int passgernum) {
super(wheelnum, weight);
this.wheelnum = wheelnum;
this.weight = weight;
this.passgernum = passgernum;
}
public void getCar() {
System.out.println("小轿车:\n" + "轮子数:" + this.wheelnum + "个\n" + "自身重量:" + this.weight + "吨\n" + "额定乘客数:" + this.passgernum+"人");
}
}
class Truck extends Car {
double load;
public Truck(int wheelnum, double weight, int passgernum, double load) {
super(wheelnum, weight, passgernum);
this.wheelnum = wheelnum;
this.weight = weight;
this.passgernum = passgernum;
this.load = load;
}
public void getTruck() {
System.out.println("卡车:\n" + "轮子数:" + this.wheelnum + "个\n" + "自身重量:" + this.weight + "吨\n" + "额定乘客数" + this.passgernum + "人\n" + "载重量" + this.load + "吨");
}
}
public class Main {
public static void main(String[] args) {
Scanner in=new Scanner(System.in);
Vehicle car1 = new Vehicle(in.nextInt(),in.nextDouble());
car1.getVehicle();
Car car=new Car(in.nextInt(),in.nextDouble(),in.nextInt());
car.getCar();
Truck turck=new Truck(in.nextInt(),in.nextDouble(),in.nextInt(),in.nextDouble());
turck.getTruck();
}
}
3(题目编号7175)、使用接口或者抽象类编写程序实现显示员工基本信息。具体要求如下:
(1)使用接口或者抽象类实现基类Employer(体会接口和抽象类的不同),包含姓名、部门和工资三个属性,显示工资的方法showSalary()和显示奖金的抽象方法showBonus();提示:因每位职工奖金不同,showBonus()方法定义为抽象方法,只抽象定义,不具体实现;
(2)定义BasicEmployee和GoodEmployee类,重写Employer类中的方法,不同员工有不同的工资和奖金;
(3)定义主类进行测试,要求输入两个不同的员工信息,并输出其个人信息。
import java.util.*;
abstract class Employer {
String name;
String department;
double salary;
abstract void showSalary();//输出工资的抽象方法
abstract void showBonus();//输出奖金的抽象方法
}
class BasicEmployee extends Employer {
BasicEmployee(String n, String d, double s) {
this.name = n;
this.department = d;
this.salary = s;
}
void showSalary() {
System.out.printf("我叫%s,在%s部门,我的工资是%.1f\n", this.name, this.department, this.salary);
}
void showBonus() {
System.out.printf("我是普通员工,没有奖金,加油升级!\n");
}
}
class GoodEmployee extends Employer {
double bonus;
GoodEmployee(String n, String d, double s, double b) {
this.name = n;
this.department = d;
this.salary = s;
this.bonus = b;
}
void showSalary() {
System.out.printf("我叫%s,在%s部门,我的工资是%.1f\n", this.name, this.department, this.salary);
}
void showBonus() {
System.out.println("我是优秀员工,我的奖金是"+this.bonus);
}
}
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
BasicEmployee e = new BasicEmployee(in.next(), in.next(), in.nextInt());
e.showSalary();
e.showBonus();
GoodEmployee e1 = new GoodEmployee(in.next(),in.next(), in.nextInt(), in.nextInt());
e1.showSalary();
e1.showBonus();
}
}
4(题目编号7176)、编写一个教师讲课的程序。所有老师都具有共同的讲课方法,但是不同科目的教师讲课内容不同,主程序中编写一个讲课的方法TeachingRace(Teacher t),显示不同的老师t讲授不同的课程内容。提示:
(1)所有老师具有共同的讲课方法,可在接口中定义一个讲课方法;
(2)不同科目的老师实现接口中的讲课方法;
(3)在主程序中定义一个讲课的方法TeachingRace(Teacher t),构造不同的教师,显示讲课内容【主要考察接口回调】。
import java.util.*;
interface Teach {
void TeachRace();
}
class Teacher implements Teach {
private String course;
public void setCourse(String course) {
this.course = course;
}
public void TeachRace() {
if (course.equals("ABC")) {
System.out.println("我是" + "英语老师," + "I say ABC");
}
if (course.equals("方程组求解")) {
System.out.println("我是" + "数学老师," + "I say 方程组求解");
}
}
}
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
Teacher teacher1 = new Teacher();
teacher1.setCourse(sc.next());
Teacher teacher2 = new Teacher();
teacher2.setCourse(sc.next());
TeachingRace(teacher1);
TeachingRace(teacher2);
}
public static void TeachingRace(Teacher t){
t.TeachRace();
}
}
5(题目编号7177)、创建Animal(动物)类:Mouse,dog等的一个继承分级结构.在父类中提供适用于所有Animal的方法,并在子类中覆盖他们,从而根据不同类型的Animal采取不同的行动Anima类有如下方法:public void speak()。
import java.util.*;
class Animal{
public void speak(){}
}
class Cat extends Animal{
String name;
public Cat(String name){
this.name=name;
}
public void speak(){
System.out.println(this.name+"的叫声为喵喵");
}
}
class Mouse extends Animal{
String name;
public Mouse(String name){
this.name=name;
}
public void speak(){
System.out.println(this.name+"的叫声为吱吱");
}
}
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
Cat cat=new Cat(in.next());
cat.speak();
Mouse mouse=new Mouse(in.next());
mouse.speak();
}
}
6(题目编号7178)、编写一个通过接口实现不同应用情况下计算平均分的程序,具体要求如下:
- (1)编写一个ComputerAverage接口,接口有一个求平均分的抽象方法average,方法的参数为double类型的数组。
*(2)定义Gymnastics类和School类,它们都是ComputerAverage的实现类,Gymnastics类中的平均分方法为计算体育比赛中选手的平均成绩,具体算法是去掉一个最低分,去掉一个最高分,然后对剩余的数求平均分。
*(3)School类中的平均分为计算学生考试成绩的平均分,具体算法是分数的和除以总的科目数
*(4)要求:在主类中声明ComputerAverage的对象,并使用为上转型对象,实现ComputerAverage的对象调用average方法, 实现多态,同样的两条语句实现两种不同计算平均分的方法。输入的成绩为一组数,数据的个数和具体的数据从键盘输入。
import java.util.Scanner;
interface ComputerAverage {
public double average(double [] data);
}
class Gymnastics implements ComputerAverage {
public double average(double[] data) {
int i,i_max=0,i_min=0;
double sum = 0;
double temp;
double max=data[0],min=data[0];
for(i=0;i<data.length;i++){
if(data[i]>max){
max=data[i];
}
if(data[i]<min){
min=data[i];
}
}
for (double x : data) {
sum = sum + x;
}
sum=(sum-max-min)/(data.length-2);
return sum;
}
}
class School implements ComputerAverage {
public double average(double[] data) {
double sum = 0;
//double temp;
for (double x : data) {
sum = sum + x;
}
sum=sum/(data.length);
return sum;
}
}
public class Main {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int n = scan.nextInt();
double[] data = new double[n];
for (int i = 0; i < n; i++) {
data[i] = scan.nextDouble();
}
//start
//write your code between start and end,do not delete any code
//end
ComputerAverage g=new Gymnastics();
System.out.print("Gymnastics average is:");
System.out.printf("%.2f\n", g.average(data));
//start
//write your code between start and end,do not delete any code
//end
ComputerAverage G=new School();
System.out.print("School average is:");
System.out.printf("%.2f", G.average(data));
}
}
三、实验过程分析与讨论:
面对对象编程的关键思想是多态性,通过继承而互相关联的类型为多态类型。
其中向上转型:当创建一个父类对象的时候,通过向上转型可以访问父类里的变量,也可以访问子类重写的父类方法。例如:Animal dog=new Dog();
向下转型:需要建立在向上转型的基础之上,即进行向下转型的时候必须有向上转型的步骤。
抽象类和接口:都不能被实例化,抽象类被继承,接口被实现,且必须实现其中的所有抽象方法,否则只能是抽象类。接口只能做方法申明,抽象类既可以方法申明,也可以实现方法。