zoukankan html css js c++ java

Java题目集函数

6-1 汽车类 (20 分)

编写汽车类，其功能有启动（start），停止（stop），加速(speedup)和减速（slowDown），启动和停止可以改变汽车的状态(on/off)，初始时状态为off，速度为0，speedUp和slowDown可以调整汽车的速度，每调用一次汽车速度改变10（加速增10，减速减10），汽车启动后才能加减速，加速上限为160，减速下限为0，汽车速度减为0后才能停止，给出汽车类的定义。 Main函数中构造一个汽车对象，并对该对象进行操作，各个操作的编号为：

start
stop
speedup
slowdown 操作完成后打印出汽车的状态和速度。

输入描述：

操作

输出描述：

汽车的状态和速度

裁判测试程序样例：

import java.util.Scanner;
public class Main{

    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        int n = s.nextInt();
        Car c = new Car();
        for (int i=0;i<n;i++) {
            int a = s.nextInt();
            switch (a) {
            case 1: c.start(); break;
            case 2: c.stop(); break;
            case 3: c.speedUp(); break;
            case 4: c.slowDown(); break;
            }
        }
        System.out.print(c.status + " ");
        System.out.println(c.speed);
    }

}

/* 你的代码被嵌在这里 */

输入样例：

在这里给出一组输入。例如：

8
1 3 3 4 3 4 4 2

输出样例：

在这里给出相应的输出。例如：

off 0

 1 class Car
 2 {
 3     public String status;
 4     public int speed = 0;
 5     public void start()
 6     {
 7 
 8         status = "on";
 9         speed = 0;
10     }
11     public void stop()
12     {
13         if(speed == 0)
14         {
15             status = "off";
16         }
17     }
18     public void speedUp()
19     {
20         if(speed<160)
21         {
22             speed += 10;
23         }
24     }
25     public void slowDown()
26     {
27         if(speed >= 10)
28         {
29             speed -= 10;
30         }
31     }
32     
33     
34 }

6-2 设计直线类 (20 分)

两点可以确定一条直线，请设计一个直线类Line，需要通过两个点Point对象来确定。

设计类Point，包含两个坐标值，提供必要的构造函数和其他辅助函数

设计类Line，包含两个点，提供必要的构造函数和其他辅助函数

为Line提供一个getLength方法返回直线的长度

在Main类的main方法中，读入2对Point的坐标，输出2对Point所表示的直线的长度，保留两位小数（可用System.out.printf）

裁判测试程序样例：

import java.util.Scanner;
public class Main{
  public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    Point p1 = new Point(sc.nextDouble(),sc.nextDouble());
    Point p2 = new Point(sc.nextDouble(),sc.nextDouble());
    Line l = new Line(p1,p2);
    System.out.printf("%.2f",l.getLength());
    }
}

/* 请在这里填写答案 */

输入样例：

23.2 22.1 12.2 3.2

输出样例：

21.87

class Point
{
    public double x;
    public double y;
    public Point(double x, double y) 
    {
        this.x = x;
        this.y = y;
    }
    
}
class Line
{
    public Point p1;
    public Point p2;
    public Line(Point p1, Point p2) {
        this.p1 = p1;
        this.p2 = p2;
    }
    public double getLength()
    {
        return Math.pow((p1.x-p2.x)*(p1.x-p2.x)+(p1.y-p2.y)*(p1.y-p2.y), 0.5);
　　　　//return Math.sqrt((p1.x-p2.x)*(p1.x-p2.x)+(p1.y-p2.y)*(p1.y-p2.y));
    }
    
}

6-3 学生数统计 (20 分)

构造类Student，包含姓名，性别，年龄。提供必要的构造函数和其他成员函数。

提供静态函数getMaleCount，getFemaleCount，能够获得所有在main函数中构造的Student对象中男生和女生的数量。

main函数中先读取学生个数n，而后构造n个学生对象，最后分别打印其中男生和女生的人数。(输入的三个字段用空格分开，名字内部没有空格，性别用数字表示，1为男生，0为女生）

裁判测试程序样例：

在这里给出函数被调用进行测试的例子。例如：
import java.util.Scanner;
public class Main{
 public static void main(String[] args){
   Scanner sc = new Scanner(System.in);
     int n = sc.nextInt();
     for(int i=0;i<n;i++){
         Student s = new Student(sc.next(),sc.nextInt(), sc.nextInt());
     }
     System.out.println("number of male students:" + Student.getMaleCount() );
     System.out.println("number of female students:" + Student.getFemaleCount() );
 }
}

/* 请在这里填写答案 */

输入样例：

5
LiuMing 0 20
FangDa 1 19
DaShan 0 20
ChenHuang 0 21
DeLi 0 20

输出样例：

number of male students:1
number of female students:4

class Student
{
    public String name;
    public static int sex;
    public int age;
    public static int MaleCount = 0;
    public static int FeMaleCount = 0;
    public Student(String name, int sex, int age) 
    {
        this.name = name;
        this.sex = sex;
        this.age = age;
        if(sex == 1)
        {
            this.MaleCount++;
        }
        if(sex == 0)
        {
            this.FeMaleCount++;
        }
    }
    
    public static int getMaleCount()
    {
        return MaleCount;
    }
    public static int getFemaleCount()
    {
        return FeMaleCount;
    }
}

6-16 Person类 (20 分)

构造Person类。包括姓名(name)，性别(sex)和年龄(age)。提供所有属性的set和get函数，提供print函数打印其信息

输入描述：

姓名(name)，性别(sex)和年龄(age)

输出描述：

用户信息

裁判测试程序样例：

import java.util.Scanner;
public class Main{
    public static void main(String[] args) {
         Scanner scan = new Scanner(System.in);      
         String name = scan.next();      
         String sex = scan.next();      
         int age = scan.nextInt();
         Person p = new Person();
         p.setName(name);
         p.setSex(sex);
         p.setAge(age);
         p.print();
         scan.close(); 
    }
}

/* 你的代码被嵌在这里 */

输入样例：

在这里给出一组输入。例如：

Lucy male 23

输出样例：

在这里给出相应的输出。例如：

name:Lucy; sex:male; age:23

class Person
{
    private String name;
    private String sex;
    private int age;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public void print()
    {
        System.out.println("name:"+this.name+"; sex:"+this.sex+"; age:"+this.age);
    }
}

6-18 学生类 (20 分)

有一个学生类的结构如下：

class Student {
    private int no;
    private String name;
        private int score;


    public Student(int _no, String _name, int _score) {
        no = _no;
        name = _name;
                score = _score;
    }
        public int getNo() {return no;}
        public String getName() {return name;}
        public int getScore() {return score;}

    public void print(){
        System.out.println(no + " "+name+" "+score);
    }
}

请构造main函数完成如下功能：从键盘中读入三个学生的信息，比较他们的成绩，按照成绩由高到低排列输出

输入描述：

三个学生的学号、姓名、成绩

输出描述：

由高到低排列输出的三个学生信息

裁判测试程序样例：

/*你的代码被嵌在这里*/

class Student {
    private int no;
    private String name;
        private int score;

    public Student(int _no, String _name, int _score) {
        no = _no;
        name = _name;
                score = _score;
    }
        public int getNo() {return no;}
        public String getName() {return name;}
        public int getScore() {return score;}

    public void print(){
        System.out.println(no + " "+name+" "+score);
    }
}

输入样例：

在这里给出一组输入。例如：

1 wang 89
2 liu 78
3 ma 90

输出样例：

在这里给出相应的输出。例如：

3 ma 90
1 wang 89
2 liu 78

import java.util.*;
public class Main{
    public static void main(String[] args) {
         Scanner s = new Scanner(System.in);      
         Student stu[] = new Student [3];
         for(int i = 0; i < 3 ;i++)
         {
             stu[i] = new Student(s.nextInt(),s.next(),s.nextInt());
         }
         for(int i = 0; i < stu.length-1; i++)
         {
             for(int j = i+1; j < stu.length; j++)
             {
                 Student t = new Student(0,null,0);
                 if(stu[i].getScore() < stu[j].getScore())
                 {
                     t = stu[i];
                     stu[i] = stu[j];
                     stu[j] = t;
                 }
             }
         }
         for(int i = 0 ; i < stu.length; i++)
         {
             stu[i].print();
         }
         s.close(); 
    }
}

或者

import java.util.*;
public class Main
{
    public static void main(String[] args) 
    {
         Scanner s = new Scanner(System.in);     
         Map<Integer, Student> map = new HashMap<>();
         for(int i = 1 ; i <= 3 ; i++)
         {
             int no = s.nextInt();
             String name = s.next();
             int score = s.nextInt();
             map.put(score, new Student(no,name,score));
         }
         for(int i = 100 ; i > 0 ; i--)
         {
             if(map.get(i) == null)
             {
                 continue;
             }
             map.get(i).print();
         }
         s.close(); 
    }
}

6-5 家具类 (20 分)

构建家具类Furniture，包括长、宽、高，均为整数(cm)。提供相应的构造函数和get、set函数。 Main函数里构造家具对象，并调用相应的函数。

输入描述：

家具对象的长宽高

输出描述：

家具对象的相关属性

裁判测试程序样例：

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        Furniture f = new Furniture(sc.nextInt(),sc.nextInt(),sc.nextInt());
        System.out.println(f.getHeight());
        System.out.println(f.getLength());
        System.out.println(f.getWidth());
    }
}

/* 你的代码被嵌在这里*/

输入样例：

在这里给出一组输入。例如：

50 60 100

输出样例：

在这里给出相应的输出。例如：

100
50
60

class Furniture
{
    public int length;
    public int width;
    public int height;
    public Furniture(int length, int width, int height) {
        super();
        this.length = length;
        this.width = width;
        this.height = height;
    }
    public int getLength() {
        return length;
    }
    public void setLength(int length) {
        this.length = length;
    }
    public int getWidth() {
        return width;
    }
    public void setWidth(int width) {
        this.width = width;
    }
    public int getHeight() {
        return height;
    }
    public void setHeight(int height) {
        this.height = height;
    }
    
    
}

6-32 Shape类 (20 分)

定义一个形状类Shape，提供计算周长getPerimeter()和面积getArea()的函数定义一个子类正方形类Square继承自Shape类，拥有边长属性，提供构造函数，能够计算周长getPerimeter()和面积getArea() 定义一个子类长方形类Rectangle继承自Square类，拥有长、宽属性，提供构造函数，能够计算周长getPerimeter()和面积getArea() 定义一个子类圆形类Circle继承自Shape，拥有半径属性，提供构造函数，能够计算周长getPerimeter()和面积getArea()

在main函数中，分别构造三个子类的对象，并输出他们的周长、面积. 提示：用System.out.printf("%.2f",d)进行格式化输出

输入描述：

正方形类的边长长方形类的长宽圆类的半径

输出描述：

正方形的周长、面积长方形的周长、面积

裁判测试程序样例：

import java.util.Scanner;
public class Main{
    public static void main(String[] args) {
         Scanner scan = new Scanner(System.in);      
         double length = scan.nextDouble();
         Square s = new Square(length);
         System.out.printf("%.2f ",s.getPerimeter());
         System.out.printf("%.2f
",s.getArea());

         length = scan.nextDouble();
         double wide = scan.nextDouble();
         Rectangle r = new Rectangle(length,wide);
         System.out.printf("%.2f ",r.getPerimeter());
         System.out.printf("%.2f
",r.getArea());

         double radius = scan.nextDouble();
         Circle c = new Circle(radius);
         System.out.printf("%.2f ",c.getPerimeter());
         System.out.printf("%.2f
",c.getArea());

         scan.close(); 
    }
}

/* 你的代码被嵌在这里 */

输入样例：

在这里给出一组输入。例如：

1
1 2
2

输出样例：

在这里给出相应的输出。例如：

4.00 1.00
6.00 2.00
12.57 12.57

class Shape
{
    public double length;
    
    public Shape(double length) {
        super();
        this.length = length;
    }
    public double getPerimeter()
    {
        return 4*length;
    }
    public double getArea()
    {
        return length*length;
    }
}
class Square extends Shape
{
    public Square(double length) 
    {
        super(length);
    }
    
}
class Rectangle extends Shape
{
    public double width;

    public Rectangle(double length, double width) {
        super(length);
        this.width = width;
    }
    public double getPerimeter()
    {
        return 2*width+2*length;
    }
    public double getArea()
    {
        return width*length;
    }
}
class Circle extends Shape
{
    public Circle(double length) {
        super(length);
    }
    public double getPerimeter()
    {
        return 2*3.14159*length;
    }
    public double getArea()
    {
        return 3.14159*length*length;
    }
}

6-33 学生、大学生、研究生类 (20 分)

定义Student学生类，拥有学号、姓名、性别属性，提供构造函数，以及相应属性的get set函数，提供函数attendClass(String className)表示上课。定义CollegeStudent大学生类继承自Student类，拥有新增属性专业，提供构造函数，提供新增属性的get和set函数定义GraduateStudent研究生类继承自CollegeStudent类，拥有新增属性导师，提供构造函数，提供新增属性的get和set函数，提供函数doResearch() 表示做研究（打印xx is doing research）。

main函数中对构造的类进行测试

输入描述：

学生类信息，学号、姓名、性别大学生类信息，学号、姓名、性别、专业研究生类信息，学号、姓名、性别、专业、导师

输出描述：

学生类信息大学生类信息研究生类信息

裁判测试程序样例：

import java.util.Scanner;
public class Main{
    public static void main(String[] args) {
         Scanner scan = new Scanner(System.in);      
         int no = scan.nextInt();
         String name = scan.next();      
         String sex = scan.next();      
         Student s = new Student(no, name, sex);
         s.print();

         no = scan.nextInt();
         name = scan.next();      
         sex = scan.next();      
         String major = scan.next();
         CollegeStudent c = new CollegeStudent(no, name, sex, major);
         c.print();

         no = scan.nextInt();
         name = scan.next();      
         sex = scan.next();      
         major = scan.next();
         String supervisor = scan.next();
         GraduateStudent g = new GraduateStudent(no, name, sex, major, supervisor );
         g.print();
         g.doResearch();
         scan.close(); 
    }
}

/* 你的代码被嵌在这里*/

输入样例：

在这里给出一组输入。例如：

1 liu female
2 chen female cs
3 li male sc wang

输出样例：

在这里给出相应的输出。例如：

no: 1
name: liu
sex: female
no: 2
name: chen
sex: female
major: cs
no: 3
name: li
sex: male
major: sc
supervisor: wang
li is doing research

class Student
{
    public int no;
    public String name;
    public String sex;
    
    public Student(int no, String name, String sex) {
        super();
        this.no = no;
        this.name = name;
        this.sex = sex;
    }

    public void attendClass(String className)
    {
        
    }
    public void print()
    {
        System.out.println("no: "+no);
        System.out.println("name: "+name);
        System.out.println("sex: "+sex);
    }
}
class CollegeStudent extends Student
{
    public String major;

    public CollegeStudent(int no, String name, String sex, String major) {
        super(no, name, sex);
        this.major = major;
    }
    @Override
    public void print() {
        super.print();
        System.out.println("major: "+major);
    }
}
class GraduateStudent extends CollegeStudent
{
    public String supervisor;

    public GraduateStudent(int no, String name, String sex, String major, String supervisor) {
        super(no, name, sex, major);
        this.supervisor = supervisor;
    }
    public void doResearch() 
    {
        System.out.println(name+" is doing research");
    }
    @Override
        public void print() {
            super.print();
            System.out.println("supervisor: "+supervisor);
        }
}

6-34 租车服务 (20 分)

某租车公司提供租车服务，针对不同的车辆类型，日租金的计算方式不同，具体地，对于货车而言，根据载重量load（单位是吨）计算，公式为loadx 1000；对于大型客车而言，根据车内座位数seats计算，公式为seatsx50；对于小型汽车而言，根据车辆等级和折旧年数计算，公式为200*level/sqrt(year)，其中sqrt表示平方根。设计合适的类继承结构实现上述功能，构造租车公司类CarRentCompany，提供静态函数rentVehicles，能够给定一组待租车辆，计算日租金总额。在main函数中，读入多个车辆数据，并计算总的日租金。

输入描述：

汽车数量汽车种类该类汽车相关属性其中1表示货车，2表示大型客车，3表示小型汽车

输出描述：

总的日租金，保留两位小数

裁判测试程序样例：

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int c = sc.nextInt();
        Vehicle[] vs = new Vehicle[c];
        for (int i=0;i<c;i++) {
            int type = sc.nextInt();
            Vehicle v = null;
            if (type == 1) {//货车
                vs[i] = new Truck (sc.nextDouble());
            } else if (type == 2) {
                vs[i] = new Keche(sc.nextInt());
            } else if (type == 3) {
                vs[i] = new Car(sc.nextInt(), sc.nextInt());
            }
        }

        System.out.printf("%.2f",CarRentCompany.rentVehicles(vs));

    }
}

/* 你的代码被嵌在这里 */

输入样例：

在这里给出一组输入。例如：

输出样例：

在这里给出相应的输出。例如：

5947.21

abstract class  Vehicle
{
    public abstract double getRank();
}
class Truck extends Vehicle
{
    public double load;
    public Truck(double load) 
    {
        this.load = load;
    }
    public double getRank()
    {
        return load*1000;
    }
}
class Keche extends Vehicle 
{
    public int seat;
    public Keche(int seat) 
    {
        this.seat = seat;
    }
    public double getRank()
    {
        return seat*50;
    }
}
class Car extends Vehicle 
{
    public int level;
    public int year;
    public Car(int level,int year) 
    {
        this.level = level;
        this.year = year;
    }
    public double getRank()
    {
        return 200*level/Math.sqrt(year);
    }
}
class CarRentCompany
{
    public static double rentVehicles(Vehicle[] vs) 
    {
        double sum = 0;
        for(Vehicle v : vs)
        {
            sum += v.getRank();
        }

　　　　//for(int i = 0 ; i < vs.length ; i++)
　　　　//{
　　　　//flag += vs[i].getFee();
　　　　//}

return sum;
    }
}

6-42 可定制排序的矩形 (20 分)

从键盘录入表示矩形个数的数字n，然后录入n个矩形的长和宽，然后对这n个矩形按照面积从大到小排序，并输出排序后的每个矩形的面积。要求：请设计Rectangle类，包含相应的构造函数和成员函数，实现Comparable接口

输入描述:

矩形个数，每个矩形的长和宽

输出描述:

由大到小排序的每个矩形的面积

裁判测试程序样例：

import java.util.Comparator;
import java.util.Arrays;
import java.util.Scanner;

/*你的代码被嵌在这里*/

public class Main {
    public static void main(String[] args) {

        Scanner scan = new Scanner(System.in);
        //输入矩形个数
        int num_rectangle = scan.nextInt();
        Rectangle[]  recs = new Rectangle[num_rectangle];
        //输入每个矩形的长和宽
        for(int i=0;i<num_rectangle;i++){
            int length = scan.nextInt();
            int width = scan.nextInt();
            Rectangle rec = new Rectangle(length,width);
            recs[i] = rec;
        }
        //按照面积由大到小排序
        Arrays.sort(recs);
        //打印前n-1个矩形的面积
        for(int i=0;i<recs.length-1;i++){
            System.out.print(recs[i].getArea()+",");
        }
        //打印最后一个矩形的面积
        System.out.print(recs[recs.length-1].getArea());
        scan.close();
    }
}

输入样例：

在这里给出一组输入。例如：

3 1 2 3 4 2 3

输出样例：

在这里给出相应的输出。例如：

12,6,2

import java.util.Comparator;
import java.util.Arrays;
import java.util.Scanner;


class Rectangle implements Comparable<Rectangle>
{
    public int length;
    public int width;
    
    public int getLength() {
        return length;
    }

    public void setLength(int length) {
        this.length = length;
    }

    public int getWidth() {
        return width;
    }

    public void setWidth(int width) {
        this.width = width;
    }

    public Rectangle(int length, int width) {
        super();
        this.length = length;
        this.width = width;
    }
    
    public int getArea() 
    {    
        return length*width;
    }

    @Override
    public int compareTo(Rectangle o) 
    {
        return o.getArea() - this.getArea();
    }
}

6-44 数群 (30 分)

请设计如下相关接口和类：

1）接口IntegerGroup表示以某种方式定义的一组整数，称为数群，它可以为空，也可以包含一到多个整数。该接口包含唯一的函数boolean contains(int)，返回某个整数参数是否在这个IntegerGroup对象里。如group1是IntegerGroup类型的一个对象，包含两个数字-5和3，那么group1.contains(-5)返回true，group1.contains(2)返回false。请定义接口IntegerGroup

2）类Range是IntegerGroup的实现类，表示包含在最小值和最大值之间的所有连续整数（最小和最大值包含在内）。例如new Range(-3, 2)表示数群-3，-2，-1，0，1，2。请写出完整的Range类，包括必要的成员数据、构造函数、成员函数。假定最小值小于等于最大值。

3）类Enum也是IntegerGroup的实现类，表示多个分散整数构成的数群。例如new Enum(new int[]{1,3,5,2,-1})表示构造一个包含整数1,3,5, 2,-1的Enum对象，以整数数组作为参数。请完成类Enum，包含必要的成员数据、构造函数、成员函数。

4）类MultipleGroups表示一组IntegerGroup对象，并用一个列表来存储多个IntegerGroup对象，MultipleGroups类有函数add，用于添加IntegerGroup对象，有函数contains，该函数以一个整数作为参数，当且仅当该IntegerGroup对象中的一个或者多个IntegerGroup对象包含这个整数时返回true。例如MultipleGroups对象multiple1包含三个对象 new Range(5, 8), new Range(10, 12), new Enum(new int[]{1, 6})，那么对multiple1.contains的调用应当返回的值如下表所示，请完成类MultipleGroup，包含必要的成员数据、构造函数、成员函数。

QQ截图20200714090611.png

Main函数已经提供，其中构造了一个MultipleGroup对象，然后读入整数n，表示构造的IntegerGroup对象的个数，接着每行表示一个IntegerGroup对象，第一个整数表示对象类型，1为Range对象，2为Enum对象。对于Range对象来说，读入最小值和最大值，对于Enum对象来说，读入包含整数的个数，然后读入各个整数并构造为一个数组传入Enum的构造函数中。最后跟着5个测试数据，调用多个MultipleGroup对象的contains方法进行测试并输出结果。

裁判测试程序样例：

/* 请在这里填写答案 */
public class Main{
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        MultipleGroups mg = new MultipleGroups();
        for (int i=0;i<n;i++) {
            int t = sc.nextInt();
            IntegerGroup ng = null;
            if (t==1) {//Range
                ng = new Range(sc.nextInt(), sc.nextInt());
            } else {//Enum
                int len = sc.nextInt();
                int arr[] = new int[len];
                for (int j=0;j<len;j++)
                    arr[j] = sc.nextInt();
                    ng = new Enum(arr);
            }
            mg.add(ng);
        }
        for (int i=0;i<5;i++)
           System.out.println(mg.contains(sc.nextInt()));
        }
}

输入样例：

在这里给出一组输入。例如：

输出样例：

在这里给出相应的输出。例如：

false
false
true
false
false

import java.util.*;
interface IntegerGroup
{
    boolean contains(int a); 
}
class Range implements IntegerGroup
{
    public int min;
    public int max;
    
    public Range(int min, int max) 
    {
        this.min = min;
        this.max = max;
    }


    @Override
    public boolean contains(int a) 
    {
        if(a >= min && a<= max)
        {
            return true;
        }
        return false;
    }
}
class Enum implements IntegerGroup
{
    public int []nu;
    
    public Enum(int[] nu) 
    {
        this.nu = nu;
    }

    @Override
    public boolean contains(int a) 
    {
        for(int i = 0 ; i < nu.length ; i++)
        {
            if(nu[i] == a)
            {
                return true;
            }
        }
        return false;
    }
}
class MultipleGroups implements IntegerGroup
{
    LinkedList<IntegerGroup> mu = new LinkedList<IntegerGroup>();
    
    public MultipleGroups(LinkedList<IntegerGroup> mu) {
        super();
        this.mu = mu;
    }
    public MultipleGroups() {
        super();
        // TODO Auto-generated constructor stub
    }
    public void add(IntegerGroup ng) 
    {
        mu.add(ng);
    }
    @Override
    public boolean contains(int a) 
    {
        for(int i = 0 ; i < mu.size() ; i++)
        {
            if(mu.get(i).contains(a)) 
            {
                return true;
            }
        }
        return false;
    }
}

6-47 图书和音像租赁 (20 分)

图书和音像店提供出租服务，包括图书和DVD的出租。图书包括书名（String，一个词表示）和价格（double），DVD包括片名（String，一个词表示）。它们都是按天出租，但租金计算方式却不同，图书的日租金为图书价格的1%，DVD的日租金为固定的1元。构造图书和DVD类的继承体系，它们均继承自Media类，且提供方法getDailyRent()返回日租金，构造音像店类MediaShop，提供静态函数double calculateRent(Media[] medias, int days)。在main函数中构造了Media数组，包含图书和DVD的对象，调用calculateRent方法得到并输出租金，保留小数点两位

输入描述：

待租图书和DVD的数量

图书和DVD的详细信息

租借天数

输出描述：

总的租金

裁判测试程序样例：

import java.util.Scanner;

public class Main {
        public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        Media[] ms  = new Media[n];
        for (int i=0; i<n; i++) {
            String type = sc.next();
            if (type.equals("book")) {
                ms[i] = new Book(sc.next(), sc.nextDouble());
            }else {
                ms[i] = new DVD(sc.next());
            }
        }
        double rent = MediaShop.calculateRent(ms, sc.nextInt());
        System.out.printf("%.2f", rent);
    }
}

/* 请在这里填写答案 */

输入样例：

5
book Earth 25.3
book Insights 34
dvd AI
dvd Transformer
book Sun 45.6
20

输出样例：

60.98

abstract class Media
{
    public abstract double getDailyRent();
}
class Book extends Media
{
    public String name;
    public double price;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public double getPrice() {
        return price;
    }
    public void setPrice(double price) {
        this.price = price;
    }
    public Book(String name, double price) {
        this.name = name;
        this.price = price;
    }
    @Override
    public double getDailyRent() 
    {
        return price/100;
    }
}
class DVD extends Media
{
    public String name;
    
    public DVD(String name) {
        this.name = name;
    }

    @Override
    public double getDailyRent() 
    {
        return 1;
    }
}
class MediaShop
{
    static double rent = 0;
    public static double calculateRent(Media[] medias, int days)
    {
        for(int i = 0 ; i < medias.length ; i++)
        {
            rent += medias[i].getDailyRent();
        }
        return rent * days;
    }
    
}

6-48 动物体系 (20 分)

基于继承关系编写一个动物体系，具体的动物包含小狗和小猫。每只动物都有名字和颜色，都能够做自我介绍（introduce）。此外，小狗有智商属性（整数），能接飞盘（catchFrisbee()，方法体内输出一行“catch frisbee”即可），小猫有眼睛颜色属性，能抓老鼠（catchMouse()，方法体内输出一行“catch mouse”即可）。各种小动物自我介绍时均介绍自己的姓名和颜色，此外，小狗应介绍自己的智商，小猫应介绍自己的眼睛颜色。小狗介绍时输出”My name is xxx, my color is xxx, my IQ is xxx”, 小猫介绍时输出“My name is xxx, my color is xxx, my eyecolor is xxx” 构造类TestAnimal，提供静态函数introduce(Animal)，对参数动物自我介绍。提供静态函数action(Animal)，根据参数对象的实际类型进行活动，如果是小狗，则让其接飞盘，如果是小猫，则让其抓老鼠。 Main函数中，根据动物类型构造动物，并调用TestAnimal中的方法进行自我介绍(introduce)和活动(action)

输入描述：

动物类型动物名称动物颜色动物其他属性如 1 猫名称猫颜色猫眼睛颜色 2 狗名称狗颜色狗的智商

输出描述：

自我介绍活动

裁判测试程序样例：

import java.util.Scanner;

/*你的代码被嵌在这里 */

public class Main{

    public static void main(String args[]) {

        Scanner s = new Scanner (System.in);
        int i = s.nextInt();
        Animal a = null;
        if (i==1) {
            a = new Cat(s.next(), s.next(), s.next());
        } else if (i==2) {
            a = new Dog(s.next(), s.next(), s.nextInt());
        }
        TestAnimal.introduce(a);
        TestAnimal.action(a);

    }
}

输入样例：

在这里给出一组输入。例如：

1 Mikey white blue

输出样例：

在这里给出相应的输出。例如：

My name is Mikey, my color is white, my eyecolor is blue
catch mouse

class Animal
{
    public String name;
    public String color;
    public Animal(String name, String color) 
    {
        this.name = name;
        this.color = color;
    }
    public void introduce() {};
    public void action() {};
}
class Cat extends Animal
{
    public String eyecolor;

    public Cat(String name, String color, String eyecolor) 
    {
        super(name, color);
        this.eyecolor = eyecolor;
    }
    public void introduce()
    {
        System.out.println("My name is "+name+", my color is "+color+", my eyecolor is "+eyecolor);
    }
    public void action()
    {
        System.out.print("catch mouse");
    }
}
class Dog extends Animal
{
    public int IQ;

    public Dog(String name, String color, int iQ) 
    {
        super(name, color);
        IQ = iQ;
    }
    public void introduce()
    {
        System.out.println("My name is "+name+", my color is "+color+", my IQ is "+IQ);
    }
    public void action()
    {
        System.out.print("catch frisbee");
    }
}
class TestAnimal
{
    public static void introduce(Animal a) 
    {
        a.introduce();
    }

    public static void action(Animal a) 
    {
        a.action();
    }
}

6-49 设计一个Duck类及其子类 (10 分)

设计一个Duck类和它的两个子类RedheadDuck和MallardDuck。裁判测试程序中的Main类会自动提交。

类的定义：

//Duck类的定义
class Duck {    }

//RedheadDuck类的定义
class RedheadDuck extends Duck {  }

//MallardDuck类的定义
class MallardDuck extends Duck {   }

裁判测试程序样例：

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner scanner=new Scanner(System.in);
        Duck rduck = new RedheadDuck();
        rduck.display();
        rduck.quack();
        rduck.swim();
        rduck.fly();    
        Duck gduck = new MallardDuck();
        gduck.display();
        gduck.quack();
        gduck.swim();
        gduck.fly();         
    }
}
/* 请在这里填写答案 */

输入样例：

在这里给出一组输入。例如：

无

输出样例：

在这里给出相应的输出。例如：

我是一只红头鸭
我会呱呱呱
我会游泳
我会飞
我是一只绿头鸭
我会呱呱呱
我会游泳
我会飞

//Duck类的定义
class Duck
{    
    public void display()
    {
        
    }
    public void quack()
    {
        System.out.println("我会呱呱呱");
    }
    public void swim()
    {
        System.out.println("我会游泳");
    }
    public void fly()
    {
        System.out.println("我会飞");
    }
}

//RedheadDuck类的定义
class RedheadDuck extends Duck 
{ 
    public void display()
    {
        System.out.println("我是一只红头鸭");
    }
}

//MallardDuck类的定义
class MallardDuck extends Duck 
{  
    public void display()
    {
        System.out.println("我是一只绿头鸭");
    }
}

6-50 图书类 (20 分)

构建一个书类Book，包括名称（字符串），价格（整型），作者（字符串，多个作者当做一个字符串处理），版本号（整型），提供带参数的构造函数Book(String name, int price, String author, int edition)，提供该类的toString()和equals()方法，toString方法返回所有成员属性的值的字符串形式，形如“name: xxx, price: xxx, author: xxx, edition: xxx”，当两个Book对象的名称(不关心大小写，无空格)、作者(不关心大小写，无空格)、版本号相同时，认为两者表示同一本书。 Main函数中，读入两本书，输出他们是否相等，打印两本书的信息。

输入描述：

两本书信息

输出描述：

两本书的打印信息两本书是否相等

裁判测试程序样例：

import java.util.Scanner;
public class Main {

    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        Book b1 = new Book(s.next(),
                s.nextInt(),
                s.next(),
                s.nextInt());
        Book b2 = new Book(s.next(),s.nextInt(),s.next(),s.nextInt());

        System.out.println(b1);
        System.out.println(b2);
        System.out.println(b1.equals(b2));

    }

}

/* 你的代码被嵌在这里 */

输入样例：

在这里给出一组输入。例如：

ThinkingInJava
86
BruceEckel
4
CoreJava
95
CayS.Horstmann
10

输出样例：

在这里给出相应的输出。例如：

name: ThinkingInJava, price: 86, author: BruceEckel, edition: 4
name: CoreJava, price: 95, author: CayS.Horstmann, edition: 10
false

class Book
{
    public String name;
    public int price;
    public String author;
    public int edition;
    public Book() 
    {
        super();
    }
    public Book(String name, int price, String author, int edition) 
    {
        super();
        this.name = name;
        this.price = price;
        this.author = author;
        this.edition = edition;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getPrice() {
        return price;
    }
    public void setPrice(int price) {
        this.price = price;
    }
    public String getAuthor() {
        return author;
    }
    public void setAuthor(String author) {
        this.author = author;
    }
    public int getEdition() {
        return edition;
    }
    public void setEdition(int edition) {
        this.edition = edition;
    }
    
    @Override
    public String toString() 
    {
        return  "name: "+name+", "+ 
                "price: "+price+", "+ 
                "author: "+author+", "+ 
                "edition: "+edition;
    }
    @Override
    public boolean equals(Object o) 
    {
        Book b = (Book)o;
        if(b.name.equalsIgnoreCase(this.name) && b.author.equalsIgnoreCase(this.author) && b.edition == this.edition)
        {
            return true;
        }
        
        return false;
    }
}

6-53 成绩管理系统 (20 分)

构造一个成绩管理系统CourseManagementSystem，该系统包括如下几个方法：void add(int no, int grade)添加该学号的成绩，如果系统已有该学生成绩，则输出"the student already exists"；void delete(int no)删除某学号成绩，如果不存在此学生则输出"no such student"；int query（int no）查询并返回该学号的成绩；统计成绩void statistics( )统计[0-59]、[60-69]、[70-79]、[80-89]、[90-100]各成绩段的学生个数并打印。请选择合适的容器实现上述功能。（题目假设不会重复添加相同学号的学生成绩） main函数中读入操作类型及相关参数，并调用statictic函数输出学生成绩统计信息。

输入描述：

操作个数操作名操作参数

输出描述：

查询学生的成绩各成绩段的学生个数

裁判测试程序样例：

import java.util.*;

public class Main {

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        CourseManagementSystem cms = new CourseManagementSystem();
        int ops = sc.nextInt();
        for (int i=0;i<ops;i++) {
            String op = sc.next();
            if (op.equals("add")) 
                cms.add(sc.nextInt(), sc.nextInt());
            else if  (op.equals("delete"))
                cms.delete(sc.nextInt());
            else if  (op.equals("query")) {
                int no = sc.nextInt();
                int s = cms.query(no);
                System.out.println("the score for "+no+" is : "+s);
            }
        }
        cms.statistic();
    }
}

/* 你的代码被嵌在这里*/

输入样例：

在这里给出一组输入。例如：

8
add 1 63
add 2 78
add 3 74
delete 3
add 2 20
delete 5
query 1
add 4 90

输出样例：

在这里给出相应的输出。例如：

the student already exists
no such student
the score for 1 is : 63
[0-59] : 0
[60-69] : 1
[70-79] : 1
[80-89] : 0
[90-100] : 1

class CourseManagementSystem
{
    int[][] A = new int[101][2];
    int n = 0;
    int a=0,b=0,c=0,d=0,e=0;
    
    public void add(int no,int grade)
    {
        if(A[no][1] != 0)
        {
            System.out.println("the student already exists");
        }
        else
        {
            A[no][1] = grade;
            n++;
            if(grade >= 90 && grade <=100)
            {
                a++;
            }
            if(grade <=89 && grade >=80)
            {
                b++;
            }
            if(grade <=79 && grade >=70)
            {
                c++;
            }
            if(grade <=69 && grade >=60)
            {
                d++;
            }
            if(grade <= 59 && grade>=0)
            {
                e++;
            }
        }
        
    }
    public void delete(int no)
    {
        
        if(A[no][1] == 0)
        {
            System.out.println("no such student");
        }
        else
        {
            int x = A[no][1]; 
            A[no][1] = 0;
            n--;
            if(x >= 90 && x <= 100)
            {
                a--;
            }
            if(x <=89 && x >=80)
            {
                b--;
            }
            if(x <=79 && x >=70)
            {
                c--;
            }
            if(x <=69 && x >=60)
            {
                d--;
            }
            if(x <= 59 && x>=0)
            {
                e--;
            }
        }
    }
    public int query(int no)
    {
        return A[no][1];
    }
    public void statistic()
    {
        System.out.println("[0-59] : "+e);
        System.out.println("[60-69] : "+d);
        System.out.println("[70-79] : "+c);
        System.out.println("[80-89] : "+b);
        System.out.println("[90-100] : "+a);
    }
}

6-57 学生信息管理 (30 分)

根据Main类中main方法中的代码，设计满足要求的Student（学生）类：1）包含属性：int no（学号）、String name（姓名）；2）满足Main类中main方法代码的说明要求。 Main类中main方法代码的说明：1）首先，从键盘接收形如“3 cuizhenyu 2 tiangang 1 dingchangqing 4 zhangfeng”的字符串，该字符串中包含了4个学生的学号和姓名（各学生以及学生的学号和姓名之间都用一个空格分隔，姓名中只包含英文字母），然后将该字符串内容中的前3个学生的学号及其姓名放到到Student数组stus中；2）将stus中的3个Student放入到HashSet stuSet中（注意：如果学生的学号相同，则认为是相同对象，不放入stuSet中）；3）将第4个学生对象放入到stuSet中，如果第4个学生对象的学号与stuSet中已有学生对象的学号相同则不能放入。然后，打印出当前stuSet中学生对象的个数；4）用Arrays.sort方法对数组stus按照学生姓名的字母顺序排序（先比较首字母，首字母相同的比较第二个字母，以此类推），输出排序后的stus中3个学生对象的内容，每个学生对象的输出格式为“no=XX&name=YY”。

输入描述：

键盘录入的包含4个学生的学号、姓名的字符串（格式如上述题目描述）

输出描述：

stuSet放入第4个学生对象后的所包含的对象个数，数组stus中包含的前3个学生对象学号、姓名（格式如上述题目描述）

裁判测试程序样例：

import java.util.Arrays;
import java.util.HashSet;
import java.util.Scanner;

public class Main{
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        Student[] stus = new Student[3];

        for(int i=0;i<3;i++){
            int no = scan.nextInt();
            String name = scan.next();
            Student s = new Student(no,name);
            stus[i] =s;
        }
        //将stus中的3个学生对象，放入到HashSet中
        HashSet<Student> stuSet = new HashSet<Student>();
        for(Student s: stus){
            stuSet.add(s);
        }
        //要放入的第4个Student
        Student fourth = new Student(scan.nextInt(),scan.next());
        stuSet.add(fourth);//如果fourth的学号（no）与stuSet中的已有学生的no重复则无法放入
        System.out.println(stuSet.size());

        Arrays.sort(stus);//对stus中的3个原有对象，按照姓名首字符有小到大排序
        for(int i=0;i<stus.length;i++){
            System.out.println(stus[i]);//输出的格式为：no=XX&name=YY
        }

        scan.close();
    }
}

/*你的代码被嵌在这里*/

输入样例：

在这里给出一组输入。例如：

3 cuizhenyu 2 tiangang 1 dingchangqing 4 zhangfeng

输出样例：

在这里给出相应的输出。例如：

4
no=3&name=cuizhenyu
no=1&name=dingchangqing
no=2&name=tiangang

class Student implements Comparable<Student>
{
    public int no;
    public String name;
    public Student(int no, String name) {
        super();
        this.no = no;
        this.name = name;
    }
    public int getNo() {
        return no;
    }
    public void setNo(int no) {
        this.no = no;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public boolean equals(Object obj) 
    {
        if(this == null || obj == null)
        {
            return false;
        }
        if(this.getClass() != obj.getClass())
        {
            return false;
        }
        Student s = (Student)obj;
        if(s.getNo() != this.getNo())
        {
            return false;
        }
        return true;
    }
    public int compareTo(Student o) 
    {
        return this.getName().compareTo(o.getName());
    }
    @Override
    public int hashCode() 
    {
        return this.no;
    }
    @Override
    public String toString() 
    {
        return "no="+no+"&name="+name;
    }
}

查看全文

相关阅读:
office 所有后缀对应的 content-type
Vue 拖拽组件 vuedraggable 和 vue-dragging
vue实现word，pdf文件的导出功能
 vue浏览器全屏实现
 对于js中事件冒泡的理解分析
 一个服务端的登录拦截
 ES6兼容ie9, flex兼容ie9
webpack报错
 vue项目的一个package.json
vue项目的构建过程

原文地址：https://www.cnblogs.com/Chenury/p/14988149.html

Java题目集 函数

输入描述：

输出描述：

裁判测试程序样例：

输入样例：

输出样例：

裁判测试程序样例：

输入样例：

输出样例：

裁判测试程序样例：

输入样例：

输出样例：

输入描述：

输出描述：

裁判测试程序样例：

输入样例：

输出样例：

输入描述：

输出描述：

裁判测试程序样例：

输入样例：

输出样例：

输入描述：

输出描述：

裁判测试程序样例：

输入样例：

输出样例：

输入描述：

输出描述：

裁判测试程序样例：

输入样例：

输出样例：

输入描述：

输出描述：

裁判测试程序样例：

输入样例：

输出样例：

输入描述：

输出描述：

裁判测试程序样例：

输入样例：

输出样例：

输入描述:

输出描述:

裁判测试程序样例：

输入样例：

输出样例：

裁判测试程序样例：

输入样例：

输出样例：

输入描述：

输出描述：

裁判测试程序样例：

输入样例：

输出样例：

输入描述：

输出描述：

裁判测试程序样例：

输入样例：

输出样例：

类的定义：

裁判测试程序样例：

输入样例：

输出样例：

输入描述：

输出描述：

裁判测试程序样例：

输入样例：

输出样例：

输入描述：

输出描述：

裁判测试程序样例：

输入样例：

输出样例：

输入描述：

输出描述：

裁判测试程序样例：

输入样例：

输出样例：

Java题目集函数