一、实验目的
- 掌握类的继承机制
- 掌握接口的定义方法
- 熟悉成员方法或构造方法多态性
二、实验内容
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.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);// 定义对象in
// 输入第一个人的信息（new_student类）
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();// 消除空格
// 输入第二个人的信息（StudentSJ类）
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();// 消除空格
// 输入第三个人的信息（StudentZZ类）
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]);// 比较StudentSJ对象总分与StudentZZ对象总分的大小
in.close();
stu.clone();
}
}
//Student类
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 getName() {
// return name;
// }
//
// public void setName(String name) {
// this.name = name;
// }
//
// public String getStuID() {
// return stuID;
// }
//
// public void setStuID(String stuID) {
// this.stuID = stuID;
// }
//
// public double getEnglish_garde() {
// return english_garde;
// }
//
// public void setEnglish_garde(double english_garde) {
// this.english_garde = english_garde;
// }
//
// public double getMath_garde() {
// return math_garde;
// }
//
// public void setMath_garde(double math_garde) {
// this.math_garde = math_garde;
// }
//
// public double getJava_garde() {
// return Java_garde;
// }
//
// public void setJava_garde(double java_garde) {
// Java_garde = java_garde;
// }
//
// public double getTotal_garde() {
// return total_garde;
// }
//
// public void setTotal_garde(double total_garde) {
// this.total_garde = total_garde;
// }
// toString()方法—返回字符串
public String toString() {
return "stuNo:" + stuID + " name:" + name + " english:" + english_garde + " math:" + math_garde + " Java:"
+ Java_garde + "\n" + "testScore:" + testScore();
}
public void show() {
System.out.println(toString());
}
// 静态compare()方法作比较—直接输出比较结果
public static void compare(new_student stu1, new_student stu2) {
if (stu1.sum() > stu2.sum())
System.out.println(stu2.name + "'s total score is less than " + stu1.name);
else if (stu1.sum() < stu2.sum())
System.out.println(stu1.name + "'s total score is less than " + stu2.name);
else
System.out.println(stu1.name + "'s total score is equal" + stu2.name);
}
// 求和函数sum()
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();
}
}
//StudentSJ类（参与综合设计的学生）
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;
}
// 重写testScore()方法
public double testScore() {
return super.testScore() + 3.0;
}
// 重新toString()方法
public String toString() {
return super.toString() + " task:" + str;
}
}
//StudentZZ类（综合设计组长）
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;
}
// 重写testScore()方法
public double testScore() {
return super.testScore() + 5.0;
}
// 重新toString()方法
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) {
// TODO Auto-generated method stub
Scanner in = new Scanner(System.in);
Double numberA = in.nextDouble();
String operator = in.next();
Double numberB = in.nextDouble();
OperationFactory.createOperate(operator,numberA,numberB).getResult();
in.close();
}
}
abstract class Operation {
DecimalFormat df = new DecimalFormat("#.000");
protected double numberA;
protected double numberB;
public Operation(double numberA,double numberB) {
this.numberA = numberA;
this.numberB = numberB;
}
public abstract void getResult();
}
class Add extends Operation {// 加法
public Add(double numberA,double numberB) {
super(numberA,numberB);
}
public void getResult() {
System.out.println("Result:" + df.format(numberA + numberB));
}
}
class Subtraction extends Operation {// 减法
public Subtraction(double numberA,double numberB) {
super(numberA,numberB);
}
public void getResult() {
System.out.println("Result:" + df.format(numberA - numberB));
}
}
class Division extends Operation {// 除法
public Division(double numberA,double numberB) {
super(numberA,numberB);
}
public void getResult() {
if (super.numberB == 0)
System.out.println("Devide by zero!");
else {
System.out.println("Result:" + df.format(numberA / numberB));
}
}
}
class Average extends Operation {// 平均值
public Average(double numberA,double numberB) {
super(numberA,numberB);
}
public void getResult() {
System.out.println("Result:" + df.format((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:对于小肚鸡肠的家伙咋不要理他。
