JAVA实验三

7173
题目內容:
现定义一个类体系，基类为Dog，派生类为斑点狗SpottedDog类和非斑点狗UnspottedDog类，具体要求如下：
（1）在基类中记录狗的品种breed，体重weight以及颜色color等属性，定义一个方法show()显示Dog信息；
（2）在UnspottedDog类中，调用Dog类的构造方法，重写show()方法，只显示狗的品种；
（3）在SpottedDog类中，新增表示斑点颜色的spotColor属性，定义包含四个属性的构造方法，重写show（）方法；
（4）定义测试类，构造斑点狗对象，分别显示斑点狗的品种、体重、颜色和品种、颜色、斑点颜色；构造非斑点狗对象，显示狗的品种、体重、颜色信息。
（说明：构造斑点狗对象和非斑点狗对象时要分别输入，各属性值之间用空格分割，输入完后按回车键确认，输入内容参照测试数据。）
输入输出说明:
输入：
金毛 10 red white
泰迪 5 black
输出：
这是一只金毛体重为10,颜色为red
这是一只金毛,颜色为red,斑点颜色为white
这是一只泰迪犬
代码编辑:

import java.util.Scanner;
class Dog{
    String breed;
    int weight;
    String color;
    Dog(){
    }
    Dog(String breed,int weight,String color){
        this.breed=breed;
        this.weight=weight;
        this.color=color;
    }
    void show(){
        System.out.println("这是一只"+breed+"体重为"+weight+","+"颜色为"+color);
    }
}
class UnspottedDog extends Dog{
    UnspottedDog(String breed, int weight, String color){
        super(breed,weight,color);
    }
    void show(){
        System.out.println("这是一只"+breed+"犬");
    }
}
class SpottedDog extends Dog{
    String spotColor;
    SpottedDog(String breed,int weight,String color,String spotColor){
        super(breed,weight,color);
        this.spotColor=spotColor;
    }
    void show(){
        System.out.println("这是一只"+breed+"体重为"+weight+","+"颜色为"+color);
        System.out.println("这是一只"+breed+","+"颜色为"+color+","+"斑点颜色为"+spotColor);
    }
}
public class Main {
    public static void main(String args[]){
        Scanner reader = new Scanner(System.in);
        String breed = reader.next();
        int weight = reader.nextInt();
        String color = reader.next();
        String spotColor = reader.next();
        SpottedDog Dog1 = new SpottedDog(breed, weight, color, spotColor);
        Dog1.show();
        String breed1 = reader.next();
        int weight1 = reader.nextInt();
        String color1 = reader.next();
        UnspottedDog Dog2 = new UnspottedDog(breed1, weight1, color1);
        Dog2.show();
    }
}

7174
题目內容:
编写一个制造各种车辆的程序。包含三个类，具体要求如下：
（1）基类Vehicle，包含轮子数和汽车自身重量两个属性,一个两参数的构造方法，一个显示汽车信息的方法；
（2）小轿车类Car，增加载客数属性，重写构造方法和显示车辆信息的成员方法；
（3）卡车类Truck，增加载客数和载货量属性，重写构造方法和显示车辆信息的成员方法；
（4）主程序类，要求输入各种车辆的信息，并在控制台输出各种车辆信息。
输入输出说明:
输入：
16 5.4 4 1.5 5 6 4 4 10
输出：
汽车:
轮子数:16个
自身重量:5.4吨
小轿车:
轮子数:4个
自身重量:1.5吨
额定乘客数:5人
卡车:
轮子数:6个
自身重量:4.0吨
额定乘客数4人
载重量10.0吨
代码编辑:

import java.util.Scanner;
class Vehicle{
    int num;
    double weight;
    Vehicle(){
    }
    Vehicle(int num,double weight){
        this.num=num;
        this.weight=weight;
    }
    void show(){
        System.out.println("汽车:");
        System.out.println("轮子数:"+num+"个");
        System.out.println("自身重量:"+weight+"吨");
    }
}
class Car extends Vehicle{
    int pernum;
    Car(int num,double weight,int pernum){
        super(num,weight);
        this.pernum=pernum;
    }
    void show(){
        System.out.println("小轿车:");
        System.out.println("轮子数:"+num+"个");
        System.out.println("自身重量:"+weight+"吨");
        System.out.println("额定乘客数:"+pernum+"人");
    }
}
class Truck extends Vehicle{
    int pernum;
    double perweight;
    Truck(int num,double weight,int pernum,double perweight){
        super(num,weight);
        this.perweight=perweight;
        this.pernum=pernum;
    }
    void show(){
        System.out.println("卡车:");
        System.out.println("轮子数:"+num+"个");
        System.out.println("自身重量:"+weight+"吨");
        System.out.println("额定乘客数"+pernum+"人");
        System.out.println("载重量"+perweight+"吨");
    }
}
public class Main {
    public static void main(String[] args) {
        Scanner reader=new Scanner(System.in);
        int num1=reader.nextInt();
        double weight1= reader.nextDouble();
        Vehicle vehicle=new Vehicle(num1,weight1);
        vehicle.show();
        int num2=reader.nextInt();
        double weight2= reader.nextDouble();
        int pernum2= reader.nextInt();
        Car car=new Car(num2,weight2,pernum2);
        car.show();
        int num3=reader.nextInt();
        double weight3= reader.nextDouble();
        int pernum3= reader.nextInt();
        double perweigt3= reader.nextDouble();
        Truck truck=new Truck(num3,weight3,pernum3,perweigt3);
        truck.show();
    }
}

7175
题目內容:
使用接口或者抽象类编写程序实现显示员工基本信息。具体要求如下：
（1）使用接口或者抽象类实现基类Employer（体会接口和抽象类的不同），包含姓名、部门和工资三个属性，显示工资的方法showSalary（）和显示奖金的抽象方法showBonus（）；提示：因每位职工奖金不同，showBonus（）方法定义为抽象方法，只抽象定义，不具体实现；
（2）定义BasicEmployee和GoodEmployee类，重写Employer类中的方法，不同员工有不同的工资和奖金；
（3）定义主类进行测试，要求输入两个不同的员工信息，并输出其个人信息。
输入输出说明:
输入：
张三 前台 5000
李四 开发 6000 4000
输出：
我叫张三,在前台部门，我的工资是5000.0
我是普通员工，没有奖金，加油升级！
我叫李四,在开发部门，我的工资是6000.0
我是优秀员工，我的奖金是4000.0
代码编辑:

import java.util.Scanner;
abstract class Employer{
    String name;
    String work;
    double money;
    Employer(){
    }
    Employer(String name,String work,double money){
        this.name=name;
        this.work=work;
        this.money=money;
    }
    abstract  void showSalary();
    abstract  void showBonus();
}
class BasicEmployee extends Employer{
    BasicEmployee(String name,String work,double money) {
        super(name, work, money);
    }
    void showSalary(){
        System.out.println("我叫"+name+",在"+work+"部门，我的工资是"+money);
    }
    void showBonus(){
        System.out.println("我是普通员工，没有奖金，加油升级！");
    }
}
class GoodEmployee extends Employer{
    double bonus;
    GoodEmployee(String name,String work,double money,double bonus){
        super(name,work,money);
        this.bonus=bonus;
    }
    void showSalary(){
        System.out.println("我叫"+name+",在"+work+"部门，我的工资是"+money);
    }
    void showBonus(){
        System.out.println("我是优秀员工，我的奖金是"+bonus);
    }
}
public class Main {
    public static void main(String[] args){
        Scanner reader=new Scanner(System.in);
        String name1= reader.next();
        String work1= reader.next();
        double money1= reader.nextDouble();
        BasicEmployee basicEmployee=new BasicEmployee(name1,work1,money1);
        basicEmployee.showSalary();
        basicEmployee.showBonus();
        String name2= reader.next();
        String work2= reader.next();
        double money2= reader.nextDouble();
        double bonus2= reader.nextDouble();
        GoodEmployee goodEmployee=new GoodEmployee(name2,work2,money2,bonus2);
        goodEmployee.showSalary();
        goodEmployee.showBonus();
    }
}

7176
题目內容:
编写一个教师讲课的程序。所有老师都具有共同的讲课方法，但是不同科目的教师讲课内容不同，主程序中编写一个讲课的方法TeachingRace(Teacher t),显示不同的老师t讲授不同的课程内容。提示：
（1）所有老师具有共同的讲课方法，可在接口中定义一个讲课方法；
（2）不同科目的老师实现接口中的讲课方法；
（3）在主程序中定义一个讲课的方法TeachingRace(Teacher t)，构造不同的教师，显示讲课内容【主要考察接口回调】
输入输出说明:
输入：
ABC 方程组求解
输出：
我是英语老师，I say ABC
我是数学老师，I say 方程组求解
代码编辑:

import java.util.Scanner;
interface Teacher{
    void TeachingRace(String s);
}
class Mathteacher implements Teacher{
    public void TeachingRace(String s){
        System.out.println("我是数学老师，I say "+s);
    }
}
class Englishteacher implements Teacher{
    public void TeachingRace(String s){
        System.out.println("我是英语老师，I say "+s);
    }
}
public class Main {
    public static void main(String[] args) {
        Teacher teacher;
        Scanner reader =new Scanner(System.in);
        String s1= reader.next();
        teacher=new Englishteacher();
        teacher.TeachingRace(s1);
        String s2= reader.next();
        teacher=new Mathteacher();
        teacher.TeachingRace(s2);
    }
}

7177
题目內容:
创建Animal(动物)类：Mouse,dog等的一个继承分级结构.在父类中提供适用于所有Animal的方法,并在子类中覆盖他们,从而根据不同类型的Animal采取不同的行动
Anima类有如下方法:
public void speak();
输入输出说明:
输入：
Tom Jerry
输出：
Tom的叫声为喵喵
Jerry的叫声为吱吱
代码编辑:

import java.util.Scanner;
class Animal{
    String name;
    void setName(String name){
        this.name=name;
    }
    public void speak(){
    }
}
class Dog extends Animal{
    public void speak(){
        System.out.println(name+"的叫声为喵喵");
    }
}
class Mouse extends Animal{
    public void speak(){
        System.out.println(name+"的叫声为吱吱");
    }
}
public class Main {
    public static void main(String[] args) {
        Scanner reader=new Scanner(System.in);
        String name1= reader.next();
        Dog dog=new Dog();
        dog.setName(name1);
        dog.speak();
        String name2= reader.next();
        Mouse mouse=new Mouse();
        mouse.setName(name2);
        mouse.speak();
    }
}

7178
题目內容:
编写一个USB接口程序，模拟计算机启动过程和关闭过程启动过程中要加载鼠标、键盘、麦克风等USB设备，具体要求如下：
（1）定义一个接口USB，包含两个抽象方法turnOn()he turnOff(),分别用于表示USB设备的启动和关闭
（2）编写鼠标Mouse、键盘KeyBoard、麦克风Mic类,实现接口中的turnOn()、turnOff()方法，方法中显示“XX设备启动了”或“XX设备关闭了”即可
（3）编写计算机类Computer，要求有一个表示计算机上USB插槽数量的数组；添加USB设备的方法add（USB usb）,功能为遍历所有插槽，如果有空闲的就添加一个USB设备
模拟开机启动USB设备的powerOn（）方法，功能为遍历所有USB接口，如果连接了USB设备，则启动USB设备，然后显示“计算机开机成功”
模拟关机关闭USB设备的powerOff（）方法，功能为遍历所有USB接口，如果连接了USB设备，则关闭USB设备，然后显示“计算机关机成功”
（4）编写测试类，要求建立计算机对象，建立鼠标、键盘、麦克风对象，并添加到计算机中，启动计算机，关闭计算机*/
输入输出说明:
无输入；
输出：
鼠标启动了
键盘启动了
麦克启动了
计算机开机成功
鼠标关闭了
键盘关闭了
麦克关闭了
计算机关机成功
代码编辑:

interface USB{
    void turnOn();
    void turnOff();
}
class Mouse implements USB{
    public void turnOn() {
        System.out.println("鼠标启动了");
    }
    public void turnOff() {
        System.out.println("鼠标关闭了");
    }
}
class KeyBoard implements USB{
    public void turnOn() {
        System.out.println("键盘启动了");
    }
    public void turnOff() {
        System.out.println("键盘关闭了");
    }
}
class Mic implements USB{
    public void turnOn() {
        System.out.println("麦克启动了");
    }
    public void turnOff() {
        System.out.println("麦克关闭了");
    }
}
class Computer{
    USB usb[] =new USB[10];
    int number=0;
    public void add(USB u){
        usb[++number]=u;
    }
    public void powerOn() {
        for(USB u:usb) {
            if(u!=null)u.turnOn();
        }
        System.out.println("计算机开机成功");
    }
    public void powerOff() {
        for(USB u:usb) {
            if(u!=null)u.turnOff();
        }
        System.out.println("计算机关机成功");
    }
}
public class Main {
    public static void main(String[] args) {
        Computer computer=new Computer();
        computer.add(new Mouse());
        computer.add(new KeyBoard());
        computer.add(new Mic());
        computer.powerOn();
        computer.powerOff();
    }
}

5950
题目內容:
编写一个通过接口实现不同应用情况下计算平均分的程序，具体要求如下：

• 1、 编写一个ComputerAverage接口，接口有一个求平均分的抽象方法average，方法的参数为double类型的数组。
• 2、定义Gymnastics类和School类，它们都是ComputerAverage的实现类，Gymnastics类中的平均分方法为计算体育比赛中选手的平均成绩，具体算法是去掉一个最低分，去掉一个最高分，然后对剩余的数求平均分。
• 3、School类中的平均分为计算学生考试成绩的平均分，具体算法是分数的和除以总的科目数
• 4、要求：在主类中声明ComputerAverage的对象，并使用为上转型对象，实现ComputerAverage的对象调用average方法， 实现多态，同样的两条语句实现两种不同计算平均分的方法。输入的成绩为一组数，数据的个数和具体的数据从键盘输入。
  输入输出说明:
  输入
  6
  9 10 8 9 10 7
  代码编辑:

import java.util.Scanner;
interface ComputerAverage {
    double average(double []data);
}
class Gymnastics implements ComputerAverage {
    public double average(double []data){
        double max,min;
        max=min=data[0];
        for(int i=0;i<data.length;i++){
            if(data[i]>max){
                max=data[i];
            }
            else if(data[i]<min){
                min=data[i];
            }
        }
        double sum=0;
        for(int i=0;i<data.length;i++){
            sum+=data[i];
        }
        sum=(sum-max-min)/(data.length-2);
        return sum;
    }
}
class School implements ComputerAverage{
    public double average(double []data){
        double sum=0;
        for(int i=0;i<data.length;i++){
            sum=sum+data[i];
        }
        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();
        }
        ComputerAverage g;
        g=new Gymnastics();
        System.out.print("Gymnastics average is:");
        System.out.printf("%.2f\n",g.average(data));
        g=new School();
        System.out.print("School average is:");
        System.out.printf("%.2f",g.average(data));
    }
}

7192
题目內容:
有如下类:
interface Paper {
public String GetName();
}
class Printer {
public void Print(Paper p) {
System.out.println(p.GetName());
}
}
要求创建 A4Paper,A6Paper两个类,实现Paper接口，并实现GetName方法在main方法中创建Printer对象，并调用Print()方法两次,分别传入A4,A6类的对象,根据已有代码完成程序
输入输出说明:
输入:
A4 A6
输出:
A4
A6
代码编辑:

interface Paper {
    public String GetName();
}
class A4Paper implements Paper{
    public String GetName(){
        return "A4";
    }
}
class A6Paper implements Paper{
    public String GetName(){
        return "A6";
    }
}
class Printer {
    public void Print(Paper p) {
        System.out.println(p.GetName());
    }
}
public class Main {
    public static void main(String[] args) {
        Printer printer=new Printer();
        printer.Print(new A4Paper());
        printer.Print(new A6Paper());
    }
}