沈师PTA2021Java编程题复习题库

最新推荐文章于 2024-04-23 18:52:22 发布

小飞睡不醒

最新推荐文章于 2024-04-23 18:52:22 发布

阅读量4.9k

点赞数 8

分类专栏： PTA Java 文章标签： java

本文链接：https://blog.csdn.net/qq_45966405/article/details/121911932

版权

PTA 同时被 2 个专栏收录

7 篇文章 10 订阅

订阅专栏

Java

6 篇文章 0 订阅

订阅专栏

致谢：感谢@WalkingWithTheWind～帮我寻找PTA中的CSS选择器

1. 编程题：判断闰年 (10 分)

根据输入的正整数y所代表的年份，计算输出该年份是否为闰年闰年的判断标准：
能够被4整除且不能被100整除的年份
或者能够被400整除的年份
输入格式:
输入n取值范围是【1…3000】
输出格式:
是闰年，输出 yes
非闰年，输出 no
输入样例:
在这里给出一组输入。例如：
100
结尾无空行
输出样例:
在这里给出相应的输出。例如：
no
结尾无空行
答案：

import java.util.*;

public class Main{
    public static void main(String[] args){
        Scanner scanner = new Scanner(System.in);
        int year;
        year = scanner.nextInt();
        if(year%4==0&&year%100!=0||year%400==0){
            System.out.println("yes");
        }
        else{
            System.out.println("no");
        }
    }
}

2. 学投资 (10 分)

小白学习了一些复利投资知识，想比较一下复利能多赚多少钱（所谓复利投资，是指每年投资的本金是上一年的本金加收益。而非复利投资是指每年投资金额不包含上一年的收益，即固定投资额）。假设他每年固定投资M元（整数），每年的年收益达到P（0<P<1，double)，那么经过N（整数）年后，复利投资比非复利投资多收入多赚多少钱呢？计算过程使用双精度浮点数，最后结果四舍五入输出整数（Math的round函数）。
输入格式:
M P N
输出格式:
复利收入（含本金），非复利收入（含本金），复利比非复利收入多的部分（全部取整，四舍五入）
输入样例:
10000 0.2 3
结尾无空行
输出样例:
17280 16000 1280
结尾无空行
答案：

import java.util.Scanner;

public class Main {
   public static void main(String[] args) {
       Scanner in=new Scanner(System.in);
       long M=in.nextLong();
       double P=in.nextDouble(),sum1,sum2,c;
       int N=in.nextInt();
       sum1=M*(1+N*P);
       sum2=M*(Math.pow((1+P),(double)N));
       if(sum1>sum2) c=sum1-sum2;
       else c=sum2-sum1;
       System.out.print(Math.round(sum2)+" ");
       System.out.print(Math.round(sum1)+" ");
       System.out.print(Math.round(c));
   }
}

3. 点是否在圆内? (10 分)

编写程序，提示用户输入一个点(x,y)，然后检查这个点是否在以原点(0,0)为圆心、半径为10的圆内。
输入格式:
输入任意一个点的x轴和y轴坐标值，且两个值之间空格分隔。
输出格式:
若点在圆内，输出1，否则输出0。
输入样例:
4 5
结尾无空行
输出样例:
1
结尾无空行
答案：

import java.util.Scanner;
public class Main {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n1 = sc.nextInt();
        int n2 = sc.nextInt();
        System.out.println(Math.sqrt(n1*n1+n2*n2)<=10?1:0);
    }
}

4. 给出一个月的总天数 (10 分)

编写程序，提示用户输入月份和年份，然后显示这个月的天数。
输入格式:
输入任意符合范围（1月_{12月）的月份和（1900年}9999年）年份，且两个值之间空格分隔。
输出格式:
输出给定年份和月份的天数。
输入样例:
2 2000
结尾无空行
输出样例:
29
结尾无空行
答案：

import java.util.Scanner;
public class Main {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n1 = sc.nextInt();
        int n2 = sc.nextInt();
        int n3;
        switch(n1){
            case 2:
                if(n2%4==0&&n2%100!=0||n2%400==0)
                    n3=29;
                else
                    n3=28;
                break;
            case 1:
            case 3:
            case 5:
            case 7:
            case 8:
            case 10:
            case 12:
                n3=31;
                break;
            default:
                n3=30;
        }
        System.out.println(n3);
    }
}

5. 成绩分级管理 (10 分)

学校进行成绩分级管理，取消分数制，改为成绩分级评定。具体办法是：小于60分为E类；60分至70分（不含70分）为D类；70分至80分（不含）为C类；80分至90分（不含）为B类；90分以上为A类。设计一个程序，对输入的成绩进行等价划分
输入格式:
输入一个整数表示成绩。
输出格式:
根据输入的成绩，输出对应的等级(大写字母）
输入样例:
在这里给出一组输入。例如：
72
结尾无空行
输出样例:
在这里给出相应的输出。例如：
C
结尾无空行
答案：

import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner scanner = new Scanner(System.in);
        int score;
        score = scanner.nextInt();
        switch(score/10){
            case 9:
            case 10:
                System.out.println("A");
                break;
            case 8:
                System.out.println("B");
                break;
            case 7:
                System.out.println("C");
                break;
            case 6:
                System.out.println("D");
                break;
            default:
                System.out.println("E");
                break;
            
        }
    }
}

6. Java中二进制位运算 (10 分)

本题目要求读入2个整数和一个字符，然后根据这个字符值，对两个整数进行相应的二进制位的运算。要求必须使用switch选择结构。
(1)如果字符是&，则两个整数进行二进制位的与运算；
(2)如果字符是 |，则两个整数进行二进制位的或运算；
(3)如果字符是^，则两个整数进行二进制位异或运算；
(4)如果是其他字符，则固定输出信息：ERROR
输入格式:
在一行中依次输入整数1，字符，整数2。
输出格式:
类似3 & 4 = 0
其中，运算符号&的前后都有一个空格，等号的前后也都有一个空格。上面表示3和4做二进制的与运算，结果是0。
输入样例:
3的二进制是0011，4的二进制是0100，二者与运算的结果是0。
3 & 4
结尾无空行
输出样例:
注意&和=的前后，都是有且仅有一个空格。
3 & 4 = 0
结尾无空行
输入样例:
7 X 3
结尾无空行
输出样例:
ERROR
结尾无空行
答案：

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String str = scanner.nextLine();
        String [] arr = str.split("\\s+");
        int num1 = Integer.parseInt(arr[0]);
        int num2 = Integer.parseInt(arr[2]);
        switch (arr[1]){
            case "&":
                System.out.println(num1 + " & " + num2 + " = " + (num1&num2));
                break;
            case "|":
                System.out.println(num1 + " | " + num2 + " = " + (num1|num2));
                break;
            case "^":
                System.out.println(num1 + " ^ " + num2 + " = " + (num1^num2));
                break;
            default:
                System.out.println("ERROR");
                break;
        }

    }
}

7. JAVA-求整数序列中出现次数最多的数 (10 分)

要求统计一个整型序列中出现次数最多的整数及其出现次数。
输入格式:
在一行中给出序列中整数个数N（0<N≤1000），依次给出N个整数，每个整数占一行。
输出格式:
在一行中输出出现次数最多的整数及其出现次数，数字间以空格分隔。题目保证这样的数字是唯一的。
输入样例:
在这里给出一组输入。例如：
10
3
2
-1
5
3
4
3
0
3
2
结尾无空行
输出样例:
在这里给出相应的输出。例如：
3 4
结尾无空行
答案：

import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
//使用HashMap键值的形式对存放输入的数和次数
public class Main {
    public static void main(String[] args) {
        Scanner cin = new Scanner(System.in);
        HashMap<Integer,Integer> mapCount = new HashMap<>();
        int n = cin.nextInt();
        for(int i = 0;i < n;i++){
            int x = cin.nextInt();
            if(mapCount.containsKey(x)){
                mapCount.put(x,mapCount.get(x)+1);
            }
            else{
                mapCount.put(x,1);
            }
        }
        int k = 0,sum = 0;
        //Map.Entry类提供getKey/getValue方法
        for(Map.Entry<Integer,Integer> entry: mapCount.entrySet()){
            int x = entry.getKey();
            int y = entry.getValue();
            if(y > sum){
                k = x;
                sum = y;
            }
        }
        System.out.println(k+" "+sum);
    }
}

8. 统计正数和负数的个数然后计算这些数的平均值 (10 分)

编写程序，输入未指定个数的整数，判断读入的正数有多少个，读入的负数有多少个，然后计算这些输入值得总和及平均值（不对0计数）。当输入为0时，表明程序结束。将平均值以double型数据显示。
输入格式:
输入在一行中给出一系列整数，其间以空格分隔。当读到0时，表示输入结束，该数字不要处
输出格式:
在第一行中输出正整数的个数；在第二行中输出负整数的个数；在第三行中输出这些输入值的总和（不对0计数）；在第四行中输出这些输入值的平均值（double型数据）。
输入样例:
1 2 -1 3 0
结尾无空行
输出样例:
3
1
5
1.25
结尾无空行
答案：

import java.util.Scanner;

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

        int positiveNum = 0;
        int	negativeNum = 0;
        int sum = 0;

        while (true) {
            int x = input.nextInt();
            if (x == 0)
                break;
            if (x > 0)
                positiveNum++;
            else
                negativeNum++;
            sum += x;
        }

        if (positiveNum + negativeNum != 0) {
            System.out.println(positiveNum);
            System.out.println(negativeNum);
            System.out.println(sum);

            double average = 0.0;
            average = (double)sum/ (positiveNum + negativeNum);
            System.out.println(average);
        }
    }
}

9. 分队列 (10 分)

班级第一次列队，通常老师会让同学按身高排成一列，然后1、2报数，喊到1的同学向前一步，就这样，队伍就变成两列了。假设现在一个班级有n个同学，并且他们已经按身高排成了一列，同学按身高从1到n编号，你能告诉我最后哪些编号的同学站在了第一列么?
输入格式:
输入一个正整数n，表示班级的人数。
输出格式:
按顺序输出所有在第一列的同学对应的编号，每两个编号之间用一个空格隔开。
输入样例:
11
输出样例:
1 3 5 7 9 11
答案：

import java.util.Scanner;
public class Main {

    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        int n=in.nextInt();
        int count=1;
        while(count<=n-2){
            System.out.print(count+" ");
            count+=2;
        }
        System.out.print(count);
    }

}

10. 累加器 (10 分)

请你实现一个累加器。输入n个非负整数，输出他们的和。 1<n<1000，而每个数则<10000。
输入格式:
输入包括两行。第一行:包括一个整数n，表示总共有n个数。第二行:包含n个整数。
输出格式:
输出n个数的和。
输入样例:
4
3 2 1 4
结尾无空行
输出样例:
10
结尾无空行
答案：

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        int n=in.nextInt();
        int sum=0;
        for(int i=0;i<n;i++){
            int x=in.nextInt();
            sum+=x;
        }
        System.out.print(sum);
    }

}

11. 我是升旗手 (10 分)

一年一度的升旗手选拔又要到了，学校要求每个班级选出一位同学做升旗手的候选人。因为升旗手对身高有严格的要求，所以班主任决定选班级里个子最高的同学(如果两位同学一样高，则选任意一位)。你能很快地给老师答案么?
输入格式:
输入包括两行。第一行:包括一个整数n，表示班级里共有n位同学。第二行:包含n个三位数，表示每一位同学的身高。
输出格式:
输出身高最高的同学的身高。
输入样例:
4
130 125 129 140
结尾无空行
输出样例:
140
结尾无空行
答案：

import java.util.Scanner;
public class Main {


    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        int n=in.nextInt();
        int max=0;
        for(int i=0;i<n;i++){
            int x=in.nextInt();
            if(x>max) max=x;
        }
        System.out.print(max);
    }
    
}

12. 666 (10 分)

中国人非常喜欢6这个数字，因为大家总爱说66大顺啊。数学狂人李某人喜欢把什么都数字化，于是她把顺利这个词也定义了数量级，6代表1级顺利，66代表2级顺利，666代表3级顺利，以此类推。你看，数学狂人的世界总是让人无法理解。今天，李某人决定将数学进行到底，现在她设前n级顺利的和是sn。
sn=6+66+666+…+66…66(n个6)。
假设你已经知道了数字n，那么，你能帮李某人求出sn么?
输入格式:
输入一个正整数n，n的范围是[0,10)。
输出格式:
输出Sn的值。
输入样例:
2
结尾无空行
输出样例:
72
结尾无空行
答案：

import java.util.Scanner;
public class Main {


    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        int n;
        n = in.nextInt();
        int sum=0,num=0;
        int x=1;
        for(int i=1;i<=n;i++){
            num += 6*x;
            sum += num;
            x *= 10;
        }
        System.out.println(sum);

    }

}

13. 倒顺数字串 (10 分)

输入正整数n，输出它的倒顺数字串。如n=6时，输出
1 2 3 4 5 6 5 4 3 2 1
输入格式:
输入一个正整数n，n的范围是[1,50]。
输出格式:
n的倒顺数字串，每两个数字之间只用一个空格隔开。
输入样例:
6
结尾无空行
输出样例:
1 2 3 4 5 6 5 4 3 2 1
结尾无空行
答案：

import java.util.Scanner;
public class Main {


    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        if(n!=1){
            for(int i=1;i<=n;i++){
                System.out.print(i+" ");
            }
            for (int i=n-1;i>1;i--){
                System.out.print(i+" ");
            }
        }
        System.out.print(1);
    }

}

14. 上三角数字三角形 (10 分)

输入一个正整数n，输出具有n层的上三角数字三角形。
输入格式:
只有一个正整数n，1<=n<=100。
输出格式:
一个上三角数字三角形，每个数字占四个字符位置。
输入样例:
5
结尾无空行
输出样例:
1 2 3 4 5
6 7 8 9
10 11 12
13 14
15
结尾无空行
答案：

import java.util.Scanner;
public class Main {


    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int count=1;
        for(int i=1;i<=n;i++){
            for (int j=1;j<=n-i+1;j++){
                 System.out.printf("%4d",count);
                count++;
            }
            System.out.println();
        }
        
    }
}

15. 求质数 (10 分)

本题目要求输入一个大于等于2的正整数，求所有不大于该正整数的质数。
输入格式:
输入一个不小于2的正整数。
输出格式:
对输入的正整数，输出不大于该正整数的质数。
输入样例:
30
结尾无空行
输出样例:
2 3 5 7 11 13 17 19 23 29
结尾无空行
答案：

import java.util.Scanner;
public class Main {


    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        int num = in.nextInt();
        for(int i=2;i<=num;i++){
            int j;
            for(j=2;j<i;j++){
                if(i%j==0)
                    break;
            }
            if (i==j)
                System.out.print(i+" ");
        }


    }

}

16. jmu-Java-03面向对象基础-01-构造函数与toString (10 分)

定义一个有关人的Person类，内含属性：
String name、int age、boolean gender、int id，所有的变量必须为私有(private)。注意：属性顺序请严格按照上述顺序依次出现。
1.编写无参构造函数：
打印"This is constructor"。
将name,age,gender,id按照name,age,gender,id格式输出
2.编写有参构造函数
依次对name,age,gender赋值。
3.覆盖toString函数：
按照格式：类名 [name=, age=, gender=, id=]输出。建议使用Eclipse自动生成.
4.对每个属性生成setter/getter方法
5.main方法中
首先从屏幕读取n，代表要创建的对象个数。
然后输入n行name age gender , 调用上面2编写的有参构造函数新建对象。
然后将刚才创建的所有对象逆序输出。
接下来使用无参构造函数新建一个Person对象，并直接打印该对象。
输入样例:
3
a 11 false
b 12 true
c 10 false
输出样例:
Person [name=c, age=10, gender=false, id=0]
Person [name=b, age=12, gender=true, id=0]
Person [name=a, age=11, gender=false, id=0]
This is constructor
null,0,false,0
Person [name=null, age=0, gender=false, id=0]
答案：

import java.util.Scanner;

class Person{
    private String name = null;
    private int age = 0;
    private boolean gender = false;
    private int id = 0;

    public Person() {
        System.out.println("This is constructor");
        System.out.println(name+","+age+","+gender+","+id);
        System.out.println("Person [name="+name+", age="+age+", gender="+gender+", id="+id+"]");
    }

    public Person(String n, int a, boolean g) {
        this.name = n;
        this.age = a;
        this.gender = g;
    }

    public String toString() {
        System.out.println("Person [name="+this.name+", age="+this.age+", gender="+this.gender+", id="+0+"]");
        return name;
    }
}

public class Main {

    public static void main(String[] args) {
        Scanner reader = new Scanner(System.in);
        int number = reader.nextInt();
        Person[] per = new Person[number];
        for(int i=0; i<per.length; i++) {
            String name = reader.next();
            int age = reader.nextInt();
            boolean genter = reader.nextBoolean();
            per[i] = new Person(name,age,genter);
        }
        for(int x=per.length-1; x>=0;x--){
            per[x].toString();
        }

        per.toString();

        Person s = new Person();
    }

}

17. 学生类-构造函数 (10 分)

定义一个有关学生的Student类，内含类成员变量： String name、String sex、int age，所有的变量必须为私有(private)。
1.编写有参构造函数：能对name,sex,age赋值。
2.覆盖toString函数：
按照格式：类名 [name=, sex=, age=]输出。使用idea自动生成,然后在修改成该输出格式
3.对每个属性生成setter/getter方法
4.main方法中
•输入1行name age sex , 调用上面的有参构造函数新建对象。
输入样例:
tom 15 male
结尾无空行
输出样例:
Student [name=‘tom’, sex=‘male’, age=15]
结尾无空行
答案：

import java.util.Scanner;

class Student{
    private String name;
    private String sex;
    private int age;
    public Student(String name, String sex, int age) {

        this.name = name;
        this.sex = sex;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student [name='" + name + "', sex='" + sex + "', age=" + 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 class Main{

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String name=sc.next();
        int age=sc.nextInt();
        String sex=sc.next();
        
        Student s1=new Student(name,sex,age);
        System.out.println(s1.toString());

    }
    
}

18. 定义类 (10 分)

请补充以下代码，完成输出要求。（注意：需要提交完整代码）
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int a,b,c,d,e;
a = in.nextInt();
b = in.nextInt();
c = in.nextInt();
d = in.nextInt();
e = in.nextInt();
RR rr = new RR();
double dd = rr.fun(a,b,c,d,e);
System.out.printf("%.2f",dd);
}
}
class RR{

}
输入格式:
在一行中给出5个不超过1000的正整数。
输出格式:
输出5个整数的平均值，保留小数点后两位。
输入样例:
1 2 3 4 5
结尾无空行
输出样例:
3.00
结尾无空行
答案：


import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
                Scanner in = new Scanner(System.in);
                int a,b,c,d,e;
                a = in.nextInt();
                b = in.nextInt();
                c = in.nextInt();
                d = in.nextInt();
                e = in.nextInt();
                RR rr = new RR();
                double dd = rr.fun(a,b,c,d,e);
                System.out.printf("%.2f",dd);
    }
}

class RR{
    public double fun(int a, int b, int c, int d, int e)
    {
        return (a+b+c+d+e)/5;
    }
}

19. 计算年龄 (10 分)

定义一个Birthday类，其成员变量有3个整形变量（出生的年月日）：year,month,day；提供构造方法对这3个成员变量进行初始化；提供成员变量的get、set方法；成员函数有getAge(),功能是实现计算到2017年12月25日时该Birthday对象的年龄。编写程序测试这个类。
输入格式:
输入出生的年、月、日（注：输入的年月日以换行隔开）
输出格式:
计算得到年龄
输入样例:
在这里给出一组输入。例如：
1995
12
23
结尾无空行
输出样例:
在这里给出相应的输出。例如：
age=22
结尾无空行
答案：

import java.util.Scanner;
class Birthday{
    private int year;
    private int month;
    private int day;    
    public Birthday(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }
    public int getYear() {
        return year;
    }
    public void setYear(int year) {
        this.year = year;
    }
    public int getMonth() {
        return month;
    }
    public void setMonth(int month) {
        this.month = month;
    }
    public int getDay() {
        return day;
    }
    public void setDay(int day) {
        this.day = day;
    }
    public static void getAge(int year,int month,int day){
        int age=0;
        age = 2017-year;
        if(month==12 && day>=25){
        age--;
        }
        System.out.println("age="+age);
    }
}
public class Main {
    public static void main(String[] args) {
        Scanner scan =new Scanner(System.in);
        int year=scan.nextInt();
        int month=scan.nextInt();
        int day=scan.nextInt();
        Birthday.getAge(year,month,day);
    }

}

20. 定义类与创建对象 (10 分)

定义一个类Person,定义name和age属性，定义有参的构造方法对name和age进行初始化。在测试类中创建该类的2个对象，姓名、年龄分别为lili、19和lucy、20，在屏幕打印出2个对象的姓名和年龄。
输入格式:
本题目无输入
输出格式:
在一行中输出一个人的姓名和年龄
输入样例:
在这里给出一组输入。例如：
结尾无空行
输出样例:
在这里给出相应的输出。例如：
this person is lili,her age is 19
this person is lucy,her age is 20
结尾无空行
答案：

class Person{
   String name;
   int age;
   Person(String n,int a){
   name = n;
   age=a;
}
}
public class Main{
public static void main(String args[]){
  Person p1 = new Person("lili",19);
  Person p2 = new Person("lucy",20);
  System.out.println("this person is "+p1.name+
  ",her age is "+p1.age);
  System.out.print("this person is "+p2.name+
  ",her age is "+p2.age);
}
}

21. 设计一个BankAccount类 (10 分)

设计一个BankAccount类，这个类包括：
（1）一个int型的balance表时账户余额。
（2）一个无参构造方法，将账户余额初始化为0。
（3）一个带一个参数的构造方法，将账户余额初始化为该输入的参数。
（4）一个getBlance（）方法，返回账户余额。
（5）一个withdraw（）方法：带一个amount参数，并从账户余额中提取amount指定的款额。
（6）一个deposit（）方法：带一个amount参数，并将amount指定的款额存储到该银行账户上。
设计一个Main类进行测试，分别输入账户余额、提取额度以及存款额度，并分别输出账户余额。
输入格式:
依次输入账户余额、提取额度、存款额度
输出格式:
依次输出初始账户余额、提取amount额度后的账户余额、存入amount后的账户余额
输入样例:
在这里给出一组输入。例如：
700
70
7
输出样例:
在这里给出相应的输出。例如：
700
630
637
答案：

import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		Scanner in=new Scanner(System.in);
		int a,b,c;
		a=in.nextInt();
		b=in.nextInt();
		c=in.nextInt();
		
		BankAccount m=new BankAccount(a);
		System.out.println(m.getBalance());
		System.out.println(m.withdraw(b));
		System.out.println(m.withdraw(b)+m.deposit(c));
	}

}
class BankAccount{
	int balance;
	
	BankAccount(){
		this.balance=0;
	}
	BankAccount(int balance){
		this.balance=balance;
	}
	public int getBalance() {
		return balance;
	}
	public int withdraw(int amount) {
		return balance-amount;
	}
	
	public int deposit(int amount) {
		return amount;
	}
}

22. 评委打分 (10 分)

班级里要搞智力竞赛啦!同学们都踊跃参加。进入最后决赛的是10个同学，随着一道道题目的出示，有时是1号选手得分，有时是5号选手得分，每次答对者得10分，最后结果如何呢?
输入格式:
第一行有十个整数，表示十位同学的初始分。第二行一个整数n，表示有n道题竞赛。接下去有n行，每行有一个数字x，x表示本次可以加分的选手序号（每次答对者得10分）。
输出格式:
10个同学最终的得分值，每两位同学之间有一个空格。
输入样例:
10 0 0 0 10 10 0 0 0 10
3
1
10
1
结尾无空行
输出样例:
30 0 0 0 10 10 0 0 0 20
结尾无空行
答案：

import java.util.Scanner;

public class Main{
    public static void main(String []args){
        Scanner s = new Scanner(System.in);
        int a[]=new int [10];
        for(int i=0;i<10;i++)
        {
            a[i]=s.nextInt();
        }
        int n = s.nextInt();                        //代表接下来输入n个数
        int j;
        for(int i=0;i<n;i++)
        {
            j=s.nextInt();
            j--;
            a[j]+=10;
        }
        for(int i=0;i<10;i++)
        {
            System.out.print(a[i]);
            if(i!=9)
                System.out.print(" ");
        }
    }
}

23. 结伴同行去秋游 (10 分)

可以去秋游啦！同学们别提多高兴了！老师说，单独行动有点危险，那么我们还是结伴同行吧。结伴的规则是这样的：排在最前的一个人和排在最后的那个人结成同伴，排在第2个的与排在倒数第2个的结成同伴…依次类推，2个一组成同伴。好，请马上排出来吧！老师语音一落，同学们“唰唰唰”很快结伴好了，准备出发喽！
输入格式:
第一行是一个整数n，表明n个同学。(2<=n<=50，n为偶数) 。第二行n个整数表明n个同学的学号，学号之间有一个空格。
输出格式:
共n/2行，每行二个整数，表明结伴同学的学号，两个学号之间有一个空格。
输入样例:
6
5 6 4 12 3 2
结尾无空行
输出样例:
5 2
6 3
4 12
结尾无空行
答案：

import java.util.Scanner;

public class Main{
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		int n=input.nextInt();
		int a[]=new int[n];
		for(int i=0;i<n;++i) {
			a[i]=input.nextInt();
		}
		for(int i=0,j=n-1;i<j;++i,--j) {
			System.out.println(a[i]+" "+a[j]);
		}
	}
}

24. 数组元素的删除 (10 分)

完成数组元素的移动功能：假设数组有n个元素，输入一个数x，把数组的第x个位置的元素删除了，后面的元素依次前进一个位置。重复若干次这样的删除，得到最后的结果。
输入格式:
第一行包括一个整数n（1<=n<=100），表示数组元素的个数。第二行输入n个数组元素，均为整数，用空格隔开。第三行输入一个数k（1<=k<=100），表示要进行k次删除。接下来k行，每行一个数x，表示要删除第x个元素。
输出格式:
输出经过k次删除后的数组，每两个元素之间用空格隔开。
输入样例:
10
1 2 3 4 5 6 7 8 9 10
4
3
2
4
6
结尾无空行
输出样例:
1 4 5 7 8 10
结尾无空行
答案：

import java.util.Scanner;
import java.util.LinkedList;

public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		LinkedList<Integer> list = new LinkedList<Integer>();
		int n = sc.nextInt();
		for(int i=0;i<n;i++) {
			list.add(sc.nextInt());
		}
		int k = sc.nextInt();
		for(int i=0;i<k;i++) {
			int index = sc.nextInt();
			list.remove(index-1);
		}
		sc.close();
		
		for(int i=0;i<list.size();i++) {
			System.out.print(list.get(i));
			if(i<list.size()-1) {
				System.out.print(" ");
			}
		}	
	}
}

25. 定义商品类，封装成员变量，输出对象 (10 分)

定义一个商品类。创建对象并按指定格式输出它。商品类要求：
（1）成员变量：商品编号（String）、商品名称(String)、商品单价(double)
（2）成员变量封装，定义为私有属性，并为每个成员变量定义getXXXX，setXXXX方法
（3）定义构造方法，要求带三个参数，参数值用于给成员变量赋值。
（4）重写toString（）方法，将对象转换为字符串，格式：商品编号，商品名称，商品单价
测试类要求：
按指定的格式输入商品信息，调用构造方法生成对象，并输出它。
例：输入：WJ002 记事本 5.5
输出：WJ002,记事本,5.5
输入商品的信息，每个属性值之间用1个空格分隔。输出格式，商品的每个属性值之间用逗号分隔。
输入样例:
WJ002 记事本 5.5
结尾无空行
输出样例:
WJ002,记事本,5.5
结尾无空行
答案：

import java.util.Scanner;
class stuff{
    private String number;
    private String name;
    private double price;
    public String getNumber() {
        return number;
    }
    public void setNumber(String number) {
        this.number = number;
    }
    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;
    }
    stuff(String number, String name,double price ) {//带参的构造方法
        this.name = name;
        this.number = number;
        this.price = price;
    }

    public String toString(){
        return getNumber()+","+getName()+","+getPrice();
    }

}
public class Main {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String number = sc.next();
        String name = sc.next();
        double price = sc.nextDouble();
        stuff a = new stuff(number, name, price);
        System.out.println(a.toString());
    }

}

26. 图形继承 (10 分)

编写程序，实现图形类的继承，并定义相应类对象并进行测试。
类Shape，无属性，有一个返回0.0的求图形面积的公有方法public double getArea();//求图形面积
类Circle，继承自Shape，有一个私有实型的属性radius（半径），重写父类继承来的求面积方法，求圆的面积
类Rectangle，继承自Shape，有两个私有实型属性width和length，重写父类继承来的求面积方法，求矩形的面积
类Ball，继承自Circle，其属性从父类继承，重写父类求面积方法，求球表面积，此外，定义一求球体积的方法public double getVolume();//求球体积
类Box，继承自Rectangle，除从父类继承的属性外，再定义一个属性height，重写父类继承来的求面积方法，求立方体表面积，此外，定义一求立方体体积的方法public double getVolume();//求立方体体积
注意：
每个类均有构造方法，且构造方法内必须输出如下内容：Constructing 类名
每个类属性均为私有，且必须有getter和setter方法（可用Eclipse自动生成）
输出的数值均保留两位小数
主方法内，主要实现四个功能（1-4）：从键盘输入1，则定义圆类，从键盘输入圆的半径后，主要输出圆的面积；从键盘输入2，则定义矩形类，从键盘输入矩形的宽和长后，主要输出矩形的面积；从键盘输入3，则定义球类，从键盘输入球的半径后，主要输出球的表面积和体积；从键盘输入4，则定义立方体类，从键盘输入立方体的宽、长和高度后，主要输出立方体的表面积和体积；
假如数据输入非法（包括圆、矩形、球及立方体对象的属性不大于0和输入选择值非1-4），系统输出Wrong Format
输入格式:
共四种合法输入
1 圆半径
2 矩形宽、长
3 球半径
4 立方体宽、长、高
输出格式:
按照以上需求提示依次输出
输入样例1:
在这里给出一组输入。例如：
1 1.0
结尾无空行
输出样例1:
在这里给出相应的输出。例如：
Constructing Shape
Constructing Circle
Circle’s area:3.14
结尾无空行
输入样例2:
在这里给出一组输入。例如：
4 3.6 2.1 0.01211
结尾无空行
输出样例2:
在这里给出相应的输出。例如：
Constructing Shape
Constructing Rectangle
Constructing Box
Box’s surface area:15.26
Box’s volume:0.09
结尾无空行
输入样例3:
在这里给出一组输入。例如：
2 -2.3 5.110
结尾无空行
输出样例2:
在这里给出相应的输出。例如：
Wrong Format
结尾无空行
答案：

import java.util.Scanner;

class Shape{
	Shape(){
		System.out.println("Constructing Shape");
	}
	public double getArea() {
		return 0.0;
	}
}

class Circle extends Shape{
	private double radius;
	Circle() {
		System.out.println("Constructing Circle");
	}
	@Override
	public double getArea() {
		return radius*radius*Math.PI ;
	}
	public void setRadius(double radius) {
		this.radius = radius;
	}
	public double getRadius() {
		return radius;
	}
	
}

class Rectangle extends Shape{
	private double width,length;
	Rectangle() {
		System.out.println("Constructing Rectangle");
	}
	@Override
	public double getArea() {
		return width*length;
	}
	public void setWidth(double width) {
		this.width = width;
	}
	public void setLength(double length) {
		this.length = length;
	}
	public double getWidth() {
		return width;
	}
	public double getLength() {
		return length;
	}
	
}

class Ball extends Circle{
	Ball(){
		System.out.println("Constructing Ball");
	}
	@Override
	public double getArea() {
		return super.getArea()*4;
	}
	public double getVolume() {
		return getArea()/3*getRadius();
	}
}

class Box extends Rectangle{
	private double height;
	Box(){
		System.out.println("Constructing Box");
	}
	@Override
	public double getArea() {
		return 2*(getWidth()*getLength()+getWidth()*getHeight()+getLength()*getHeight());
	}
	public double getVolume() {
		return super.getArea()*height;
	}
	public void setHeight(double height) {
		this.height = height;
	}
	public double getHeight() {
		return height;
	}
	
}

public class Main {

	private static Scanner type;

	public static void main(String[] args) {
		type = new Scanner(System.in);
		int a=type.nextInt();
		if(a>4||a<1) {
			System.out.println("Wrong Format");
			return;
		}
		if(a==1) {
			double b=type.nextDouble();
			if(b<0) {
				System.out.println("Wrong Format");
				return;
			}
			Circle c=new Circle();
			c.setRadius(b);
			System.out.println("Circle's area:"+String.format("%.2f",c.getArea()));
		}
		if(a==2) {
			double b=type.nextDouble();
			double c=type.nextDouble();
			if(b<0||c<0) {
				System.out.println("Wrong Format");
				return;
			}
			Rectangle d=new Rectangle();
			d.setWidth(b);
			d.setLength(c);
			System.out.println("Rectangle's area:"+String.format("%.2f",d.getArea()));
		}
		if(a==3) {
			double b=type.nextDouble();
			if(b<0) {
				System.out.println("Wrong Format");
				return;
			}
			Ball c=new Ball();
			c.setRadius(b);
			System.out.println("Ball's surface area:"+String.format("%.2f",c.getArea()));
			System.out.println("Ball's volume:"+String.format("%.2f",c.getVolume()));
		}
		if(a==4) {
			double b=type.nextDouble();
			double c=type.nextDouble();
			double d=type.nextDouble();
			if(b<0||c<0||d<0) {
				System.out.println("Wrong Format");
				return;
			}
			Box e=new Box();
			e.setHeight(b);
			e.setLength(c);
			e.setWidth(d);
			System.out.println("Box's surface area:"+String.format("%.2f",e.getArea()));
			System.out.println("Box's volume:"+String.format("%.2f",e.getVolume()));
		}
	}
}

27. 设计圆和圆柱体 (10 分)

编写一个完整的Java Application 程序。包含类Circle、Cylinder、Main，具体要求如下。
（1）编写类Circle，表示圆形对象，包含以下成员
①属性：

radius：私有，double型，圆形半径；
②方法：
Circle(double radius), 构造方法,用参数设置圆的半径
Circle(),构造方法，将圆形初始化为半径为0。
void setRadius(double r)：用参数r设置radius的值
double getRadius()：返回radius的值
double getArea()，返回圆形的面积
double getPerimeter()，返回圆形的周长
public String toString( )，将把当前圆对象的转换成字符串形式，例如圆半径为10.0，返回字符串"Circle(r:10.0)"。
（2）编写一个类Cylinder，表示圆柱形对象，包含以下成员
①属性：
height：私有，double型，圆柱体高度；
circle：私有，Circle类型，圆柱体底面的圆形；
②方法：
Cylinder(double height，Circle circle), 构造方法,用参数设置圆柱体的高度和底面的圆形
Cylinder(),构造方法，将圆柱体的高度初始化为0，底面圆形初始化为一个半径为0的圆形。
void setHeight(double height)：用参数height设置圆柱体的高度
double getHeight()：返回圆柱体的高度
void setCircle(Circle circle)：用参数circle设置圆柱体底面的圆形
Circle getCircle()：返回圆柱体底面的圆形
double getArea()，重写Circle类中的area方法，返回圆柱体的表面积
double getVolume()，返回圆柱体的体积
public String toString( )，将把当前圆柱体对象的转换成字符串形式，例如半径为10.0，高为5.0，返回字符串"Cylinder(h:5.0,Circle(r:10.0))"。
（3）编写公共类Main,在main()方法中实现如下功能
输入一个整数n，表示有n个几何图形。
对于每一个几何图形，先输入一个字符串，“Circle”表示圆形，“Cylinder”表示圆柱体。
如果是圆形，输入一个浮点数表示其半径。要求计算其面积和周长并输出。
如果是圆柱体，输入两个浮点数分别表示其半径和高度。要求计算其面积和体积并输出。

将以下代码附在自己的代码后面：

public class Main{
public static void main(String args[]) {
Scanner input = new Scanner(System.in);
int n = input.nextInt();
for(int i = 0; i < n; i++) {
String str = input.next();
if(str.equals(“Circle”)) {
Circle c = new Circle(input.nextDouble());
System.out.println(“The area of " + c.toString() + " is " + String.format(”%.2f",c.getArea()));
System.out.println(“The perimeterof " + c.toString() + " is “+ String.format(”%.2f”,c.getPerimeter()));
} else if(str.equals(“Cylinder”)) {
Cylinder r = new Cylinder(input.nextDouble(), new Circle(input.nextDouble()));
System.out.println(“The area of " + r.toString() + " is " + String.format(”%.2f",r.getArea()));
System.out.println(“The volume of " + r.toString() + " is " + String.format(”%.2f",r.getVolume()));
}
}
}
}
输入格式:
第一行输入一个整数n，表示有n个几何图形。
以下有n行，每行输入一个几何图形的数据。
每行先输入一个字符串表示几何图形的类型，“Circle”表示圆形，“Cylinder”表示圆柱体。
如果是圆形，输入一个浮点数表示其半径。
如果是圆柱体，输入两个浮点数分别表示其半径和高度。
输出格式:
如果是圆形，要求计算其面积和周长并输出。
如果是圆柱体，要求计算其面积和体积并输出。
注意，圆周率用Math.PI
输入样例:
在这里给出一组输入。例如：
4
Circle 10.0
Cylinder 10.0 10.0
Circle 1.1
Cylinder 1.1 3.4
输出样例:
在这里给出相应的输出。例如：
The area of Circle(r:10.0) is 314.16
The perimeterof Circle(r:10.0) is 62.83
The area of Cylinder(h:10.0,Circle(r:10.0)) is 1256.64
The volume of Cylinder(h:10.0,Circle(r:10.0)) is 3141.59
The area of Circle(r:1.1) is 3.80
The perimeterof Circle(r:1.1) is 6.91
The area of Cylinder(h:1.1,Circle(r:3.4)) is 96.13
The volume of Cylinder(h:1.1,Circle(r:3.4)) is 39.95
答案：

import java.util.Scanner;
class Circle {
private double radius;
    public Circle(){radius=0;}
    public Circle(double radius) {
        this.radius = radius;
    }

    public void setRadius(double radius) {
        this.radius = radius;
    }

    public double getRadius() {
        return radius;
    }
   public double getArea(){
        return Math.pow(radius,2)*3.1415926f;
    }
    public double getPerimeter(){
        return 2*radius*3.1415926f;
    }
    public String toString( ){
        return "Circle(r:"+this.radius+")";
    }
}

class Cylinder extends Circle{
private double height;
private Circle circle;

    public Cylinder(double height, Circle circle) {
        this.height = height;
        this.circle = circle;
    }
    public Cylinder(){this.height=0;}

    public void setHeight(double height) {
        this.height = height;
    }

    public void setCircle(Circle circle) {
        this.circle = circle;
    }

    public double getHeight() {
        return height;
    }

    public Circle getCircle() {
        return circle;
    }
    public double getArea(){
        return height*circle.getPerimeter()+circle.getArea()*2;
    }
    public double getVolume(){
        return circle.getArea()*height;
    }
    public String toString( ){
       return  "Cylinder(h:"+this.height+","+this.circle.toString()+")";
    }
}
public class Main{
    public static void main(String args[]) {
        Scanner input = new Scanner(System.in);
        int n = input.nextInt();
        for(int i = 0; i < n; i++) {
            String str = input.next();
            if(str.equals("Circle")) {
                Circle c = new Circle(input.nextDouble());
                System.out.println("The area of " + c.toString() + " is " + String.format("%.2f",c.getArea()));
                System.out.println("The perimeterof " + c.toString() + " is "+ String.format("%.2f",c.getPerimeter()));
            } else if(str.equals("Cylinder")) {
                Cylinder r = new Cylinder(input.nextDouble(), new Circle(input.nextDouble()));
                System.out.println("The area of " + r.toString() + " is " + String.format("%.2f",r.getArea()));
                System.out.println("The volume of " + r.toString() + " is " + String.format("%.2f",r.getVolume()));
            }
        }
        input.close();
    }
}

28. jmu-Java-01入门-取数字 (10 分)

本题目要求读入若干个代表整数的字符串，然后将其转化为整数。
如果该数＞＝10000且＜＝20000，则依次输出其对应的二进制字符串、八进制字符串、十六进制字符串。
否则将字符串中的每个数字抽取出来，然后将所有数字加总求和。
提示：参考jdk文档的Integer,
输入样例:
123
10000
-123
314159265
输出样例:
1 2 3 6
10011100010000,23420,2710
1 2 3 6
3 1 4 1 5 9 2 6 5 36
答案：


import java.util.Scanner;
 
public class Main{
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		String str;
		while(true){
			str = sc.next();
			Integer data = new Integer(str);
			if(data.intValue() >= 10000 && data.intValue()<=20000){
				System.out.print(Integer.toBinaryString(data.intValue()));
				System.out.print(",");
				System.out.print(Integer.toOctalString(data.intValue()));
				System.out.print(",");
				System.out.print(Integer.toHexString(data.intValue()));
				System.out.println();
			}
			else{
				boolean flag = true;
			int add = 0;
			for(int i=0; i<str.length();++i){
				if(str.charAt(i) == '-'){
					continue;
				}
				if(flag){
					flag = false;
				}
				else{
					System.out.print(" ");
				}
				System.out.print(str.charAt(i));
				add += str.charAt(i) - '0';
			}
			System.out.print(" ");
			System.out.println(add);
			}
			
		}
		//sc.close();
	}
}

29. jmu-Java-01入门-取数字浮点数 (10 分)

本题目要求读入若干以回车结束的字符串表示的整数或者浮点数，然后将每个数中的所有数字全部加总求和。
输入格式:
每行一个整数或者浮点数。保证在浮点数范围内。
输出格式:
整数或者浮点数中的数字之和。题目保证和在整型范围内。
输入样例:
-123.01
234
结尾无空行
输出样例:
7
9
结尾无空行
答案：

import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		while (true) {
			String s = sc.nextLine();
			char[] ch = s.toCharArray();
			int sum = 0;
			for (int i = 0; i < ch.length; i++) {
				if (ch[i] == '-'|| ch[i] == '.') {

				} else {
					//将字符char类型转换成int类型
					int temp = Integer.parseInt(String.valueOf(ch[i]));
					sum += temp;
				}
			}
			System.out.println(sum);
		}
	}
}

30. 声明图书类，记录图书总册数，利用静态变量赋值。 (10 分)

声明一个图书类，其数据成员为书名、编号（利用静态变量实现自动编号）、书价，并拥有静态数据成员册数，记录图书的总册数；在构造方法中，利用静态变量为对象的编号赋值，在主方法中定义对象数组，并求出总册数。
输出格式:
请输出每本图书对应的书名，书号，书价以及总图书数。
输出样例:
书名：Java程序设计, 书号：1, 书价：34.5
书名：数据结构, 书号：2, 书价：44.8
书名：C++程序设计, 书号：3, 书价：35.0
图书总册数为：3
答案：


public class Main {
	public static void main(String[] args) {
		Books b1 = new Books("Java程序设计",34.5);
		Books b2 = new Books("数据结构",44.8);
		Books b3 = new Books("C++程序设计",35.0);
		b1.show();
		b2.show();
		b3.show();
		System.out.println("图书总册数为："+Books.count);
	}
}


class Books{
	private String title;
	private static int id;
	private double price;
	static int count;
	
	public Books() {}
	public Books(String title,double price) {
		this.title = title;
		this.price = price;
		count++;	
	}
	public void show() {
		id++;
		System.out.println("书名："+title+", 书号："+Books.id+", 书价："+price);
	}
}

31. 定义类2 (10 分)

请补充以下代码，完成输出要求。（注意：需要提交完整代码）
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
double dd = RR.fun();
System.out.printf("%.2f",dd);
}
}
class RR{

}
输入格式:
在一行中给出5个不超过1000的实数。
输出格式:
输出排在中间的那个数，保留小数点后两位。
输入样例:
1 2 5 4 3
结尾无空行
输出样例:
5.00
结尾无空行
答案：

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

public class Main {
	public static void main(String[] args) {
		double dd = RR.fun();
		System.out.printf("%.2f", dd);
	}
}

class RR {
	public static double fun() {
		Scanner se=new Scanner(System.in);
		double a[]=new double[5];
		for(int i=0;i<a.length;i++) {
			a[i]=se.nextDouble();
		}
		return a[2];
	}

}

32. jmu-Java-03面向对象基础-04-形状-继承 (10 分)

前言
前面题目形状中我们看到，为了输出所有形状的周长与面积，需要建立多个数组进行多次循环。这次试验使用继承与多态来改进我们的设计。
本题描述
1.定义抽象类Shape
属性：不可变静态常量double PI，值为3.14，
抽象方法:public double getPerimeter(),public double getArea()
2.Rectangle与Circle类均继承自Shape类。
Rectangle类(属性：int width,length)、Circle类(属性：int radius)。
带参构造方法为Rectangle(int width,int length),Circle(int radius)。
toString方法(Eclipse自动生成)
3.编写double sumAllArea方法计算并返回传入的形状数组中所有对象的面积和与
double sumAllPerimeter方法计算并返回传入的形状数组中所有对象的周长和。
4.main方法
4.1 输入整型值n，然后建立n个不同的形状。如果输入rect，则依次输入宽、长。如果输入cir，则输入半径。
4.2 然后输出所有的形状的周长之和，面积之和。并将所有的形状信息以样例的格式输出。提示：使用Arrays.toString。
4.3 最后输出每个形状的类型与父类型.使用类似shape.getClass() //获得类型, shape.getClass().getSuperclass() //获得父类型;
注意：处理输入的时候使用混合使用nextInt与nextLine需注意行尾回车换行问题。
思考
你觉得sumAllArea和sumAllPerimeter方法放在哪个类中更合适？
是否应该声明为static?
输入样例:
4
rect
3 1
rect
1 5
cir
1
cir
2
输出样例:
38.84
23.700000000000003
[Rectangle [width=3, length=1], Rectangle [width=1, length=5], Circle [radius=1], Circle [radius=2]]
class Rectangle,class Shape
class Rectangle,class Shape
class Circle,class Shape
class Circle,class Shape
答案：


import java.util.Scanner;
 
abstract class Shape {
	double PI = 3.14;
 
	public abstract double getPerimeter();
 
	public abstract double getArea();
}
 
class Rectangle extends Shape {
	int wide, len;
 
	Rectangle(int a, int b) {
		wide = a;
		len = b;
	}
 
	@Override
	public double getPerimeter() {
		// TODO Auto-generated method stub
		return 2 * (wide + len);
	}
 
	@Override
	public double getArea() {
		// TODO Auto-generated method stub
		return wide * len;
	}
	
	public String toString(){
		return "[width=" + wide + ", length=" + len + "]";
	}
}
 
class Circle extends Shape {
	int radius;
 
	Circle(int _radius) {
		radius = _radius;
	}
 
	@Override
	public double getPerimeter() {
		// TODO Auto-generated method stub
		return radius * 2 * PI;
	}
 
	@Override
	public double getArea() {
		// TODO Auto-generated method stub
		return radius * radius * PI;
	}
 
	public String toString(){
		return "[radius=" + radius + "]";
	}
 
}
 
public class Main {
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		int n = in.nextInt();
		in.nextLine();
		Shape A[] = new Shape[n];
		int k = 0, j = 0;
		double sumAllArea = 0, sumAllPerimeter = 0;
		for (int i = 0; i < n; i++) {
			String S = in.next();
			if (S.equals("rect")) {
				int wide = in.nextInt(), len = in.nextInt();
				in.nextLine();
				A[i] = new Rectangle(wide, len);
			} else if (S.equals("cir")) {
				int radius = in.nextInt();
				in.nextLine();
				A[i] = new Circle(radius);
			}
			sumAllArea += A[i].getArea();
			sumAllPerimeter += A[i].getPerimeter();
		}
 
		System.out.println(sumAllPerimeter);
		System.out.println(sumAllArea);
		System.out.print("[");
		for (int i = 0; i < n; i++) {
			if(i != 0)
				System.out.print(", ");
			if (A[i] instanceof Rectangle) {
					System.out.print("Rectangle ");
				System.out.print(A[i].toString());
			}
			else {
					System.out.print("Circle ");
				System.out.print(A[i].toString());	
			}
		}
 
		System.out.println("]");
 
		for(int i = 0;i < n;i++) {
			if(A[i] instanceof Rectangle) {
				System.out.println("class Rectangle,class Shape");
			}else {
				System.out.println("class Circle,class Shape");
 
			}
		}
		in.close();
	}
}

33. 定义ClassName接口，设计类Company，实现获取类名称的功能 (10 分)

定义一个ClassName接口，接口中只有一个抽象方法getClassName()；设计一个类Company，该类实现接口ClassName中的方法getClassName()，功能是获取该类的类名称；编写应用程序使用Company类
输出格式:
输出类名称。
输出样例:
Company
答案：

interface ClassName {

    public String getClassName();

}

class Company implements ClassName {
    public String getClassName(){
        return "Company";
    }
}

public class Main {
    public static void main(String []args){
        ClassName name=new Company();
        System.out.println(name.getClassName());
    }
}

34. 接口–四则计算器 (10 分)

利用接口做参数，写个计算器，能完成加减乘除运算。
定义一个接口ICompute含有一个方法int computer(int n, int m)。
定义Add类实现接口ICompute，实现computer方法，求m，n之和
定义Sub类实现接口ICompute，实现computer方法，求n-m之差
定义Main类，在里面输入两个整数a, b，利用Add类和Sub类的computer方法，求第一个数a和第二个数b之和，输出和，第一个数a和第二个数b之差，输出差。
输入格式:
输入在一行中给出2个整数
输出格式:
输出两个数的和、差
输入样例:
在这里给出一组输入。例如：
6 7
结尾无空行
输出样例:
在这里给出相应的输出。例如：
13
-1
结尾无空行
答案：

import java.util.Scanner;

public class Main{
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        int n=in.nextInt();
        int m=in.nextInt();
        Add l=new Add();
        Sub j=new Sub();
        System.out.println(l.computer(n, m));
        System.out.println(j.computer(n, m));

        in.close();

    }
}
interface IComputer{
    abstract public int computer(int n ,int m);
}
class Add implements IComputer
{
    int m,n;
    public int computer(int n ,int m) {
        return n+m;
    }
}
class Sub implements IComputer
{
    int m,n;
    public int computer(int n ,int m) {
        return n-m;
    }
}

35. USB接口的定义 (10 分)

定义一个USB接口，并通过Mouse和U盘类实现它，具体要求是：
1.接口名字为USB，里面包括两个抽象方法：
void work（）；描述可以工作
void stop(); 描述停止工作
2.完成类Mouse，实现接口USB，实现两个方法：
work方法输出“我点点点”；
stop方法输出 “我不能点了”；
3.完成类UPan，实现接口USB，实现两个方法：
work方法输出“我存存存”；
stop方法输出 “我走了”；

4测试类Main中，main方法中
定义接口变量usb1 ，存放鼠标对象，然后调用work和stop方法
定义接口数组usbs,包含两个元素，第0个元素存放一个Upan对象，第1个元素存放Mouse对象，循环数组，对每一个元素都调用work和stop方法。
输入格式:
输出格式:
输出方法调用的结果
输入样例:
在这里给出一组输入。例如：
结尾无空行
输出样例:
在这里给出相应的输出。例如：
我点点点
我不能点了
我存存存
我走了
我点点点
我不能点了
结尾无空行
答案：

public class Main {

	public static void main(String[] args) {
		Mouse usb1=new Mouse();
		usb1.work();
		usb1.stop();
		USB usbs[]=new USB[2];
        usbs[0]=new UPan();
		usbs[0].work();
		usbs[0].stop();
		usbs[1]=new Mouse();
		usbs[1].work();
		usbs[1].stop();
		

	}

}
interface USB{
	void work();
	void stop();
}
class Mouse implements USB{
	public void work(){//要写public
		System.out.println("我点点点");
	}
	public void stop(){
		System.out.println("我不能点了");
	}
}
class UPan implements USB{
	public void work(){
		System.out.println("我存存存");
	}
	public void stop(){
		System.out.println("我走了");
	}
}

36. 单词替换 (10 分)

设计一个对字符串中的单词查找替换方法，实现对英文字符串中所有待替换单词的查找与替换。
输入格式:
首行输入母字符串，第二行输入查询的单词，第三行输入替换后的单词。
输出格式:
完成查找替换后的完整字符串
输入样例:
在这里给出一组输入。例如：
Although I am without you, I will always be ou you
ou
with
结尾无空行
输出样例:
在这里给出相应的输出。例如：
Although I am without you, I will always be with you
结尾无空行
答案：

import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		 String statement;
		    Scanner sc =new Scanner(System.in);
		    statement=sc.nextLine();
		    String word1=sc.next();
		    String word2=sc.next();//用word2替换word1

		    String words[]=statement.split(" ");
		   /* for(int i=0;i<words.length;i++)
		    	System.out.print(words[i]+"\t");*/
		    for(int i=0;i<words.length;i++) {//将句子分割成单词
		    	if(word1.equals(words[i])) {
		    		words[i]=word2;
		    	}
		    }
		   StringBuffer stb=new StringBuffer();
		   String sta=null;
		   for(int i=0;i<words.length;i++) {//数组转换为句子
			   if(i==words.length-1)stb.append(words[i]);
			   else	stb.append(words[i]+" ");
		   }
		   sta=stb.toString();
		   System.out.println(sta);
		    sc.close();
	}

}

37. 图书价格汇总 (10 分)

图书价格汇总
输入格式:
假设某图书馆中图书记录的格式为“Java程序设计： 34；Web程序设计： 56；JSP程序设计：20”（每本书的价格是整数，每本书的价格与下一本书的名字之间有一个中文；）。
输出格式:
编写一个类的方法，能够接受键盘录入的符合上述格式的图书内容字符串，输出图书记录中所有书目的总价格。
输入样例:
Java程序设计：34 ；Web程序设计： 56；JSP程序设计：20
结尾无空行
输出样例:
Java程序设计：34
Web程序设计： 56
JSP程序设计：20
总价格为110
结尾无空行
答案：

import java.util.Scanner;

public class Main {
	
	public static void main(String args[]) {
		Scanner sc=new Scanner(System.in);
		String str=sc.nextLine();
		String bookInfo[]=str.split("；");
		Main main=new Main();
		int sum=0;
		
		for(int i=0;i<bookInfo.length;i++)			//输出分割后的书本信息
			System.out.println(bookInfo[i]);
		
		for(int i=0;i<bookInfo.length;i++) {
			String bn= (bookInfo[i].split("："))[0];//以：分割
			Integer pr=Integer.parseInt((bookInfo[i].split("："))[1].trim());
			sum+=pr.intValue();
			
		}
		System.out.println("总价格为"+sum);
	}

}

38. 通过键盘输入一行字符，分别统计出其中英文字母、空格、数字和其它字符的个数。 (10 分)

统计一行字符串中的英文字母个数、空格个数、数字个数、其他字符个数
输入格式:
通过键盘输入一行字符(任意字符）
输出格式:
统计一行字符串中的中英文字母个数、空格个数、数字个数、其他字符个数
输入样例:
rwrwewre2345asdJSJQI%^&(& *&sdf YY( 2342-k’
结尾无空行
输出样例:
字母个数：22
数字个数：8
空格个数：5
其他字符个数：10
结尾无空行
答案：

import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		String str = sc.nextLine();
		sc.close();
		
		char[] chars = str.toCharArray();
		int letter=0,num=0,blank=0,other=0;
		for(int i=0;i<chars.length;i++) {
			if((chars[i]>='A' && chars[i]<='Z') || (chars[i]>='a' && chars[i]<='z')){
				letter++;
			}else if(chars[i]>=47 && chars[i]<=57) {
				num++;
			}else if(chars[i]==32) {
				blank++;
			}else {
				other++;
			}
		}
		
		System.out.println("字母个数："+letter);
		System.out.println("数字个数："+num);
		System.out.println("空格个数："+blank);
		System.out.println("其他字符个数："+other);
	}
}

39. 判断登录信息–Java字符串比较 (10 分)

从键盘接收用户输入的两个字符串，第一个代表用户名，第二个代表密码。
(1)如果用户名是SwpuIot，并且密码是123456，则输出：Welcome
(2)如果用户名正确，密码不正确，输出：Mismatch
(3)其他情况下，输出：NotExist
要输出的信息，建议从题目中复制，确保精确匹配。
输入格式:
用空格分隔开的两个字符串。
输出格式:
首字母大写的一个单词或词组。
输入样例:
SwpuIot 123456
结尾无空行
输出样例:
Welcome
结尾无空行
答案：

import java.util.Scanner;
public class Main {
	public static void main(String[] args) {
		String str = "SwpuIot 123456";
		String[] strs = str.split(" ");
		
		Scanner sc = new Scanner(System.in);
		String s1 = sc.next();
		String s2 = sc.next();
		sc.close();
		
		if(strs[0].equals(s1) && strs[1].equals(s2)) {
			System.out.println("Welcome");
		}else if(strs[0].equals(s1) && !strs[1].equals(s2)) {
			System.out.println("Mismatch");
		}else {
			System.out.println("NotExist");
		}
		
	}
}

40. 伪随机数 (10 分)

在java.util这个包里面提供了一个Random的类，我们可以新建一个Random的对象来产生随机数，他可以产生随机整数、随机float、随机double，随机long。Random的对象有两种构建方式：带种子和不带种子。不带种子的方式将会返回随机的数字，每次运行结果不一样。无论程序运行多少次，带种子方式构建的Random对象会返回一样的结果。
请编写程序，使用第一种方式构建Random对象，并完成下面输入输出要求。
输入格式:
在一行中输入3个不超过10000的正整数n,m,k。
输出格式:
在一行中输出以k为种子建立的Random对象产生的第n个0到m-1之间的伪随机数。
输入样例:
10 100 1000
结尾无空行
输出样例:
50
结尾无空行
答案：


import java.util.*;
public class Main {
 
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int m = sc.nextInt();
        int k = sc.nextInt();
        List<Integer> ss = new ArrayList<Integer>();
        //Set<Integer> ss = new HashSet<Integer>();
        Random rand = new Random(k);
        for(int i = 0;i < n;i++)
        {
        	ss.add(rand.nextInt(m));
        	if(i==n-1)
        		System.out.println(ss.get(i));
        }
        
	}
 
}

41. jmu-Java-06异常-02-使用异常机制处理异常输入 (10 分)

使用异常处理输入机制，让程序变得更健壮。
main方法：
输入n，创建大小为n的int数组。
输入n个整数，放入数组。输入时，有可能输入的是非整型字符串，这时候需要输出异常信息，然后重新输入。
使用Arrays.toString输出数组中的内容。
输入样例：
5
1
2
a
b
4
5
3
输出样例：
java.lang.NumberFormatException: For input string: “a”
java.lang.NumberFormatException: For input string: “b”
[1, 2, 4, 5, 3]
答案：

import java.util.*;
public class Main{
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		int n=scan.nextInt();
		int a[]=new int[n];
		int count=0;
		while(count<n) {
			try {
				String temp=scan.next();
				int i=Integer.parseInt(temp);
				a[count++]=i;
			}catch(Exception e) {
				System.out.println(e);
			}
		}
		System.out.println(Arrays.toString(a));
		scan.close();
	}
}

42. 天不假年 (10 分)

程序填空题。根据题目要求完善下面的代码。请提交完整代码。 “今年50，明年18”是一个美好的愿望。人的年龄只能不断增长。 Person类的setAge方法用于更新年龄。如果新的年龄比原来的年龄小，则输出B表示发现异常，否则输出A表示正常。
import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner in = new Scanner(System.in);
int age;
age = in.nextInt();
Person p = new Person(age);
age = in.nextInt();
try{
p.setAge(age);
}catch(AgeException e){
}
}
}
class Person{
int age;
public Person(int age){
this.age = age;
}
public void setAge(int age) throws AgeException {
if(this.age <=age){
this.age = age;
}else{
throw new AgeException();
}
}
}
class AgeException extends Exception{
}
输入格式:
输入在一行中给出2个绝对值不超过100的正整数A和B。
输出格式:
在一行中输出一个字符A或者B。
输入样例:
50 18
结尾无空行
输出样例:
B
结尾无空行
答案：


import java.util.Scanner;
public class Main{
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        int age;
        age = in.nextInt();
        Person p = new Person(age);
        age = in.nextInt();
        try{
            p.setAge(age);
            System.out.println("A");
        }catch(AgeException e){
            System.out.println("B");
        }
    }
}
class Person{
    int age;
    public Person(int age){
        this.age = age;
    }
    public void setAge(int age) throws AgeException {
        if(this.age <=age){
            this.age = age;
        }else{
            throw new AgeException();
        }
    }
}
class AgeException extends Exception{
}

43. 成绩录入时的及格与不及格人数统计 (10 分)

编写一个程序进行一个班某门课程成绩的录入，能够控制录入成绩总人数，对录入成绩统计其及格人数和不及格人数。设计一个异常类，当输入的成绩小0分或大于100分时，抛出该异常类对象，程序将捕捉这个异常对象，并调用执行该异常类对象的toString（）方法，该方法获取当前无效分数值，并返回一个此分数无效的字符串。
输入格式:
从键盘中输入学生人数n
从键盘中输入第1个学生的成绩
从键盘中输入第2个学生的成绩
…
从键盘中输入第n个学生的成绩
（注：当输入的成绩无效时（即分数为小于0或大于100）可重新输入，且输出端会输出此分数无效的提醒。）
输出格式:
显示及格总人数
显示不及格总人数
输入样例:
在这里给出一组输入。例如：
3
100
30
60
结尾无空行
输出样例:
在这里给出相应的输出。例如：
2
1
结尾无空行
输入样例:
在这里给出一组输入。例如：
2
200
69
30
结尾无空行
输出样例:
在这里给出相应的输出。例如：
200invalid!
1
1
结尾无空行
答案：

import java.util.Scanner;
 
public class Main {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int count=sc.nextInt();
        int pass=0;
        for (int i=0;i<count;i++){
            int grade=sc.nextInt();
            if (grade<0||grade>100){
                System.out.println(grade+"invalid!");
                i--;
            }else if (grade>=60){
                pass++;
            }
        }
        System.out.println(pass);
        System.out.println(count-pass);
 
    }
}

44. 计算正五边形的面积和周长 (10 分)

从键盘输入一个数作为正五边形的边长，计算并输出该正五边形的周长和面积。
计算正五边形的面积公式为： S=a
2
×
25+10×
5
/4
输入格式:
输入正五边形的边长。例如：
5
输出格式:
输出正五边形的面积和周长。第一行输出面积，第二行输出周长。例如：
43.0119
25
输入样例:
16.8
结尾无空行
输出样例:
485.5875
84
结尾无空行
答案：

import java.lang.Math;
import java.math.BigDecimal;
import java.text.DecimalFormat;
import java.util.Scanner;
public class Main {
    public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    double a=in.nextDouble();
    Bian b1=new Bian(a);

    DecimalFormat df1 = new DecimalFormat("#.####"); 
    System.out.println(df1.format(b1.getArea()));
    System.out.println(df1.format(b1.getPerimeter()));
    } 
}
abstract class shape{// 抽象类
     public abstract double getArea();
     public abstract double getPerimeter(); 
}
class Bian extends shape{
    private double a;
    public Bian(double a){
        this.a=a;
    }
    public double getArea(){
        double s=a*a/4*(Math.sqrt(25+10*Math.sqrt(5.0)));
        return s;
    }
    public double getPerimeter(){
        return a*5;
    }
}