1.试题编号：1-1-1：任务实现1

package com.test;

import java.util.Scanner;

public class Test1 {

// 任务一：通过键盘输入某年某月某日，计算并输出这一天是这一年的第几天。例如，2001
// 年 3 月 5 日是这一年的第 64 天。(30 分)
// 要求：使用分支结构语句实现
public static void main(String[] args) {

    // 1.考点 分支结构/闰年

    // 2.思路
    // 2.1扫描器接收用户的输入
    // 2.2判断是否是闰年
    // 2.3计算是第几天

    // 2.1
    Scanner scanner = new Scanner(System.in);
    System.out.println("请输入年：");
    int year = scanner.nextInt();
    System.out.println("请输入月：");
    int month = scanner.nextInt();
    System.out.println("请输入日：");
    int day = scanner.nextInt();

    // 2.2 闰年满足条件： 1.能被400整除 2.能被4整除且不能被100整除
    boolean isOK = (year % 400 == 0) || (year % 4 == 0 && year % 100 != 0);

    // 2.3计算闰年 2022年 3月 10日 31+28+10=69

    int[] days = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };

    int total = 0;// 表示总天数

    // 加上之前的天数
    for (int i = 0; i < month - 1; i++) {
        total = days[i] + total;
    }

    total = total + day;
    // 如果是闰年,并且月份大于2
    if (isOK && month > 2) {
        total = total + 1;
    }

    System.out.println(year + "年" + month + "月" + day + "日是这一年的第" + total + "天");
}

}

package com.test;

public class Test2 {
// 任务二：编程实现判断一个整数是否为“水仙花数”。所谓“水仙花数”是指一个三位
// 的整数，其各位数字立方和等于该数本身。例如：153 是一个“水仙花数”，因为 153=13＋
// 53＋33。(30 分)
// 要求：用带有一个输入参数的函数(或方法)实现，返回值类型为布尔类型。
public static void main(String[] args) {

    int a = 153;
    boolean isOK = isFun(a);

    if (isOK) {
        System.out.println(a + "是水仙花数");
    } else {
        System.out.println(a + "不是水仙花数");
    }
}

public static boolean isFun(int num) {
    // num = 345;
    int i = num / 100;// 百位
    int j = num % 100 / 10;// 十位
    int k = num % 10;// 个位

    // 如果:各位数字立方和等于该数本身,这个数就是水仙花数
    if (i * i * i + j * j * j + k * k * k == num) {
        return true;
    }
    return false;
}

}

package com.test;

import java.util.Scanner;

public class Test3 {

// 任务三：从键盘上输入一个年份值和一个月份值，输出该月的天数。(说明：一年有 12
// 个月，大月的天数是 31，小月的天数是 30。2 月的天数比较特殊，遇到闰年是 29 天，否则
// 为 28 天。例如，输入 2011、3，则输出 31 天。) (30 分)
// 要求：使用分支结构语句实现。
public static void main(String[] args) {

    int[] days = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };

    // 1.接收用户输入
    Scanner scanner = new Scanner(System.in);
    System.out.println("请输入年：");
    int year = scanner.nextInt();
    System.out.println("请输入月：");
    int month = scanner.nextInt();

    // 2.判断是否是闰年
    boolean isOK = (year % 400 == 0) || (year % 4 == 0 && year % 100 != 0);

    // 3.判断这年这月有多少天
    int num = 0;
    switch (month) {
    case 1:
        num = 31;
        break;
    case 2:
        if (isOK) {
            num = 29;
        } else {
            num = 28;
        }
        break;
    case 3:
        num = 31;
        break;
    case 4:
        num = 30;
        break;
    case 5:
        num = 31;
        break;
    case 6:
        num = 30;
        break;
    case 7:
        num = 31;
        break;
    case 8:
        num = 31;
        break;
    case 9:
        num = 30;
        break;
    case 10:
        num = 31;
        break;
    case 11:
        num = 30;
        break;
    case 12:
        num = 31;
        break;
    }

    System.out.println(year + "年" + month + "月有" + num + "天");
}

}

2.试题编号：1-1-2：任务实现2

package com.test2;

public class Test1 {
// 任务一：使用冒泡排序法对数组中的整数按升序进行排序，
// 如下所示： 原始数组：a[]={1,9,3,7,4,2,5,0,6,8}
// 排序后： a[]={0,1,2,3,4,5,6,7,8,9}
// 要求：综合使用分支、循环结构语句实现，直接输出结果不计分。(30分)
public static void bubbleSort(int[] a) {
int n = a.length;

    for (int i = 0; i < n - 1; ++i) {
        // 每次遍历都将最大值移动到数组末尾
        for (int j = 0; j < n - i - 1; ++j) {
            if (a[j] > a[j + 1]) {
                // 交换相邻元素位置
                int temp = a[j];
                a[j] = a[j + 1];
                a[j + 1] = temp;
            }
        }
    }
}

private static void printArray(int[] a) {
    for (int num : a) {
        System.out.print(num + " ");
    }
    System.out.println();
}

public static void main(String[] args) {
    int[] a = { 1, 9, 3, 7, 4, 2, 5, 0, 6, 8 };

    System.out.println("原始数组：");
    printArray(a);

    bubbleSort(a); //调用冒泡排序方法

    System.out.println("\n排序后的数组：");
    printArray(a);

}

}

package com.test2;

import java.util.Scanner;

public class Test2 {
// 任务二：从键盘输入三条边A、B、C 的边长，请编程判断能否组成一个三角形。(30分)
// 要求：A,B,C <1000，如果三条边长A、B、C 能组成三角形的话，输出YES，否则NO。 public static void main(String[] args) { // 1.接收用户输入 Scanner sc = new Scanner(System.in); System.out.println(“请输入小于1000的边长A”); float A = sc.nextFloat(); System.out.println(“请输入小于1000的边长B”); float B = sc.nextFloat(); System.out.println(“请输入小于1000的边长C”); float C = sc.nextFloat(); sc.close(); // 2.判断是否能组成三角形 // 满足：任意两边之和大于第三边 if (A + B > C && A + C > B && B + C > A) {
System.out.println(“YES”);
} else {
System.out.println(“NO”);
}
}

}

package com.test2;

import java.util.Scanner;

public class Test3 {
// 任务三：分别输入两个字符串 s1 和s2 ，
// 请问s1 中包含多少个s2，如果没有则输出0。(30分)
// 要求：使用String对象完成。
public static void main(String[] args) {
// 接收用户输入字符串
Scanner scanner = new Scanner(System.in);
System.out.println(“请输入第一个字符串：”);
String s1 = scanner.nextLine();
System.out.println(“请输入第二个字符串：”);
String s2 = scanner.nextLine();
scanner.close();
int count = 0; // 字符串个数
int index = 0; // 开始查找的索引位置
while ((index = s1.indexOf(s2, index)) != -1) {
count++;
index += s2.length();
}
System.out.println(“字符串s1中包含” + count + “个s2”);
}
}

3.试题编号：1-1-3：任务实现3

package com.test3;

import java.util.Scanner;

public class Test1 {
// 任务一：输入一个百分制的成绩t，将其转换成对应的等级然后输出，
// 具体转换规则如下：90~100 为 A;80~89 为 B；70~79 为 C；60~69 为 D0~59 为 E。(30分)
// 要求：如果输入数据不在0~100 范围内，请输出一行：“Score is error!”。
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println(“请输入一个百分制的成绩：”);
int t = scanner.nextInt();
scanner.close();
String str = “”;
if (t < 0 || t > 100) {
str = “Score is error!”;
} else if (t >= 90) {
str = “A”;
} else if (t >= 80) {
str = “B”;
} else if (t >= 70) {
str = “C”;
} else if (t >= 60) {
str = “D”;
} else {
str = “E”;
}

    System.out.println(str);
}

}

=========================================================
package com.test3;

import java.util.Scanner;

public class Test2 {
// 任务二：任意输入十个数据，打印出该十个数据的最大值、最小值。(30分)
// 要求：①定义一个大小为10 的整形数组a；
// ②从键盘输入10 个整数，放置到数组a 中；
// ③输出数组a 中的最大值、最小值。
public static void main(String[] args) {

    int[] a = new int[10];

    Scanner sc = new Scanner(System.in);
    // 1.循环接收用户输入
    for (int i = 0; i < a.length; i++) {
        System.out.println("请输入第" + (i + 1) + "个整数：");
        a[i] = sc.nextInt();
    }

    // 2.获取最大最小值

// Arrays.sort(a);
//
// System.out.println(“最小值为：”+a[0]);
// System.out.println(“最大值为：”+a[9]);
int max = a[0];
int min = a[0];
for (int i = 0; i < a.length; i++) { if (a[i] > max) {
max = a[i];
}
if (a[i] < min) {
min = a[i];
}
}
System.out.println(“最小值为：” + min);
System.out.println(“最大值为：” + max);
sc.close();
}
}

=========================================================
任务三：请完成以下编程工作：①定义学生类，其包含 2 个属性：学号，姓名。②定义大学生类，该类继承学生类，并新增一个属性：专业。③为大学生类实例化一个对象，并给这个大学生对象的所有属性赋值。(30分)
要求：
①所有属性的数据类型均为字符串类型。
②大学生类应该继承于学生类。
③在主函数(或主方法)中实例化大学生对象，并给该对象的每个属性赋值
++++++College.java文件++++++
package com.util;

public class College extends Student {

public String type;

@Override
public String toString() {
    return "College [type=" + type + ", num=" + num + ", name=" + name + "]";
}

public static void main(String[] args) {
    College college = new College();

    college.num = "1001";
    college.name = "小花";
    college.type = "软件技术";
    System.out.println(college);
}

}
++++++Student.java文件++++++
package com.util;

public class Student {

public String num;

public String name;

}

4.试题编号：1-1-4：任务实现4

package com.test;

public class Test1 {
// 任务一：输出阶梯形式的99 乘法口诀表，如下图1.4.1所示。(30分) // 11=1
// 12=2 22=4
// 13=3 23=6 33=9 // 14=4 24=8 34=12 44=16 // 15=5 25=10 35=15 45=20 55=25
// 16=6 26=12 36=18 46=24 56=30 66=36
// 17=7 27=14 37=21 47=28 57=35 67=42 77=49 // 18=8 28=16 38=24 48=32 58=40 68=48 78=56 88=64 // 19=9 29=18 39=27 49=36 59=45 69=54 79=63 89=72 99=81
public static void main(String[] args) {

    for (int i = 1; i <= 9; i++) { // 外层循环控制行
        for (int j = 1; j <= i; j++) { // 内层循环控制列
            System.out.print(j + "*" + i + "=" + (i * j) + "\t");
        }
        System.out.println(); // 输完一行，换行
    }
}

}

任务二：创建 5 个学生对象，并赋给一个学生数组，每个学生有以下属性：学号名、 年龄，请按顺序实现以下任务：
子任务 1：将学生按学号排序输出。
子任务 2：给所有学生年龄加 1。
子任务 3：在实现子任务 2 的基础上，统计大于 20 岁的学生人数。(30分)
++++++Student.java文件++++++
package com.util;

public class Student implements Comparable {

public int num;

public String name;

public int age;

public Student(int num, String name, int age) {
    super();
    this.num = num;
    this.name = name;
    this.age = age;
}

@Override
public String toString() {
    return "Student [num=" + num + ", name=" + name + ", age=" + age + "]";
}

@Override
public int compareTo(Student student) {
    return this.num - student.num;
}

}

++++++Test.java文件++++++
package com.util;

import java.util.Arrays;

public class Test {
// 任务二：创建 5 个学生对象，并赋给一个学生数组，每个学生有以下属性：学号、姓
// 名、 年龄，请按顺序实现以下任务：
// 子任务 1：将学生按学号排序输出。
// 子任务 2：给所有学生年龄加 1。
// 子任务 3：在实现子任务 2 的基础上，统计大于 20 岁的学生人数。(30 分)
public static void main(String[] args) {

    // 1.创建5个学生对象
    Student s1 = new Student(1, "A", 20);
    Student s2 = new Student(3, "B", 22);
    Student s3 = new Student(2, "C", 21);
    Student s4 = new Student(5, "D", 18);
    Student s5 = new Student(4, "E", 19);

    // 2.数组的静态初始化
    Student[] sts = { s1, s2, s3, s4, s5 };

    // 3.排序
    Arrays.sort(sts);

    // 4.打印信息
    int count = 0;// 统计大于20岁的人数
    for (Student student : sts) {
        student.age = student.age + 1;// 年龄+1
        if (student.age > 20) {
            count++;
        }
    }

    System.out.println("在实现子任务 2 的基础上，统计大于 20 岁的学生人数：" + count);
}

}

package com.test;

public class Test3 {

// 任务三：有一分数序列：2/1，3/2，5/3，8/5，13/8，21/13 … 求出这个数列的前 20 项之和。(30 分)
// 要求：利用循环计算该数列的和。注意分子、分母的变化规律。(30 分)
public static void main(String[] args) {

    // 分子: 2 3 5 8 13 21
    // 分母: 1 2 3 5 8 13

    // 斐波那契数列: 1 1 2 3 5 8 13 21 34
    // 从第一项和第二项为1,从第三项开始,每一项都是前2项的和

    double sum = 0;// 最终的和
    for (int i = 1; i <= 20; i++) {// 统计20项
        sum = sum + fbnq(i + 2) / fbnq(i + 1);
    }

    System.out.println("前20项之和为：" + sum);
}

public static double fbnq(int n) {
    if (n == 1 || n == 2) {
        return 1;
    }
    return fbnq(n - 1) + fbnq(n - 2);
}

}

5.试题编号：1-1-5：任务实现5

package com.test;

import java.util.Scanner;

public class Test1 {
// （1）任务描述
// 任务一：所谓“降序数”是指一个自然数的低位数字不大于高位数字的数。
// 例如：64，55，321都认为是降序数，但是623不是降序数。一位数字被认为是降序数。
// 编一个程序，输入一个数，判定它是否为降序数。该程序是循环执行的，当输入的数为0时，则退出程序运行。(30分)
// 要求：利用while循环实现
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int num = 1;
while (num != 0) {
System.out.print(“请输入一个数字（输入0退出程序）：”);
num = scanner.nextInt();
if (num == 0) {
break;
} else if (isDescending(num)) {
System.out.println(num + ” 是降序数”);
} else {
System.out.println(num + ” 不是降序数”);
}
}
System.out.println(“程序结束”);
}

// 检查一个数字是否为降序数的方法
public static boolean isDescending(int num) {
    int temp = num; // 临时变量
    int prev = temp % 10; // 从后面数第一位数字
    temp = temp / 10; // 去掉刚刚取的数字
    while (temp != 0) {
        int curr = temp % 10; // 取最后一个数字给当前变量curr
        if (curr < prev) { // 当前变量>从后面数前一位数字
            return false; // 不是降序数
        }
        prev = curr; // 当前变量里的数字给prev变量，下次变成前一位数字了
        temp /= 10; // 去掉最后一个数字
    }
    return true;
}

}

package com.test;

import java.util.Scanner;

public class Test2 {

// 任务二：根据输入的半径值，计算球的体积。输入多组数据，每组占一行，每行包括一
// 个实数，表示球的半径，输入-1 时，表示输入结束。输出对应球的体积，计算结果保留三位
// 小数。注：PI = 3.1415927。例如：输入 2 输出 33.510。(30 分)
// 要求：利用 while 循环结构完成多组数组的输入
public static void main(String[] args) {

    int r = 0;
    Scanner scanner = new Scanner(System.in);
    // 1.循环输入
    while (r != -1) {
        System.out.println("请输入球的半径:");
        r = Integer.parseInt(scanner.nextLine());

        // 2.计算球的体积,并输出
        if (r > 0) {
            double v = 4 * 3.1415927 * r * r * r / 3;
            System.out.println("半径为" + r + "球的体积为：" + String.format("%.3f", v));
        }
    }
}

}

package com.test;

import java.util.Scanner;

public class Test3 {
// 任务三：从键盘上输入一个整数 N，输出 1~N 之间能被 7 整除的整数的个数，以及这
// 些能被 7 整除的数的和。(30 分)
// 要求：利用循环结构完成计算
public static void main(String[] args) {

    // 1.接收用户输入
    Scanner scanner = new Scanner(System.in);
    System.out.println("请输入一个整数N:");
    int N = scanner.nextInt();

    int count = 0;// 统计能被7整除的整数的个数
    int sum = 0;// 这些整数的和

    for (int i = 1; i <= N; i++) {

        if (i % 7 == 0) {// 判断当前数字i能否被7整除
            count++;
            sum = sum + i;
        }
    }

    System.out.println("1-" + N + "之间能被7整除的整数的个数：" + count);
    System.out.println("1-" + N + "之间能被7整除的整数的和：" + sum);
}

}

6.试题编号：1-1-6：任务实现6

package com.test;
import java.util.Scanner;
public class Test1 {
// 任务一：从键盘上输入一个整数 N，输出 1~N 之间的素数。(30 分)
// 要求：用带有一个输入参数的函数(或方法)实现，返回值类型为布尔类型。
public static void main(String[] args) {

    // 1.接收用户输入
    Scanner scanner = new Scanner(System.in);
    System.out.println("请输入一个整数:");
    int N = scanner.nextInt();

    // 循环1-N
    for (int i = 2; i < N; i++) {
        // 判断i是否是素数
        if (isNum(i)) {
            System.out.println(i);
        }
    }
}
public static boolean isNum(int num) {
    // 循环判断是否存在
    for (int i = 2; i < num; i++) {
        // 如果找到一个数，能被num整除，那么num就不是素数
        if (num % i == 0) {
            return false;
        }
    }
    return true;
}

}

package com.test;
public class Test2 {
// 任务二：在屏幕打印出如下图 1.6.1 的倒三角图形。(30 分)
图 1.6.1 倒三角形
// i j=9-2i // 1 7
// * 2 5
// *** 3 3
// * 4 1
public static void main(String[] args) {

    for (int i = 1; i <= 4; i++) {
        for (int j = 1; j <= 9 - 2 * i; j++) {
            System.out.print("*");
        }
        System.out.println("");
    }
}

}

package com.test;
public class Test3 {
// 任务三：假设一张足够大的纸，纸张的厚度为 0.5 毫米。请问对折多少次以后，可以达
// 到珠穆朗玛峰的高度(最新数据：8844.43 米)。请编写程序输出对折次数。(30 分)
// 要求：使用循环结构语句实现。
public static void main(String[] args) {
// 1.统一单位
int weight = 5;
int total = 88444300;
int count = 0;// 对折的次数
// 2.循环判断
while (true) {

        weight = weight * 2;
        count++;
        if (total <= weight) {
            break;
        }
    }
    // 3.打印
    System.out.println("对折" + count + "次可以达到珠穆朗玛峰的高度");
}

}

7.试题编号：1-1-7：任务实现7

package com.test;
public class Test1 {
// 任务一：编写程序输出 2~99 之间的同构数。同构数是指这个数为该数平方的尾数，例
// 如 5 的平方为 25，6 的平方为 36，25 的平方为 625，则 5、6、25 都为同构数。(30 分)
// 要求：调用带有一个输入参数的函数(或方法)实现，此函数(或方法)用于判断某个整数
// 是否为同构数，输入参数为一个整型参数，返回值为布尔型（是否为同构数）。
public static void main(String[] args) {
// 1.循环2-99
for (int i = 2; i <= 99; i++) {
// 2.判断是不是同构数
boolean isOK = isNum(i);
if (isOK) {
System.out.println(“同构数：” + i + “\t\t平方为：” + i * i);
}
}
}
// 判断是不是同构数
public static boolean isNum(int num) {
if (num < 10) {// 2-9
if (num == num * num % 10) {// 是同构数
return true;
} else {
return false;
}
} else {// 10-99
if (num == num * num % 100) {// 是同构数
return true;
} else {
return false;
}
}
}

}

package com.test;
import java.util.Scanner;
public class Test2 {
// 任务二：从键盘输入一个整数 N，打印出有 N*2-1 行的菱形。例如输入整数 4，则屏幕
// 输出如图 1.7.1 的菱形。(30 分)图 1.7.1 输入 4，打印出的菱形
public static void main(String[] args) {

    // 1.接收用户输入
    Scanner scanner = new Scanner(System.in);
    System.out.println("请输入一个整数N");
    int N = scanner.nextInt();

    // 2.打印菱形
    for (int i = 1; i <= N; i++) {// 打印上半部分
        for (int j = 1; j <= N - i; j++) {// 打印空格
            System.out.print(" ");
        }
        for (int j = 1; j <= 2 * i - 1; j++) {// 打印*号
            System.out.print("*");
        }
        System.out.println("");
    }

    for (int i = 1; i < N; i++) {// 打印下半部分

        for (int j = 1; j <= i; j++) {// 打印空格
            System.out.print(" ");
        }
        for (int j = 1; j <= 2 * N - 1 - 2 * i; j++) {// 打印*号
            System.out.print("*");
        }
        System.out.println("");
    }
}

}

package com.test;
public class Test3 {
// 任务三：计算正整数 n 每个数位上的数之积，例如 24，它的每个数位上的数字之积为
// 2 * 4 = 8。(30 分)
// 要求：①编写一个计算函数(或方法)fun，将结果放到 c中，并显示结果。
// ②利用循环语句实现。
public static void main(String[] args) {

    int num = 345;
    System.out.println(num + "每个数位上的数字之积为：" + fun(num));
}

public static int fun(int n) {// 345

    int a = n;// 为数n
    int c = 1;// 定义乘积
    while (a != 0) {

        int b = a % 10;// 拿到数字a的最后一位
        c = c * b;

        a = a / 10;// a舍去最后一位
    }
    return c;
}

}

8.试题编号：1-1-8：任务实现8

package com.test;
public class Test1 {
// 任务一：所谓回文数是从左至右与从右至左读起来都是一样的数字，如：121 是一个回
// 文数,321 就不是回文数。求出 100—200 的范围内所有回文数的和。(30 分)
// 要求：使用循环结构语句实现。
public static void main(String[] args) {

    // 1.什么是回文数？
    // 2.循环遍历
    // 3.判断是不是回文数

    int sum = 0;// 存储100-200之间回文数的和
    for (int i = 100; i <= 200; i++) {
        if (isHW(i)) {
            System.out.println(i);
            sum = sum + i;
        }
    }
    System.out.println("100—200的范围内所有回文数的和:" + sum);
}

public static boolean isHW(int num) { // 123
    int a = num;
    int b = 0;// 从右往左 321
    while (a != 0) {
        int c = a % 10; // c 3 2 1
        b = b * 10 + c; // b 3 32 321
        a = a / 10; // a 12 1 0
    }
    if (num == b) { // 正序123 == 逆序 321
        return true;
    } else {
        return false;
    }
}

}

任务二：编写程序实现：
①定义一个抽象类 Shape，它有一个计算面积的抽象方法 calArea。
②定义一个三角形类 Triangle。它有两个属性 n、m，分别表示三角形的底和高。另外，
它必须继承于 Shape 类，并实现 calArea 方法来计算三角形的面积。
③定义一个矩形类 Rectangle。它有两个属性 n、m，分别表示矩形的长和宽。另外，
它 必须继承于 Shape 类，并实现 calArea 方法来计算矩形的面积。
④定义一个圆类 Circle。它有一个属性 n，表示圆形的半径。另外，它必须继承于 Shape类，
并实现 calArea 方法来计算圆形的面积。
⑤分别创建一个三角形对象、一个矩形对象、一个圆形对象，然后将它们存入到一个数组中，
最后将数组中各类图形的面积输出到屏幕上。(30分)

++++++Circle.java文件++++++
package com.util;
public class Circle extends Shape {

private int n;

public Circle() {
    super();
}

public Circle(int n) {
    super();
    this.n = n;
}

@Override
public double calArea() {
    return Math.PI * n * n;
}

}
++++++Rectangle.java文件++++++
package com.util;
public class Rectangle extends Shape {

private int n;
private int m;
public Rectangle() {
    super();
}

public Rectangle(int n, int m) {
    super();
    this.n = n;
    this.m = m;
}

@Override
public double calArea() {
    return n * m;
}

}

+++++++Shape.java文件+++++++
package com.util;

public abstract class Shape {

// 计算面积的抽象方法
public abstract double calArea();

}

+++++++Shape.java文件+++++++
package com.util;

public abstract class Shape {

// 计算面积的抽象方法
public abstract double calArea();

}
+++++++Test2.java文件+++++++
package com.util;

public class Test2 {

public static void main(String[] args) {

    Triangle triangle = new Triangle(3, 4);
    Rectangle rectangle = new Rectangle(4, 5);
    Circle circle = new Circle(5);

    Shape[] s = { triangle, rectangle, circle };

    for (Shape shape : s) {
        System.out.println(shape.calArea());
    }
}

}
+++++++Triangle.java文件+++++++
package com.util;

public class Triangle extends Shape {

private int n;
private int m;

public Triangle() {
    super();
}

public Triangle(int n, int m) {
    super();
    this.n = n;
    this.m = m;
}

@Override
public double calArea() {
    return n * m / 2.0;
}

}

package com.test;
import java.util.Scanner;

public class Test3 {
// 任务三：输入一个整数，输出满足对应条件的结果。(30 分)
// 能同时被 3、5、7 整除
// 能同时被 3、5 整除
// 能同时被 3、7 整除
// 能同时被 5、7 整除
// 只能被 3、5、7 中的一个整除
// 不能被 3、5、7 任一个整除
// 要求：使用分支结构语句实现。
public static void main(String[] args) {

    // 1.接收用户输入
    Scanner scanner = new Scanner(System.in);
    System.out.println("请输入一个整数：");
    int n = scanner.nextInt();

    // 2.判断
    // 2.1能同时被 3、5、7 整除
    if (n % 3 == 0 && n % 5 == 0 && n % 7 == 0) {
        System.out.println(n + "能同时被 3、5、7 整除");
    }
    // 2.2能同时被 3、5 整除
    if (n % 3 == 0 && n % 5 == 0) {
        System.out.println(n + "能同时被 3、5整除");
    }
    // 2.3能同时被 3、7 整除
    if (n % 3 == 0 && n % 7 == 0) {
        System.out.println(n + "能同时被 3、7整除");
    }
    // 2.4能同时被 5、7 整除
    if (n % 5 == 0 && n % 7 == 0) {
        System.out.println(n + "能同时被 5、7整除");
    }
    // 2.5只能被 3、5、7 中的一个整除
    if ((n % 3 == 0 && n % 5 != 0 && n % 7 != 0) || (n % 3 != 0 && n % 5 == 0 && n % 7 != 0)
            || (n % 3 != 0 && n % 5 != 0 && n % 7 == 0)) {
        System.out.println(n + "只能被 3、5、7 中的一个整除");
    }
    // 2.6不能被 3、5、7 任一个整除
    if (n % 3 != 0 && n % 5 != 0 && n % 7 != 0) {
        System.out.println(n + "不能被 3、5、7 任一个整除");
    }
}

}

9.试题编号：1-1-9：任务实现9

package com.test;
import java.util.Scanner;

public class Test1 {
// 任务一：有一种细胞，从诞生第二天开始就能每天分裂出一个新的细胞，新的细胞在第
// 二天又开始繁衍。假设在第一天，有一个这样的细胞，请问，在第 N 天晚上，细胞的数量
// 是多少？输入一个整数 N（0 < N < 20），编程求解第 N 天该细胞的数量。例如输入 5，输出
// 答案为 16。(30 分)
// 要求：使用循环或者递归完成。
public static void main(String[] args) {

    // 1.接收用户输入
    Scanner scanner = new Scanner(System.in);
    System.out.println("请输入天数：");
    int N = scanner.nextInt();

    int total = 1;
    // 2.循环
    for (int i = 2; i <= N; i++) {
        total = total * 2;
    }
    System.out.println("第" + N + "天细胞的数量：" + total);
}

}

package com.test;
public class Test2 {
// 任务二：某电视机厂每天生产电视 500 台，在质量评比中，每生产一台合格电视机记 5
// 分，每生产一台不合格电视机扣 18 分。如果四天得了 9931 分，编程计算这四天生产的合
// 格电视机的台数，并输出。(30 分)
// 要求：用循环语句实现。
public static void main(String[] args) {

    for (int i = 1; i <= 2000; i++) {// i表示合格电视机的台数

        // i*5表示：合格的积分；(2000-i)*18表示：不合格的积分
        if (i * 5 - (2000 - i) * 18 == 9931) {
            System.out.println("这四天生产的合格电视机的台数：" + i);
            break;
        }
    }
}

}

package com.test;

public class Test3 {
// 任务三：在一个停车场内，汽车、摩托车共停了 48 辆，其中每辆汽车有 4 个轮子，每
// 辆摩托车有 3 个轮子，这些车共有 172 个轮子，编程输出停车场内有汽 车和摩托车的数
// 量。(30 分)
// 要求：用循环结构和假设发实现。
public static void main(String[] args) {

    for (int i = 1; i <= 48; i++) {// i表示汽车的数量

        if (4 * i + 3 * (48 - i) == 172) {
            System.out.println("停车场内有汽车" + i + "辆，摩托车" + (48 - i) + "辆");
        }
    }
}

}

10.试题编号：1-1-10：任务实现10

package com.test;
public class Test1 {
// 任务一：编写一个应用程序，计算并输出一维数组（9.8，12，45，67，23，1.98，2.55，45）
// 中的最大值、最小值和平均值。(30 分)
// 要求：利用数组完成功能。
public static void main(String[] args) {
// 1.定义数组存放数据
double[] a = { 9.8, 12, 45, 67, 23, 1.98, 2.55, 45 };
// 2.定义变量存放最大最小值/平均值
double max = a[0];
double min = a[0];
double avg = 0;

    // 3.循环遍历
    for (int i = 0; i < a.length; i++) {

        if (a[i] > max) {
            max = a[i];
        }

        if (a[i] < min) {
            min = a[i];
        }

        avg = avg + a[i];
    }

    avg = avg / a.length;

    System.out.println("最大值：" + max);
    System.out.println("最小值：" + min);
    System.out.println("平均值：" + avg);
}

}

package com.test;
import java.util.Scanner;

public class Test2 {
// 任务二：输入一个年度，判断是否是闰年。例如，2000 是闰年，1900 不是闰年，1904
// 是闰年。
// 要求：使用分支结构语句实现。 提示：以下两个条件，只要满足任意一个，即是闰年：
// ①能整除 4 且不能整除 100 ；②能整除 400。(30 分)
public static void main(String[] args) {

    // 1.接收用户输入
    Scanner scanner = new Scanner(System.in);
    System.out.println("请输入一个年度：");
    int year = scanner.nextInt();

    // 2.判断是不是闰年
    if (year % 400 == 0 || (year % 4 == 0 && year % 100 != 0)) {
        System.out.println(year + "是闰年");
    } else {
        System.out.println(year + "不是闰年");
    }
}

}

package com.test;
public class Test3 {

// 任务三：有 N(N<100)个整数，已经按照从小到大的顺序排列好，现在另外给一个整数
// X，请将该数插入到序列中，并使新的序列依然有序。(30 分)
// 要求：将新序列在一行输出
public static void main(String[] args) {

    int a[] = { 1, 2, 3, 4, 6, 7, 8, 9, 10 };// 已经排序的数组
    int num = 5;// 要插入的数字
    int index = 0;// 插入的索引

    for (int i = 0; i < a.length; i++) {

        // 找到第一个大于num的数,当前i就是插入的位置
        if (a[i] >= num) {
            index = i;
            break;
        }
    }

    int b[] = new int[a.length + 1];

    // 循环执行数值插入到b数组
    for (int i = 0; i <= a.length; i++) {

        if (i < index) {// 前面不变
            b[i] = a[i];
        } else if (i == index) {// 中间插入num
            b[i] = num;
        } else {// 后面的数据,往后挪一位
            b[i] = a[i - 1];
        }
    }

    for (int i = 0; i <= a.length; i++) {
        System.out.println(b[i]);
    }
}

}