JAVA—实验4 继承、接口与多态

一、实验目的

1. 掌握类的继承机制
2. 掌握接口的定义方法
3. 熟悉成员方法或构造方法多态性
   二、实验内容

1．卖车－接口与多态编程

【问题描述】
(1) 汽车接口(Car)：有两个方法， getName()、getPrice()(接口源文件可以自己写，也可以直接从题目中下载)
(2) BMW类，实现汽车接口
(3) 奇瑞QQ类，实现汽车接口
(4) 桑塔那类，实现汽车接口
(4) 汽车出售店(CarShop)类，有成员变量：count(售出数量) 和total(总价)，有方法：
void sellCar(Car car); (调用方法获取售出车的车型、售价；获取售出数量及总价）
int getCount(); int getTotal();
(5) 编写测试类：卖出一辆BMW、一辆奇瑞QQ、一辆桑塔那，输出结果.
【输入形式】
无
【输出形式】
卖出的第一辆车车型、单价
汽车店的总收入、卖出车数量
卖出的第二辆车车型、单价
汽车店的总收入、卖出车数量
卖出的第三辆车车型、单价
汽车店的总收入、卖出车数量

运行结果：

源码：

package buycar;

public class BuyCar {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		CarShop c1 = new CarShop();
		c1.sellCar(new BMW());
		c1.sellCar(new CherryQQ());
		c1.sellCar(new Santana());
	}

}

interface Car {
	public String getName();

	public int getPrice();
}

class BMW implements Car {
	public String getName() {
		return "BMW";
	}

	public int getPrice() {
		return 300000;
	}
}

class CherryQQ implements Car {
	public String getName() {
		return "CherryQQ";
	}

	public int getPrice() {
		return 20000;
	}
}

class Santana implements Car {
	public String getName() {
		return "Santana";
	}

	public int getPrice() {
		return 280000;
	}
}

class CarShop {
	private int count = 0;
	private int total = 0;

	public void sellCar(Car car) {
		count++;
		total += car.getPrice();
		System.out.println("car model:" + car.getName() + " price:" + car.getPrice() + "\n" + "total income:" + total
				+ " count of sold:" + count);
	}
}

2．继承－－Student类及其子类

【问题描述】
(1)声明Student类：
属性包括：学号、姓名、英语成绩、数学成绩、Java成绩、总成绩（成绩为double型，学号、姓名为String类型）
方法包括：构造方法、标准方法、toString()方法、compare()方法(比较两个学生的总成绩，结果分大于、等于、小于)、sum()方法(计算总成绩)、testScore()方法(计算评测成绩)
注：评测成绩取三门课程成绩的平均分(评测成绩保留2位小数)
(2)声明StudentSJ(参与综合设计的学生)类为Student的子类，增加任务属性，并重写testScore()方法（计算评测成绩，评测成绩＝三门课的平均分+3）
(3)声明StudentZZ(综合设计组长)类为Student的子类，增加责任属性，并重写testScore()方法（计算评测成绩，评测成绩＝三门课的平均分+5）
(4)声明测试类：在主方法中声明Student类数组(含3个元素)，生成3个对象存入数组，其中一个为Student类的对象，一个StudentSJ类的对象，一个StudentZZ类的对象，将方法testScore()发送给数组中的每一个元素，输出结果，并分析具体执行的是哪一个类中的方法。比较StudentSJ类对象和StudentZZ类对象的总成绩，输出结果。
【输入形式】
三行：第一行，学生的信息；
第二行，参加综合设计的学生信息
第三行，综合设计组长信息
【输出形式】
学生对象的详细信息
综合设计学生对象的详细信息
综合设计组长对象的详细信息
StudentSJ类对象和StudentZZ类对象的总成绩的比较结果

运行结果：

源码：

package studentDome;

import java.math.BigDecimal;
import java.text.DecimalFormat;
import java.util.Scanner;

public class StudentDome {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		new_student[] stu = new new_student[3];
		Scanner in = new Scanner(System.in);
		
		String stuID1 = in.next();
		String name1 = in.next();
		double english_garde1 = in.nextDouble();
		double math_garde1 = in.nextDouble();
		double Java_garde1 = in.nextDouble();
		in.nextLine();

		
		String stuID2 = in.next();
		String name2 = in.next();
		double english_garde2 = in.nextDouble();
		double math_garde2 = in.nextDouble();
		double Java_garde2 = in.nextDouble();
		String str = in.next();
		in.nextLine();

		
		String stuID3 = in.next();
		String name3 = in.next();
		double english_garde3 = in.nextDouble();
		double math_garde3 = in.nextDouble();
		double Java_garde3 = in.nextDouble();
		String str1 = in.next();

		stu[0] = new new_student(name1, stuID1, english_garde1, math_garde1, Java_garde1);
		stu[0].show();

		stu[1] = new StudentSJ(name2, stuID2, english_garde2, math_garde2, Java_garde2, str);
		stu[1].show();

		stu[2] = new StudentZZ(name3, stuID3, english_garde3, math_garde3, Java_garde3, str1);
		stu[2].show();

		new_student.compare(stu[1], stu[2]);

		in.close();
		stu.clone();
	}

}


class new_student {
	
	private String name;
	private String stuID;
	private double english_garde;
	private double math_garde;
	private double Java_garde;
	private double total_garde;

	
	public new_student(String name, String stuID, double english_garde, double math_garde, double Java_garde) {
		this.name = name;
		this.stuID = stuID;
		this.english_garde = english_garde;
		this.math_garde = math_garde;
		this.Java_garde = Java_garde;
	}

	public String toString() {
		DecimalFormat df = new DecimalFormat("#.00");
		return "stuNo:" + stuID + " name:" + name + " english:" + english_garde + " math:" + math_garde + " Java:"
				+ Java_garde + " testScore:" + df.format(testScore());
	}

	public void show() {
		System.out.println(toString());
	}

	public static void compare(new_student stu1, new_student stu2) {
		if (stu1.sum() < stu2.sum())
			System.out.println(stu1.name + "'s total score is less than " + stu2.name);
		else if (stu1.sum() > stu2.sum())
			System.out.println(stu1.name + "'s total score is greater than " + stu2.name);
		else
			System.out.println(stu1.name + "'s total score is equal to " + stu2.name);
	}


	public double sum() {
		total_garde = english_garde + math_garde + Java_garde;
		return total_garde;
	}


	public double testScore() {

		BigDecimal bg = new BigDecimal((sum() / 3));
		return bg.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
	}

}


class StudentSJ extends new_student {
	private String str;


	public StudentSJ(String name, String stuID, double english_garde, double math_garde, double Java_garde,
			String str) {
		super(name, stuID, english_garde, math_garde, Java_garde);
		this.str = str;
	}


	public double testScore() {
		return super.testScore() + 3.0;

	}


	public String toString() {
		return super.toString() + " task:" + str;
	}
}


class StudentZZ extends new_student {
	private String str;


	public StudentZZ(String name, String stuID, double english_garde, double math_garde, double Java_garde,
			String str) {
		super(name, stuID, english_garde, math_garde, Java_garde);
		this.str = str;
	}

	
	public double testScore() {
		return super.testScore() + 5.0;
	}

	
	public String toString() {
		return super.toString() + " duty:" + str;
	}
}

3．编程实现运算类—工厂设计模式

【问题描述】
(1)定义抽象类Operation，有double型数据成员numberA、numberB，有抽象方法getResult()
(2)定义Operation的4个子类，分别实现加、减、除运算，二个数的平均数运算
(3)定义类OperationFactory：有静态方法Operation createOperate(String operate); 根据形参operate的值创建相应加、减、除、平均值类的对象，赋给抽象类引用后返回
(4)定义测试类及主方法：用户从键盘输入运算数及运算符，根据运算符调用OperationFactory类的静态方法，创建相应实例，设置运算数，输出运行结果
【输入形式】
一个表达式（数据与运算符之间空格间隔）
【输出形式】
表达式运算的结果，保留3位小数
【样例输入】

运行结果：

源码：

package factoryModeDome;

import java.text.DecimalFormat;
import java.util.Scanner;

public class FactoryModeDome {

	public static void main(String[] args) {
		DecimalFormat df = new DecimalFormat("#.000");
		// TODO Auto-generated method stub
		Scanner in = new Scanner(System.in);
		Double numberA = in.nextDouble();
		String operator = in.next();
		Double numberB = in.nextDouble();
		if (OperationFactory.createOperate(operator, numberA, numberB).getResult() == Double.parseDouble("Infinity"))
			System.out.println("Devide by zero!");
		else
			System.out.println("Result:"
					+df.format(OperationFactory.createOperate(operator, numberA, numberB).getResult()));
		in.close();
	}

}

abstract class Operation {
	protected double numberA;
	protected double numberB;

	public Operation(double numberA, double numberB) {
		this.numberA = numberA;
		this.numberB = numberB;
	}

	public abstract double getResult();
}

class Add extends Operation {
	public Add(double numberA, double numberB) {
		super(numberA, numberB);
	}

	public double getResult() {
		return (numberA + numberB);
	}
}

class Subtraction extends Operation {
	public Subtraction(double numberA, double numberB) {
		super(numberA, numberB);
	}

	public double getResult() {
		return (numberA - numberB);
	}
}

class Division extends Operation {
	public Division(double numberA, double numberB) {
		super(numberA, numberB);
	}

	public double getResult() {
			return numberA / numberB;
	}
}

class Average extends Operation {
	public Average(double numberA, double numberB) {
		super(numberA, numberB);
	}

	public double getResult() {
		return (numberA + numberB) / 2;
	}
}

class OperationFactory {
	public static Operation createOperate(String operate, double numberA, double numberB) {
		Operation op = null;
		switch (operate) {
		case "+":
			op = new Add(numberA, numberB);
			break;
		case "-":
			op = new Subtraction(numberA, numberB);
			break;
		case "/":
			op = new Division(numberA, numberB);
			break;
		case "avg":
			op = new Average(numberA, numberB);
			break;
		}
		return op;
	}
}

END:对于小肚鸡肠的家伙咋不要理他。