2023民大电信22级Java 实验4 继承、接口与多态

目录

一、实验目的

二、实验内容

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

代码实现：

输出显示：

2．继承－Student类及其子类

代码实现：

输出显示：

2. 编程实现运算类—工厂设计模式

代码实现： 

 结果显示：

一、实验目的

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、一辆桑塔那，输出结果.

【输入形式】

无
【输出形式】

卖出的第一辆车车型、单价

汽车店的总收入、卖出车数量

卖出的第二辆车车型、单价

汽车店的总收入、卖出车数量

卖出的第三辆车车型、单价

汽车店的总收入、卖出车数量

表4.1实验题目1测试用例

序号

样例输入

样例输出

1

无

carModel:BMW price:300000

totalIncome:300000 countOfSold:1

carModel:CherryQQ price:20000

totalIncome:320000 countOfSold:2

carModel:Santana price:280000

totalIncome:600000 countOfSold:3

代码实现：

//Car.java
public interface Car {
    String getName();
    int getPrice();

}

//BMW.java
public class BMW implements Car{

    @Override
    public String getName() {
        return "BMW";
    }

    @Override
    public int getPrice() {
        return 300_000;
    }
}

//CherryQQ.java
public class CherryQQ implements Car{
    @Override
    public String getName() {
        return "CherryQQ";
    }

    @Override
    public int getPrice() {
        return 20_000;//可用下划线便于区分
    }
}

//Santana.java
public class Santana implements Car{
    @Override
    public String getName() {
        return "Santana";
    }

    @Override
    public int getPrice() {
        return 280_000;
    }
}

//CarShop.java
public class CarShop {
    //设置成static后就能在Test中不用创建实例来调用CarShop中的方法
    //即系统已给其分配内存
    private static int count= 0;
    private static int totalIncome = 0;
    //接口car 这里的形参可以放入BMW CherryQQ
    public static void sellCar(Car car){
        count++;
        totalIncome+= car.getPrice();
        String info;
        info = "carModel:"+car.getName()+" price:"+car.getPrice()+"
"+
                "totalIncome:"+getTotalIncome()+" countOfSold:"+getCount();
        System.out.println(info);
    }

    public static int getCount() {
        return count;
    }

    public static int getTotalIncome() {
        return totalIncome;
    }
}

//Test.java
public class Test {
    public static void main(String[] args) {
        BMW bmw = new BMW();
        CherryQQ cherryQQ =new CherryQQ();
        Santana santana = new Santana();

        CarShop.sellCar(bmw);
        CarShop.sellCar(cherryQQ);
        CarShop.sellCar(santana);
    }
}

输出显示：

carModel:BMW price:300000
totalIncome:300000 countOfSold:1
carModel:CherryQQ price:20000
totalIncome:320000 countOfSold:2
carModel:Santana price:280000
totalIncome:600000 countOfSold:3

进程已结束,退出代码0

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类对象的总成绩的比较结果

表4.2实验题目2测试用例

序号

1

样例输入

1001 Zhangsan 89 87 84

1002 Lisi 78 65 90 SystemFramework

1003 Wangwu 90 87 92 GroupLeader

样例输出

stuNo:1001 name:Zhangsan english:89.0 math:87.0 Java:84.0 testScore:86.67

stuNo:1002 name:Lisi english:78.0 math:65.0 Java:90.0 testScore:80.67 task:SystemFramework

stuNo:1003 name:Wangwu english:90.0 math:87.0 Java:92.0 testScore:94.67 duty:GroupLeader

Lisi's total score is less than Wangwu

（一个学生的信息占一行）

代码实现：

//Student.java
package experiment_4_2;

public class Student {
    private String ID,name;
    private double english,math,java,total;

    public Student(String ID, String name, double english, double math, double java) {
        this.ID = ID;
        this.name = name;
        this.english = english;
        this.math = math;
        this.java = java;
    }
    public double sum(){
        total = english+math+java;
        return total;
    }
    public static void compare(Student stu1,Student stu2){
        if (stu1.sum()> stu2.sum()){
            System.out.println(stu1.name+"'s total score is greater than "+stu2.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 to "+stu2.name);
        }
    }
    public double testScore(){
        return sum()/3;
    }
    public String toString(){
        String info;
        info = "stuNo:"+ID+" name:"+name+" english:"+english+" math:"+math+" Java:"+java+
                " testScore:"+String.format("%.2f",testScore());
        return info;
    }

}

//StudentSJ.java
package experiment_4_2;

public class StudentSJ extends Student{
    private String task;
    public StudentSJ(String ID, String name, double english, double math, double java,String task) {
        super(ID, name, english, math, java);
        this.task = task;
    }

    @Override
    public double testScore() {
        return 3+sum()/3;
    }

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

//StudentZZ.java
package experiment_4_2;

public class StudentZZ extends Student{
    private String duty;
    public StudentZZ(String ID, String name, double english, double math, double java,String duty) {
        super(ID, name, english, math, java);
        this.duty = duty;
    }

    @Override
    public double testScore() {
        return sum()/3+5;
    }

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

//Test.java
package experiment_4_2;

import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        Student[] students = new Student[3];
        Scanner sc = new Scanner(System.in);

        students[0] = new Student(sc.next(), sc.next(), sc.nextDouble(), sc.nextDouble(), sc.nextDouble());
        students[1] = new StudentSJ(sc.next(), sc.next(),sc.nextDouble(), sc.nextDouble(), sc.nextDouble(), sc.next());
        students[2] = new StudentZZ(sc.next(), sc.next(),sc.nextDouble(), sc.nextDouble(), sc.nextDouble(), sc.next());

        for (int i = 0; i < 3; i++) {
            System.out.println(students[i]);
        }

        Student.compare(students[1],students[2]);
    }
}

输出显示：

2. 编程实现运算类—工厂设计模式

【问题描述】

(1)定义抽象类Operation，有double型数据成员numberA、numberB，有抽象方法getResult()

(2)定义Operation的4个子类，分别实现加、减、除运算，二个数的平均数运算

(3)定义类OperationFactory：有静态方法Operation createOperate(String operate); 根据形参operate的值创建相应加、减、除、平均值类的对象，赋给抽象类引用后返回

(4)定义测试类及主方法：用户从键盘输入运算数及运算符，根据运算符调用OperationFactory类的静态方法，创建相应实例，设置运算数，输出运行结果

  

【输入形式】

一个表达式（数据与运算符之间空格间隔）
【输出形式】

表达式运算的结果，保留3位小数
【样例输入】

表4.3实验题目3测试用例

序号

样例输入

样例输出

1

45.8 + 80.9

Result:126.700

2

100 / 3

Result:33.333

3

123 / 0

Devide by zero!

代码实现： 

//Operation.java
package experiment_4_3;

public abstract class Operation {
    protected double numberA,numberB;
    public abstract double getResult();

    public void setNumberA(double numberA) {
        this.numberA = numberA;
    }

    public void setNumberB(double numberB) {
        this.numberB = numberB;
    }
}

//Plus.java
package experiment_4_3;

public class Plus extends Operation{

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

//Subtraction.java
package experiment_4_3;

public class Subtraction extends Operation{
    @Override
    public double getResult() {
        return numberA - numberB;
    }
}

//Average.java
package experiment_4_3;

public class Average extends Operation{
    @Override
    public double getResult() {
        return (numberA+numberB)/2;
    }
}

//Division.java
package experiment_4_3;

public class Division extends Operation{
    @Override
    public double getResult() {
        return numberA/numberB;
    }
}

//OperationFactory.java
package experiment_4_3;

public class OperationFactory {
    public static Operation createOperation(String operate){
        Operation op = null;
        switch (operate){
            case "+":op = new Plus();break;
            case "-":op = new Subtraction();break;
            case "avg":op = new Average();break;
            case "/":op = new Division();break;
        }
        return op;
    }
}

//Test.java
package experiment_4_3;

import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        Scanner sc =new Scanner(System.in);
        double a,b;
        String c;
        a= sc.nextDouble();
        //一定要用空格隔开 要不然sc.next sc.nextDouble无法分辨
        //System.out.println(a);
        c=sc.next();
        //System.out.println(c) ;
        b = sc.nextDouble();
        //System.out.println(b);
        Operation operation = OperationFactory.createOperation(c);
        operation.setNumberA(a);
        operation.setNumberB(b);
        if (c.equals("/") &&b==0){//字符的比较要用到equals
            System.out.println("Divide by zero!");
        }
        else {
            System.out.println("Result:" + String.format("%.3f", operation.getResult()));

        }
        //System.out.println("result:"+String.format("%.3f",operation.getResult()));
        //上一行结果是Infinity
        //System.out.println(1/0);该行报错
    }
       
}
//输入1+2不可以
//in:1 /2
//out:1.0
//    2

 结果显示：

123 / 0
Divide by zero!

进程已结束,退出代码0

45.8 + 80.9
Result:126.700

进程已结束,退出代码0
 

100 / 3
Result:33.333

进程已结束,退出代码0