沈师 Java程序设计 PTA 编程题答案

文章目录

1. 求最大值 (10 分)

本题目要求读入2个整数A和B，然后输出两个数的最大值。
输入格式:
输入在一行中给出2个绝对值不超过1000的整数A和B。
输出格式:
对每一组输入，在一行中输出最大值。
输入样例:
在这里给出一组输入。例如：
18 -299
输出样例:
在这里给出相应的输出。例如：
18
答案：

import java.util.Scanner;
public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int a = sc.nextInt();
        int b = sc.nextInt();
        System.out.print(a>b?a:b);
    }
}

2. 编程题：统计符合条件元素的个数-hebust (10 分)

统计1…n的闭区间中，能够被3整除元素的奇数和偶数的个数
输入格式:
输入值n的范围是【1…1000】
输出格式:
奇数个数,偶数个数
输入样例:
5
输出样例:
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();
        int x=0,y=0;
        for(int i=1;i<=n;i++){
            if(i%3==0){
                if(i%2==0)
                    y++;
                else
                    x++;
            }
        }
        
        System.out.print(x+","+y);
    }
}

3. 编程题：判断闰年-hebust (10 分)

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


import java.util.Scanner;
public class Main {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        if(n%4==0&&n%100!=0||n%400==0)
            System.out.print("yes");
        else
            System.out.print("no");

    }
}

4. Time Difference (10 分)

What is the time difference between 10:30 and 11:45?
Your program reads two time spots and prints the time difference between them, in terms of hours and minutes.
Input Format
Two time spots, in 24-hour, each is represented as two numbers, as “hour minute”. The second time spot is later than the first and both are within the same day.
Output Format
Two numbers represent the time difference. The first is the hours in the difference, while the second is the minutes.
Sample Input
10 30 11 45
Sample Output
1 15
答案：

import java.util.Scanner;
public class Main {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int h1 = sc.nextInt();
        int m1 = sc.nextInt();
        int h2 = sc.nextInt();
        int m2 = sc.nextInt();
        if(m2==m1&&h2==h1){
            System.out.print(0+" "+0);
        }
        else if(m2>=m1){
            System.out.print(h2-h1+" "+(m2-m1));
        }else{
            System.out.print(h2-h1-1+" "+(m2-m1+60));
        }
    }
}

5. java基本语法-整数四则运算 (10 分)

输入2个整数，输出它们的和、差、乘积和准确的商。
输入格式:
输入两个整数
输出格式:
每一行中依次输出四则运算的结果
输入样例:
70
16
输出样例:
在这里给出相应的输出。例如：
86
54
1120
4.375
答案：

import java.util.Scanner;
public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int a = sc.nextInt();
        int b = sc.nextInt();
        System.out.println(a+b);
        System.out.println(a-b);
        System.out.println(a*b);
        System.out.println((double)a/b);
    }
}

6. 学投资 (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));
   }
}

7. 点是否在圆内? (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);
    }
}

8. 给出一个月的总天数 (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);
    }
}

9. 程序改错题1 (10 分)

程序改错题。以下代码目标是实现从键盘输入1个整数x，然后根据x的值做不同的计算，输出结果。(程序有错，请改正后提交)

import java.util.Scanner;
public class Main {
    public static void main(String args[]) {
        Scanner in = new Scanner(System.in);
        int x, j = 1;
        x = in.nextInt();
        switch (x) {
        case 1:
            j++;
        case 2:
            j++;
        case 3:
            j = x*j++;
        case 4:
            j= x + j++;
        case 5:
            j = x - j++;
        default:
            j = x;
        }
        System.out.println(j);
    }
}

输入格式:
输入整数x。
输出格式:
输出值。
输入样例:
5
输出样例:
4
答案：

import java.util.Scanner;
public class Main {
    public static void main(String args[]) {
        Scanner in = new Scanner(System.in);
        int x, j = 1;
        x = in.nextInt();
        switch (x) {
        case 1:
            j++;break;
        case 2:
            j++;break;
        case 3:
            j = x*j++;break;
        case 4:
            j= x + j++;break;
        case 5:
            j = x - j++;break;
        default:
            j = x;break;
        }
        System.out.println(j);
    }
}

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

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

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 < 60)
			System.out.println("E");
		else if(n >= 60 && n < 70)
			System.out.println("D");
		else if(n >= 70 && n < 80)
			System.out.println("C");
		else if(n >= 80 && n < 90)
			System.out.println("B");
		else if(n >= 90)
			System.out.println("A");
	}
	
}

11. 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;
        }

    }
}

12. 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);
    }
}

13. 统计正数和负数的个数然后计算这些数的平均值 (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);
        }
    }
}

14. 分队列 (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);
    }

}

15. 累加器 (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);
    }

}

16. 我是升旗手 (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);
    }
    
}

17. 等腰直角三角形 (10 分)

等腰直角三角形是指一个角是直角，且两条直角边相等的三角形。这里我们输出直角边长为n的等腰直角三角形的格式如下所示: 比如n=1，则输出:
*
n=2，输出:

*
**

n=3，输出:

*
**
***

那么，你能用程序来实现么?
输入格式:
输入一个数n，表示三角形的边长。1<n<1000。
输出格式:
输出对应的用*表示的等腰直角三角形。
输入样例:
4
输出样例:

*
**
***
****

答案：

import java.util.Scanner;
public class Main {
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        int n;
        String s = "*";
        n = in.nextInt();
        for(int i = 1; i <= n; i++){
            System.out.println(s);
            s += "*";
        }
    }

}

18. 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);

    }

}

19. 倒顺数字串 (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);
    }

}

20. 上三角数字三角形 (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();
        }
        
    }
}

21. 求质数 (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+" ");
        }


    }

}

22. 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();
    }

}

23. 学生类-构造函数 (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());

    }
    
}

24. 定义类 (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;
    }
}

25. 计算年龄 (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);
    }

}

26. 程序填空题2 (10 分)

补全以下程序，使得程序输出结果与下述结果一致。

public class Main {
    public static void main(String[] args) {
        Test test = new Test(true);
    }
}

class Test {
    public Test(){
        System.out.println("Constructor one invoked!");
    }
    public Test(int x){
        //此处添加代码
        System.out.println("Constructor two invoked!");
    }
    public Test(boolean b){
        //此处添加代码
        System.out.println("Constructor three invoked!");
    }

}

输入格式:

无

输出格式:

无

输入样例:

输出样例:

Constructor one invoked!
Constructor two invoked!
Constructor three invoked!

答案：

public class Main {
	public static void main(String[] args) {
		Test test = new Test(true);
	}
}


class Test {
    public Test(){
    	System.out.println("Constructor one invoked!");
    }
    public Test(int x){
    	this();
    	System.out.println("Constructor two invoked!");
    }
    public Test(boolean b){
    	this(1);
    	System.out.println("Constructor three invoked!");
    }

}

27. 定义类与创建对象 (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);
}
}

28. 设计一个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;
	}
}

29. 求矩阵主对角线元素的和 (10 分)

编写一个程序，求n x n的double类型矩阵中主对角线上所有数字的和。
输入格式:
第一行输入矩阵的阶数n（0<=n<=10）。第二行输入矩阵的n x n个double类型的数值。
输出格式:
输出n x n的double类型矩阵中对角线上所有数字的和（double型数值）。
输入样例:
4
1 2 3 4 5 6.5 7 8 9 10 11 12 13 14 15 16
输出样例:
34.5
答案：

import java.util.*;

class Main{
    public static void main(String[] args) {
        Scanner cin = new Scanner(System.in);
        int n = cin.nextInt();
        double [][]d = new double[n][n];
        double sum = 0;

        for(int i = 0; i < n; i ++ ){
            for( int  j = 0; j < n; j ++ ){
                d[i][j] = cin.nextDouble();
                if( i == j ){
                    sum += d[i][j];
                }
            }
        }

        System.out.println(sum);

        cin.close();
    }
}

30. 评委打分 (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(" ");
        }
    }
}

31. 结伴同行去秋游 (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]);
		}
	}
}

32. 数组元素的删除 (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(" ");
			}
		}	
	}
}

33. 定义商品类，封装成员变量，输出对象 (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());
    }

}

34. 程序改错题2 (10 分)

程序改错题。以下代码存在错误，请修改后提交。

public class Main {
    public static void main(String[] args) {
        Animal animal = new Dog();
        animal.shout();
        animal.run();
    }
}

class Animal {
    void shout() {
        System.out.println("animal shout！");
    }
}

class Dog extends Animal {
    void shout() {
        super.shout();
        System.out.println("wangwang……");
    }

    void run() {
        System.out.println("Dog is running");
    }
}

输入格式:
输出格式:
输入样例:
无
输出样例:
animal shout！
wangwang……
Dog is running
答案：

public class Main {
    public static void main(String[] args) {
        Animal animal = new Dog();
        animal.shout();
        ((Dog) animal).run();
    }
}

class Animal {
    void shout() {
        System.out.println("animal shout！");
    }
}

class Dog extends Animal {
    void shout() {
        super.shout();
        System.out.println("wangwang……");
    }

    void run() {
        System.out.println("Dog is running");
    }
}

35. 程序填空题3 (10 分)

参照输出样例补全以下程序，使程序输出结果与输出样例一致。

public class Main {
    public static void main(String[] args) {
        Son son = new Son();
        son.method();
    }
}

class Parent {
    Parent() {
        System.out.println("Parent's Constructor without parameter");
    }

    Parent(boolean b) {
        System.out.println("Parent's Constructor with a boolean parameter");
    }
    
    public void method() {
        System.out.println("Parent's method()");
    }
}

class Son extends Parent {
    //补全本类定义
}

输入格式:
无
输出格式:
无
输入样例:
输出样例:
Parent’s Constructor with a boolean parameter
Son’s Constructor without parameter
Son’s method()
Parent’s method()
答案：

public class Main {
    public static void main(String[] args) {
        boolean b=true;
        Son son = new Son(b);
        son.method();
    }
}

class Parent {
    Parent() {
        System.out.println("Parent's Constructor without parameter");
    }

    Parent(boolean b) {
        System.out.println("Parent's Constructor with a boolean parameter");
    }

    public void method() {
        System.out.println("Parent's method()");
    }
}

class Son extends Parent {
    //补全本类定义
    public Son(){}
    public Son(boolean b){
        super(b);
        System.out.println("Son's Constructor without parameter");
    }

    public void method() {
        System.out.println("Son's method()");
        super.method();
    }

}

36. 图形继承 (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()));
		}
	}
}

37. 设计圆和圆柱体 (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();
    }
}

38. 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();
	}
}

39. 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);
		}
	}
}

40. 声明图书类，记录图书总册数，利用静态变量赋值。 (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);
	}
}

41. 定义类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];
	}

}

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

前言
前面题目形状中我们看到，为了输出所有形状的周长与面积，需要建立多个数组进行多次循环。这次试验使用继承与多态来改进我们的设计。
本题描述：
定义抽象类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();
	}
}

43. 集体评分 (10 分)

程序填空题。请补充以下代码，完成题目要求。（注意：需要提交完整代码）有一个团队由5个人组成。他们每个人给指导老师一个分数，去掉最高分，去掉最低分，剩下的3个分数的平均分就是该团队对指导老师的评分。

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
                Scanner in = new Scanner(System.in);
                int[] grade = new int[5];
                for(int i=0; i<grade.length; i++){
                      grade[i] = in.nextInt();
                 }
                RR rr = new RT(grade);
                double dd = rr.mark();
                System.out.printf("%.2f",dd);
    }
}
abstract class RR{
   int[] grade;
   public RR(int[] grade){
      this.grade = grade;
   }
   public abstract double mark();
}
class RT extends RR{

}

输入格式:
在一行中给出5个不超过10的正整数（从小到大排列）。
输出格式:
输出集体评分，保留小数点后两位。
输入样例:
1 2 4 6 9
输出样例:
4.00
答案：

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

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
                Scanner in = new Scanner(System.in);
                int[] grade = new int[5];
                for(int i=0; i<grade.length; i++){
                      grade[i] = in.nextInt();
                 }       

                RR rr = new RT(grade);
                double dd = rr.mark();
                System.out.printf("%.2f",dd);
    }
}
abstract class RR{
   int[] grade;
   public RR(int[] grade){
      this.grade = grade;
   }
   public abstract double mark();
}
class RT extends RR{
	public RT(int[] grade) {
		super(grade);
	}

	public double mark () {
		double t=0;
		for(int i=1;i<grade.length-1;i++) {
			t=t+grade[i];
		}
		t=t/(grade.length-2);
		return t;
		
	}

}

44. 定义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());
    }
}

45. 集体评分2 (10 分)

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
                Scanner in = new Scanner(System.in);
                int[] grade = new int[5];
                for(int i=0; i<grade.length; i++){
                      grade[i] = in.nextInt();
                 }
                RR rr = new RT(grade);
                double dd = rr.mark();
                System.out.printf("%.2f",dd);
    }
}
interface RR{
   double mark();
}
class RT implements RR{
   int[] grade;
   public RT(int[] grade){
      this.grade = grade;
   }
}

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

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
                Scanner in = new Scanner(System.in);
                int[] grade = new int[5];
                for(int i=0; i<grade.length; i++){
                      grade[i] = in.nextInt();
                 }       

                RR rr = new RT(grade);
                double dd = rr.mark();
                System.out.printf("%.2f",dd);
    }
}
abstract class RR{
   int[] grade;
   public RR(int[] grade){
      this.grade = grade;
   }
   public abstract double mark();
}
class RT extends RR{
	public RT(int[] grade) {
		super(grade);
	}

	public double mark () {
		double t=0;
		for(int i=1;i<grade.length-1;i++) {
			t=t+grade[i];
		}
		t=t/(grade.length-2);
		return t;
		
	}

}

46. 接口–四则计算器 (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;
    }
}

47. 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("我走了");
	}
}

48. jmu-Java-06异常-01-常见异常 (10 分)

自己编码以产生常见异常。
###main方法：
事先定义好一个大小为5的数组。
根据屏幕输入产生相应异常
提示：可以使用System.out.println(e)打印异常对象的信息，其中e为捕获到的异常对象。
**输入说明: **
arr 代表产生访问数组是产生的异常。然后输入下标，如果抛出ArrayIndexOutOfBoundsException异常则显示，如果不抛出异常则不显示。
null，产生NullPointerException
cast，尝试将String对象强制转化为Integer对象，产生ClassCastException。
num，然后输入字符，转化为Integer，如果抛出NumberFormatException异常则显示。
其他，结束程序。
输入样例：
arr 4
null
cast
num 8
arr 7
num a
other
输出样例：
java.lang.NullPointerException
java.lang.ClassCastException: java.lang.String cannot be cast to java.lang.Integer
java.lang.ArrayIndexOutOfBoundsException: 7
java.lang.NumberFormatException: For input string: “a”
答案：

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        int []arr = new int [5];
        Scanner input = new Scanner(System.in);
        while (input.hasNext()){
            String  a = input.next();
            if (a.equals("arr")){
                int b = input.nextInt();
                try {
                    int d = arr[b];
                }catch (Exception e){
                    System.out.println(e.toString());
                }
            }else if (a.equals("num")){
                String  b = input.next();
                try{
                    int d = Integer.parseInt(b);
                }catch (Exception e){
                    System.out.println(e.toString());
                }
            }else if (a.equals("cast")){
                try {
                    Object str = new String("cc");
                    System.out.println((Integer)(str));
                }catch (Exception e){
                    System.out.println(e.toString());
                }
            }else if (a.equals("null")){
                try {
                    String t = null;
                    int l = t.length();
                }catch (Exception e){
                    System.out.println(e.toString());
                }
            }else {
                System.exit(0);
            }

        }
    }
}

49. 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();
	}
}

50. 天不假年 (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{
}

51. 成绩录入时的及格与不及格人数统计 (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);
 
    }
}

52. jmu-Java-01入门-格式化输入输出与字符串 (10 分)

###本题主要考察
使用Scanner处理输入
使用System.out.printf进行格式化输出
String常用方法与字符串常用操作
main
###输入说明：
输入double，然后输入3个浮点数。输出：从左到右依次输出3个double(均保留2位小数输出，宽度为5)，格式依次为：右侧填充空格，左侧填充空格，直接输出
输入int，然后输入3个整数(以1个或多个空格分隔)。输出：将3个整数相加后输出。
输入str，然后输入3个字符串。输出：去除空格，然后倒序输出3个字符。
输入line，然后输入一行字符串。输出：转换成大写后输出。
如果输入不是上面几个关键词，输出:输出other。
###输出说明 choice=你输入选项
该选项对应的输出内容
###提示
可使用line.split(“\s+”);将以1个或多个空格分隔开的字符串分割并放入字符串数组。
Scanner.nextLine与Scanner的其他next函数混用有可能出错。
输入样例:
double
1.578 3.0 3.14259
line
aaaaaaaaaa
int
1 2 3
str
321 654 987
line
dddddddddd
end
输出样例:
choice=double
1.58 , 3.00,3.14
choice=line
AAAAAAAAAA
choice=int
6
choice=str
987654321
choice=line
DDDDDDDDDD
choice=end
other
答案：

import java.util.Scanner;

public class Main{
    public static void main(String args[]){
        String lei;
        Scanner inp=new Scanner(System.in);
        while(true){
            lei=inp.nextLine();
            if(lei.equals("double")){
                double[]  dou=new double[3];
                for(int i=0;i<3;i++)  dou[i]=inp.nextDouble();
                System.out.printf("choice=%s\n",lei);
                System.out.printf("%-5.2f,%5.2f,%.2f\n",dou[0],dou[1],dou[2]);
                inp.nextLine();
            }
            else  if(lei.equals("int")) {
                int sum=0;
                for(int i=0;i<3;i++)  sum+=inp.nextInt();
                System.out.printf("choice=%s\n",lei);
                System.out.printf("%d\n",sum);
                inp.nextLine();
            }
            else if(lei.equals("str")){
                String str;
                str=inp.next();
                str=inp.next()+str;
                str=inp.next()+str;
                System.out.printf("choice=%s\n",lei);
                System.out.println(str);
                inp.nextLine();
            }
            else if(lei.equals("line")){
                String str;
                str=inp.nextLine();
                str=str.toUpperCase();
                System.out.printf("choice=%s\n",lei);
                System.out.println(str);
            }
            else{
                System.out.printf("choice=%s\n",lei);
                System.out.println("other");
            }
        }
    }
}

53. 单词替换 (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();
	}

}

54. 图书价格汇总 (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);
	}

}

55. 通过键盘输入一行字符，分别统计出其中英文字母、空格、数字和其它字符的个数。 (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);
	}
}

56. 数组元素交换 (10 分)

数组元素交换，要求：（1）最大的元素与第一个元素交换（2）最小的元素与最后一个元素交换。
输入格式:
输入一行字符串（由不同的整数组成，以空格分开）
输出格式:
首先以数组形式输出初始字符串（一行一个数字），然后以数组形式输出完成交换后的字符串（一行一个数字）。
输入样例:
2 9 0 10
输出样例:
2
9
0
10
10
9
2
0
答案：


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

public class Main {
    public static void main(String[] args) {
        //获取用户的输入,并解析为一个数组
        Scanner sc = new Scanner(System.in);
        String str = sc.nextLine();
        //分割用户输入得到一个字符串数组
        String[] strs = str.split("\\s+");
        // 遍历这个字符串数组，将每个字符串解析为一个Integer，并装到Integer数组中
        int[] nums = new int[strs.length];

        try {
            for (int i = 0; i < strs.length; i++) {
                nums[i] = Integer.parseInt(strs[i]);
            }
        }catch (NumberFormatException e){
            //System.out.println("你输入有误，请输入数字，其它字符不支持");
        }
        int[] numStart = (int[])Arrays.copyOf(nums,nums.length);
        int max_index = 0;
        int min_index = 0;
        int max =nums[0];
        int min =nums[0];
        int bottle=0;
        // 遍历数组,获取最大数和最小数对应的index值
        for (int i = 0; i < nums.length; i++) {
            if(max<nums[i]){
                max_index=i;
                max = nums[i];
            }
            if(min>nums[i]){
                min_index=i;
                min=nums[i];
            }
        }
        // 捣鼓瓶子，倒来倒去
        bottle=nums[0];
        nums[0]=nums[max_index];
        nums[max_index]=bottle;
        bottle=nums[nums.length-1];
        nums[nums.length-1]=nums[min_index];
        nums[min_index]=bottle;
        // 打印结果
        for(int i=0;i<nums.length;i++) {
            System.out.println(numStart[i]);
        }
        for(int i=0;i<nums.length;i++) {
            System.out.println(nums[i]);
        }

    }
}

57. 判断登录信息–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");
		}
		
	}
}

58. 伪随机数 (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));
        }
        
	}
 
}

59. 计算正五边形的面积和周长 (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;
    }
}

60. 创建一个倒数计数线程 (10 分)

创建一个倒数计数线程。要求：1.该线程使用实现Runnable接口的写法；2.程序该线程每隔0.5秒打印输出一次倒数数值（数值为上一次数值减1）。
输入格式:
N（键盘输入一个整数）
输出格式:
每隔0.5秒打印输出一次剩余数
输入样例:
6
输出样例:
在这里给出相应的输出。例如：
6
5
4
3
2
1
0
答案：

import java.util.Scanner;
public class Main {

    public static void main(String[] args) {
        Test t=new Test();
        Thread th=new Thread(t);
        th.start();
    }
}
class Test implements Runnable {
    public void run() {
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        for(int i=n;i>=0;i--){
            System.out.println(i);
            try 
               {
                Thread.sleep(500);
               } catch (InterruptedException e) {
                e.printStackTrace();
               }
        }


    }

}

61. 程序改错题4 (10 分)

程序改错题。请修改下列代码，使程序能够输出正确的结果。

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Thread t = new Thread(new RunHandler());
        t.run();
    }
}

class RunHandler  {
    public void run() {
        Scanner in = new Scanner(System.in);
        int x = in.nextInt();
            System.out.println("run");
    }
}

输入格式:
输入一个整数x。
输出格式:
输出x行，每行一个字符串“run”。
输入样例:
4
输出样例:
run
run
run
run
答案：

import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		Thread t = new Thread(new RunHandler());
		t.start();
	}
}

class RunHandler implements Runnable  {
	public void run() {
		Scanner in = new Scanner(System.in);
		int x = in.nextInt();
		for(int i=0;i<x;i++) {
			System.out.println("run");
		}
	}
}

62. 试试多线程 (10 分)

编写4个线程，第一个线程从1加到25，第二个线程从26加到50,第三个线程从51加到75，第四个线程从76加到100，最后再把四个线程计算的结果相加。
输入格式:
无
输出格式:
最终结果
输入样例:
输出样例:
5050
答案：

import java.util.Scanner;

public class Main {
    public static void main(String[] args){
        MyRunnble mr1=new MyRunnble(0);
        MyRunnble mr2=new MyRunnble(25);
        MyRunnble mr3=new MyRunnble(50);
        MyRunnble mr4=new MyRunnble(75);
        Thread t1=new Thread(mr1);
        Thread t2=new Thread(mr2);
        Thread t3=new Thread(mr3);
        Thread t4=new Thread(mr4);
        t1.start();
        t2.start();
        t3.start();
        t4.start();
		
		//这里利用一个标记来保证每个线程执行完毕，不知道有没有更好的思路，欢迎探讨
        while (!mr1.isF()||!mr2.isF()||!mr3.isF()||!mr4.isF());
        System.out.println(mr1.getSum()+ mr2.getSum()+ mr3.getSum()+ mr4.getSum());
    }
}

class MyRunnble implements Runnable{
    private int num;
    private int sum=0;
    private boolean f=false;

    public MyRunnble(int num) {
        this.num = num;
    }

    @Override
    public void run() {
        for (int i=0;i<25;i++){
            num++;
            sum+=num;
        }
        f=true;
    }

    public int getSum() {
        return sum;
    }

    public boolean isF() {
        return f;
    }
}

共计62

进程已结束,退出代码0