Java程序设计课后习题(答案版) 期末复习

第一章 Java语言概述

一、选择题

下面哪种类型的文件可以在Java虚拟机中运行?( A )

A. class

B. Java

C. jre

D. exe
如果JDK 的安装路径为“d:\jdk”，若想在命令窗口中任何当前路径下，都可以直接使用javac和java命令，需要将环境变量path设置为以下哪个选项?( B )

A. d: \jdk

B. d: \jdk\bin

C. d: \jre\bin

D. d:\jre
在JDK 目录中,Java 程序运行环境的根目录是( C )。

A. bin

B. demo

C. jre

D. lib
JDK 安装后，在安装路径下有若干子目录，其中包含Java 开发包中开发工具的是( A )目录。

A. \bin

B. \demo

C. \include

D. \jre
对于可以独立运行的Java 应用程序，下列( D )说法是正确的。

A.无须main方法

B.必须有两个main方法

C.可以有多个或零个main方法

D. 必须有一个main方法
Java源文件和编译后的文件扩展名分别是( B )。

A. class和java

B. java和class

C. class和class

D.java和java
作为Java应用程序入口的main()方法，其声明格式可以是( C )。

A. public static int main( String[ ] args)

B. public void main( String[ ] args)

C. public static void main( String[ ] args )

D. public int main( String[ ] args)
在Eclipse中，( A )视图显示输出的结果。

A.控制台

B.导航器

C.包资源管理器

D. 大纲
下面说法正确的是( D )。
A. Java程序的main( )方法写在类的外部
B.一个Java程序里可以有一到多个 main( )方法
C.如果Java程序中的main( )方法中只有一条语句，则不需要用{ }括起来
D. Java程序中，如果类名由public修饰，则类名必须与文件名保持一致
在控制台运行一个名为Test的Java程序，使用的正确命令是( B )。

A. java Test. Java

B. java Test

C. javac Test. Java

D. javac Test

二、填空题

建立Java开发环境，安装JDK, 一般需要设置环境变量 path 、 classpath 。
开发和运行Java程序需要经过的三个主要步骤为编辑、编译和运行。
编写一个Java 源程序，编译该源程序的命令为 javac ，运行该程序的命令为 java 。
Java应用程序中有一个main( )方法，它前面有三个修饰符是 public 、 static 、 void 。
缩写的JDK代表 Java开发工具，JRE 代表 Java运行环境。

第二章数据类型

一、选择题

下面哪一项在Java中是非法的标识符?( C )

A. $ user

B. point

C. You&me

D. _endline
下列不属于Java保留字的是( A ) 。

A. sizeof

B. super

C. abstract

D. break
下列整型数据类型中，需要内存空间最少的是( D ) 。

A. short

B. long

C. int

D. byte
哪个是将一个十六进制值赋值给一个long型变量? ( D )

A. long number = 345L;

B. long number = 0345;

C. long number = 0345L;

D. long number = 0x345L;
char类型的取值范围是( B )。

A.2-7~27

B.0~216-1

C.-215~215

D.0~28-1
在Java中，表示换页符的转义字符是( B )

A. \ n

B. \ f

C. ‘f’

D. \ dd
若定义有变量float a, b=6.5F，则下列说法正确的是( B )。

A.变量a, b均被初始化为6.5

B.变量a没有被初始化，b被初始化为6.5

C.变量a, b均未被初始化

D.变量b没有被初始化，a被初始化为6.5
下列关于boolean类型的叙述中，正确的是( D )

A.可以将boolean类型的数值转换为int 类型的数值

B.可以将boolean类型的数值转换为字符串

C.可以将boolean类型的数值转换为char类型的数值

D.不能将boolean类型的数值转换为其他基本数据类型
下列选项中属于字符串常量的是( B )。

A. ‘abc’

B. “abc”

C. abc

D. (abc)
创建了Scanner对象scan, 以下能正确获取输人数据的是( C )。

A. int s= scan. nextFloat( ) ;

B. float s= scan. nextDouble( ) ;

C. float s= scan. nextInt( ) ;

D. String s=scan. nextInt( );
以下( A )是合法的变量名。

A. de2 $_

B. df-5

C. long

D.3x
以下能够实现正确输出的是( C )。

A. System. out. println( Hello world!);

B. System. Out. println(“Hello world!");

C. System. out. println(“Hello world!");

D. system. out. println( “Hello world!");

二、填空题

Java中的分隔符有注释符、空白符和普通分隔符三种。
布尔型常量只有两个值: true 和 false ，表示“真”和“假”。
单行注释以 // 开始，表示注释一行。多行注释以 / 开始，到 / 结束，中间可写一到多行。
Java中的数据类型分为两种，分别是基本数据类型和引用数据类型。
在Java中，byte类型数据占 1 字节，short 类型数据占 2 字节，int类型数据

4 字节，long 类型数据占 8 字节。

要输出" \ “，输出语句为 System. out. println(“\”); 。

三、操作题

输出会员管理菜单。菜单项有: 1. 显示会员信息; 2. 添加会员信息; 3. 修改会员信息; 4. 查询会员信息。

public class P41_1 {  
  
    public static void main(String[] args) {  
        Menu();  
    }  
  
    public static void Menu() {  
        System.out.println("会员管理菜单：");  
        System.out.println("1. 显示会员信息");  
        System.out.println("2. 添加会员信息");  
        System.out.println("3. 修改会员信息");  
        System.out.println("4. 查询会员信息");  
        System.out.print("请选择操作（输入数字1-4）：");  
    }  
}

编写一个Java程序，要求从键盘输入个人信息，并显示出来。个人信息包括：姓名、年龄、性别、身高、体重、住址、电话。

import java.util.Scanner;  
  
public class P41_2 {  
  
    public static void main(String[] args) {  
        Scanner scanner = new Scanner(System.in);  
  
        System.out.print("请输入您的姓名：");  
        String name = scanner.nextLine();  
  
        System.out.print("请输入您的年龄：");  
        int age = scanner.nextInt();  
        scanner.nextLine(); // 消耗掉输入年龄后的换行符  
  
        System.out.print("请输入您的性别（男/女）：");  
        String gender = scanner.nextLine();  
  
        System.out.print("请输入您的身高（厘米）：");  
        double height = scanner.nextDouble();  
        scanner.nextLine(); // 消耗掉输入身高后的换行符  
  
        System.out.print("请输入您的体重（千克）：");  
        double weight = scanner.nextDouble();  
        scanner.nextLine(); // 消耗掉输入体重后的换行符  
  
        System.out.print("请输入您的住址：");  
        String address = scanner.nextLine();  
  
        System.out.print("请输入您的电话：");  
        String phone = scanner.nextLine();  
  
        System.out.println("您输入的信息如下：");  
        System.out.println("姓名：" + name + "  年龄：" + age + "  性别：" + gender + "  身高：" + height + "厘米" + "   体重：" + weight + "千克" + "  住址：" + address + "   电话：" + phone);  
    }  
}

第三章运算符

一、选择

若有定义int a=1, b=2；那么表达式(a++)+(++b)的值是( B )。

A.3

B.4

C.5

D.6
假定有变量定义: int k=7, x=12；那么能使值为3的表达式是( D )。

A. x%=(k%=5)

B. x%=(k-k%5)

C. x%=k-k%5

D. (x%=k)-(k%=5)
设x=1，y=2，z= 3,则表达式y+=z–/++x的值是( A )。

A. 3

B. 3.5

C. 4

D. 5
下列哪个赋值语句是正确的? ( D )

A. char a= ‘12’;

B. int a= 12.0;

C. int a=12. 0f;

D. int a=(int)12.0;
下列选项中，Java 语句错误的是( A )。

A. float a=3. 0;

B. double a=3.5;

C. char a= 20;

D. byte= 15;
下列代码的执行结果是( D )。

Public class Test{ 
   Public static void main (String args[ ]){
       System. out. println(5/2);
   }
}

A.2.5

B.2.0

C.2.50

D.2

执行下列程序段后，b，x，y的值正确的是( A )。
```
int x=6,y=8;
boolean b;
b=x<y ||++x==--y;
```
A. true，6，8;

B. false，7，7

C. true，7, 7

D. false，6，8
下面表达式的值分别是( C )

(1)8/3 (2)8%3 (3)8.0/3

A. 2.666667 2 2.666667

B. 2 2 2

C. 2 2 2.666667

D. 2.6666672 2 2
定义整型变量int n=456，表达式的值为5的是( B )。

A. n/10/10

B. (n-n/100 * 100)/10

C. n%10

D. n/10
下列语句中，( D )正确完成了整型变量的声明和赋值。

A.int a, a=0

B. a=0;

C. int a=5. 6

D. int a1=0, a2=1
以下为boolean类型变量赋值的正确方式是( B )

A. boolean a=”true”

B. boolean a=(9>10)

C. boolean a=1

D. boolean a="真”
分析下面代码，正确的选项是( A )
```
double a=9;
a++;
int b=a/2;
```
A. 编译错误

B. 4.5

C. 4

D. 5

二、填空题

设x=2，则表达式(x++)/3的值是 0 。
如果要得到表达式20/3的浮点结果，表达式应改为 20.0/3.0 。
Java中的显式类型转换是强制类型转换，隐式类型转换是低类型转换向高类型。
设a为double 类型变量，b为char类型变量，c为long类型变量，则表达式b+a/c的值为 double 类型。
设int x=16, y=5,则x/y的值为 3 ，x%y的值为 1 。
表达式(10+2*6)/4%3的值是 2 。

三、操作题

将给定小写字母转换成大写字母。

public class P53_1 {  
    public static void main(String[] args) {  
        String str = "hello, world!";  
        String changStr = chang(str);  
        System.out.println(changStr); // 输出: HELLO, WORLD!  
    }  
  
    public static String chang(String input) {  
        char[] chars = input.toCharArray();  
        for (int i = 0; i < chars.length; i++) {  
            char c = chars[i];  
            // 如果字符是小写字母（ASCII码在97-122之间）  
            if (c >= 'a' && c <= 'z') {  
                // 转换为大写字母（ASCII码减去32）  
                chars[i] = (char) (c - ('a' - 'A'));  
            }  
        }        return new String(chars);  
    }  
}

将给定的华氏温度转换成摄氏温度。转换公式为：摄氏度=5*(华氏度-32)/9。

public class P53_2 {  
    public static void main(String[] args) {  
        double fahrenheit = 98.6; // 给定的华氏温度  
        double celsius = fahrenheitToCelsius(fahrenheit); // 转换为摄氏温度  
  
        // 打印结果  
        System.out.println(fahrenheit + "°F 对应的摄氏温度是 " + celsius + "°C");  
    }  
  
    // 转换函数：将华氏温度转换为摄氏温度  
    public static double fahrenheitToCelsius(double fahrenheit) {  
        return 5 * (fahrenheit - 32) / 9;  
    }  
}

任意给定一个三位数，请输出该数的个位、十位和百位数。

public class P53_3 {  
    public static void main(String[] args) {  
        int number = 123;  
        int hundreds = number / 100;  
        int tens = (number % 100) / 10;  
        int ones = number % 10;  
        System.out.println("百位数: " + hundreds);  
        System.out.println("十位数: " + tens);  
        System.out.println("个位数: " + ones);  
    }  
}

第四章控制语句

一、选择题

Java中关于if选择结构描述错误的是( C )。

A. if选择结构是根据条件判断之后再做处理的一种语法结构

B.关键字if后小括号里必须是一个条件表达式，表达式的值必须为布尔类型

C. if后小括号里表达式的值为false时，程序需要执行大括号里的语句

D. if语句可以和else 一起使用

下面哪些Java语句会导致无限循环? ( B )

(1)while (true) i = 0;

(2)while (false) i = 1;

(3)while (! false) i = 0;

A.仅仅(3)

B. (1)和(3)

C.仅仅(1)

D.(1)、(2)和(3)

下列关于多重if选择结构的说法正确的是( B )。

A.多个else if块之间的顺序可以改变，改变之后对程序的执行结果没有影响

B.多个else if块之间的顺序可以改变，改变之后可能对程序的执行结果有影响

C.多个else if块之间的顺序不可以改变，改变后程序编译不通过

D.多个else if块之间的顺序不可以改变，改变后程序编译可以通过

下列语句序列执行后，k的值是( D)。

int x=3,y=5,k=0;
switch(x%y+3) {
 case 0 : k=x*y; break;
 case 6 : k=x/y; break;
 case 12 : k=x-y; break;
 default : k=x*y-x; break;
}

A.12

B.-2

C.15

D.0

下列语句序列执行后，i的值是( A )
```
int i=0;

do {i+=3;}

while(i<10);
```
A.12

B.9

C.6

D.3
一个循环一般应包括哪几部分内容(A)?

A.以下答案都包括

B.循环体部分

C.初始化部分

D.迭代部分和终止部分
若a的值为3，下列程序段被执行后，c的值是©。
```
int c=1;
if (a>0)
 if(a>3)
  c=2;
 else c=3;
else c=4;
```
A.1

B.2

C.3

D.4

以下程序段的输出结果为©

int j=2;
switch(j){
 case 2 : System. out. print ("two. ");
 case 2+1 : System. out. println ("three. "); break;
default : System. out. println ("value is "+j); break; }

A. two.

B. three.

C. two. three.

D. value is 2

和语句“for(int x=0; x<15; x+= 2) sum+=x+5;”作用一样的语句是(A )。

A. for (int x=5; x=20; x+=2) sum+=x;

B. for (int x=5; x<20; x+=x-2) x+=2;

C. for (int x=0; x<15; x+=2) sum+=x+3; x+=2;

D. 上述全对

阅读以下代码，当m为多少时，“THREE"会出现在输出的结果中( C)。

switch (m) {
    case 0:
        System. out. println ("ONE");
    case 1 :
        System. out. println ("TWO");
    case 2 :
        System. out. println ("THREE") ;
    case 3:
        System. out. println("FOUR") ;
        break;
    default:
        System. out. println ("OTHER") ;
}

A.仅2

B.只有0和1

C.0、1、2

D.0、1、2、3

阅读以下代码，选择正确的输出结果( C )。

public class TestDemo1 {
 public static void main (String[ ] args) {
     int m = 3, n = 6，k = 0;
     while ((m++) <= (--n))
     ++k;
     System. out. println(k);
 }
}

A.0

B.1

C.2

D.3

下面程序输出的结果是( A )。

public class TestDemo2 {
    public static void main(String[ ] args) {
        int a, b;
        for (a=1, b=1; a<=100; a++) {
            if (b>= 10)
                break;
            if(b%3==1) {
                b+=3;
                continue;
            }
        }
        System. out. println(a);
    }
}

A.4

B.5

C.6

D.101

二、填空题

case子句中的常量的类型必须与switch表达式的类型相容，并且各个case子句的常量的值不能相同。
顺序结构是按照程序语句行的自然顺序依次执行。
循环结构，即算法中有一组操作要求反复被执行。
在一个for循环的循环体中包含另一个for 循环，实现for循环的嵌套。
do-while循环首先执行再判断，而while循环首先判断再执行。
通过使用一个“标签化中断”的语句，break语句就可以退出多重嵌套循环。
下面程序是计算5的阶乘，请在横线处填空，使程序功能完整

public class Factorial {
public static void main(String[ ] args) {
int n=10;
long result=1;
do { return *=n;
n–;
} while(n>=1);
System. out. println("5的阶乘为: "+result) ;
}
}

if语句合法的条件值是 boolean 类型。

三、操作题

任意输入三个整数，请按大小顺序输出它们。

import java.util.Arrays;  
import java.util.Scanner;  
  
public class P94_1 {  
    public static void main(String[] args) {  
        Scanner scanner = new Scanner(System.in);  
  
        // 接收三个整数输入  
        System.out.print("请输入第一个整数: ");  
        int a = scanner.nextInt();  
        System.out.print("请输入第二个整数: ");  
        int b = scanner.nextInt();  
        System.out.print("请输入第三个整数: ");  
        int c = scanner.nextInt();  
  
        // 使用数组存储这三个数  
        int[] numbers = {a, b, c};  
  
        // 使用Arrays.sort()方法进行排序  
        Arrays.sort(numbers);  
  
        // 输出排序后的整数  
        System.out.println("排序后的整数为: " + numbers[0] + ", " + numbers[1] + ", " + numbers[2]);  
  
        scanner.close();  
    }  
}

编程实现加、减、乘、除简单计算器。

import java.util.Scanner;  
  
public class P94_2 {  
    public static void main(String[] args) {  
        Scanner scanner = new Scanner(System.in);  
  
        System.out.print("请输入一个算术表达式 (例如: 1 + 2 或 3 * 4): ");  
        String expression = scanner.nextLine();  
  
        // 使用一个或多个空白字符来分割字符串  
        String[] parts = expression.split("\\s+");  
  
        if (parts.length < 3) {  
            System.out.println("无效的表达式，请确保输入格式正确！！");  
            return;  
        }  
  
  
        try {  
            double num1 = Double.parseDouble(parts[0]);  
            char operator = parts[1].charAt(0); // 假设操作符只有一个字符  
            double num2 = Double.parseDouble(parts[2]);  
  
            double result = 0;  
  
            switch (operator) {  
                    //JDK新特性使用方法！！
                case '+'-> result = num1 + num2;  
                case '-'-> result = num1 - num2;  
                case '*'-> result = num1 * num2;  
                case '/'-> {if (num2 != 0) {result = num1 / num2;} else {System.out.println("除数不能为0");return;}}  
                default-> {System.out.println("无效的操作符");return;}  
            }            System.out.println("结果是: " + result);  
        } catch (NumberFormatException e) {  
            System.out.println("输入中包含非数字字符");  
        }  
    }
}

《孙子算经》中记载了这样一道题目，今有鸡、兔同笼，上有三十五个头，下有九十足，问鸡、兔各几只?试编写程序解决这个问题。

public class P94_3 {  
    public static void main(String[] args) {  
        // 定义总头数和总足数  
        int totalHeads = 35;  
        int totalFeet = 94; // 注意题目中的九十足可能是个错误，因为35只动物如果是鸡兔混合，足数应该是偶数  
  
        // 计算兔子数量  
        // 因为每只兔子有4只足，每只鸡有2只足  
        // 所以兔子数量 = (总足数 - 2 * 总头数) / (4 - 2)  
        int rabbitCount = (totalFeet - 2 * totalHeads) / 2;  
  
        // 计算鸡的数量  
        // 因为总头数 = 鸡的数量 + 兔子的数量  
        // 所以鸡的数量 = 总头数 - 兔子的数量  
        int chickenCount = totalHeads - rabbitCount;  
  
        // 输出结果  
        System.out.println("鸡的数量为：" + chickenCount + "只");  
        System.out.println("兔子的数量为：" + rabbitCount + "只");  
    }  
}

求3~ 100中的所有的素数。

public class P94_4 {  
    public static void main(String[] args) {  
        // 循环遍历3到100之间的所有整数  
        for (int num = 3; num <= 100; num++) {  
            // 定义一个布尔变量isPrime，初始值为true  
            boolean isPrime = true;  
            // 循环遍历2到sqrt(num)之间的所有整数  
            for (int i = 2; i <= Math.sqrt(num); i++) {  
                // 如果num能被i整除，则将isPrime置为false并跳出循环  
                if (num % i == 0) {  
                    isPrime = false;
                    break;  
                }  
            }            // 如果isPrime为true，则输出num  
            if (isPrime) {  
                System.out.print(num + " ");  
            }  
        }    
    }
}

第五章数组

一、选择题

下面程序输出的结果是( C )。

public class Test {
    public static void main(String[ ] args) {
        int[ ]a = new int[11];
        int[ ]p= new int[4];
        int k=5;
        for (int i =1; i <= 10; i++)
        a[i] = i;
        for(int i=1; i<=3; i++)
        p[i] = a[ i* i];
        for(int i=1; i<=3; i++)
        k = k+ p[i]* 2;
        System. out. println(k) ;
    }
}

A.37

B.31

C.33

D.35

给出下列的程序，其叙述正确的是( A )。

public class Test {
    public static void main (String[ ] args) {
        int [ ] a = new int[10];
        System. out. println(a[1]) ;
    }
}

A.输出0

B.输出null

C.编译时将发生错误

D.编译正确但是运行时出错

已知int[ ] a=new int[ 10]；在下列给出的数组元素中非法的是( D )。

A. a[0]

B. a[1]

C. a[9]

D. a[10]
设有定义语句int k[ ]=new int[3]，则下列对此语句的叙述中错误的是( C )。

A.定义了一个名为k的一维数组

B. k数组有3个元素

C. k数据元素的下标为1~3

D.数组k中的每一个元素都是整型
若有定义byte[ ] x={1, 2, 3, 4}，k>=0且k<=3,则数组元素错误引用的是( B )。

A. x[5-3]

B. x[k+5]

C. x[k]

D. x[0]

下面程序输出的结果是( C )。

public class Test1{
    public static void main (String[ ] args){
        int m[ ][ ]= { {1,4,7}, {2,5,8}, {3,6,9} };
        int i,j,k=2;
        for(i=0; i<3; i++)
        System. out. print (m[i][i]);
    }
}

A.456

B. 258

C.159

D.789

为使下列代码正常运行，应该在下划线处填入的选项是( B )。
```
int[ ] num=new int[5];
for(int i=0;i<num.    ; i++) {
 num[i]=i;
}
```
A. size

B. length

C. dlmension

D. measurement
定义一个数组String[ ] cities=“北京"，“上海"，“天津”，“重庆”，“武汉"，“广州”，数组元素cities[5]的值是( C )。

A.北京

B.武汉

C.广州

D. 数字越界
下列数组的初始化正确的是( A )。

A. int[ ] score=new int[ ] {1, 2, 3, 4, 5};

B.int score={1, 2, 3, 4, 5, 6};

C. int score[ ]=new int[5] {1, 2, 3, 4, 5};

D. int score=new int[ ] {1, 2, 3, 4, 5};

下面代码的运行结果是©

public class Test{
    public static void main(String[ ] args){
        int[ ] a ={10,20,30};
        int[ ]b ={1,2,3,4,5};
        a=b;
        for (int i=0;i<a. length; i++){
            System. out. print(a[i]+” ");
        }
     }
}

A.程序报错

B.10 20 30

C.1 2 3 4 5

D.1 2 3

二、填空题

数组元素具有相同的数据类型，下标标明了元素在数组中的位置，从 0 开始。
写出定义一个整型数组a，且含有100个元素的语句: int [ ]a=new int[100]; 。
定义一个二维数组并初始化语句为:

int[ ][ ] a={ {1,2,3,4}, {5,6,7,8}, {9,10,11,12}, {13,14,15,16} };

那么，数组的元素a[3][2]的值是 15 。

Arras 类提供了排序的方法 sort() ，能对数组进行升序排序。
二维数组每行中列元素的个数可以不相同。

三、操作题

输入10个会员的积分，并采用冒泡排序法进行排序。

import java.util.Scanner;  
  
public class p108_1 {  
  
    public static void main(String[] args) {  
        Scanner scanner = new Scanner(System.in);  
  
        // 读取一行输入，包含10个会员的积分，用空格分隔    
System.out.print("请输入10个会员的积分（用空格分隔）: ");  
        String input = scanner.nextLine();  
        String[] parts = input.trim().split("\\s+"); // 使用正则表达式分割字符串，允许一个或多个空格    
        // 检查输入是否包含10个积分    
if (parts.length != 10) {  
            System.out.println("输入错误！请输入10个会员的积分。");  
            return;  
        }  
  
        // 将字符串数组转换为整数数组    
int[] scores = new int[10];  
        for (int i = 0; i < parts.length; i++) {  
            scores[i] = Integer.parseInt(parts[i]);  
        }  
  
        // 使用冒泡排序法对会员的积分进行排序    
bubbleSort(scores);  
  
        // 打印排序后的会员积分    
System.out.println("排序后的会员积分：");  
        for (int score : scores) {  
            System.out.print(score + " ");  
        }  
  
        scanner.close();  
    }  
  
    // 冒泡排序法    
public static void bubbleSort(int[] array) {  
        int n = array.length;  
        for (int i = 0; i < n - 1; i++) {  
            for (int j = 0; j < n - i - 1; j++) {  
                if (array[j] > array[j + 1]) {  
                    // 交换array[j]和array[j + 1]    
int temp = array[j];  
                    array[j] = array[j + 1];  
                    array[j + 1] = temp;  
                }  
            }        
        }    
	}
}

删除一维数组中重复的数据。

import java.util.ArrayList;  
import java.util.Arrays;  
  
public class P108_2 {  
  
    public static int[] removeDuplicates(int[] array) {  
        if (array == null || array.length == 0) {  
            return array; // 或者返回一个新空数组    
}  
  
        // 使用ArrayList来存储不重复的元素    
ArrayList<Integer> list = new ArrayList<>();  
        for (int num : array) {  
            if (!list.contains(num)) {  
                list.add(num);  
            }  
        }  
        // 将ArrayList转换为数组    
int[] result = new int[list.size()];  
        for (int i = 0; i < list.size(); i++) {  
            result[i] = list.get(i);  
        }  
  
        return result;  
    }  
  
    public static void main(String[] args) {  
        int[] nums = {1, 2, 3, 2, 4, 4, 5, 5, 5, 6};  
        int[] uniqueNums = removeDuplicates(nums);  
  
        // 打印结果    
System.out.println(Arrays.toString(uniqueNums));  
    }  
}

编写程序实现两个矩阵相加。

public class P108_3 {  
  
    // 矩阵相加的方法  
    public static int[][] addMatrices(int[][] matrix1, int[][] matrix2) {  
        // 确保两个矩阵的行数和列数相同  
        if (matrix1.length != matrix2.length || matrix1[0].length != matrix2[0].length) {  
            throw new IllegalArgumentException("矩阵必须具有相同的维度");  
        }  
  
        // 获取矩阵的行数和列数  
        int rows = matrix1.length;  
        int cols = matrix1[0].length;  
  
        // 创建结果矩阵  
        int[][] result = new int[rows][cols];  
  
        // 遍历矩阵的每个元素，并将它们相加  
        for (int i = 0; i < rows; i++) {  
            for (int j = 0; j < cols; j++) {  
                result[i][j] = matrix1[i][j] + matrix2[i][j];  
            }  
        }  
        // 返回结果矩阵  
        return result;  
    }  
  
    // 主方法，用于测试矩阵相加功能  
    public static void main(String[] args) {  
        // 创建两个3x3的矩阵  
        int[][] matrix1 = {  
                {1, 2, 3},  
                {4, 5, 6},  
                {7, 8, 9}  
        };  
  
        int[][] matrix2 = {  
                {9, 8, 7},  
                {6, 5, 4},  
                {3, 2, 1}  
        };  
  
        // 调用矩阵相加方法  
        int[][] result = addMatrices(matrix1, matrix2);  
  
        // 打印结果矩阵  
        for (int[] row : result) {  
            for (int num : row) {  
                System.out.print(num + " ");  
            }  
            System.out.println();  
        }  
    }}

第六章面向对象

一、选择题

设A为已定义的类名，以下创建A的对象a的正确语句是( B )。

A. int A a;

B. A a=new A( );

C. A a=new int( )

D. public A a=A( );
用来导入类或包的语句是( C )。

A. main

B. package

C. import

D. include
下面关于类和对象的说法中错误的是( D )。

A.类是对象的类型，它封闭了数据和操作

B.类是对象的集合，对象是类的实例

C.一个对象必属于某个类

D.一个类的对象只有一个
方法内定义的变量( A ) 。

A. 一定在方法内所有位置可见

B.可能在方法的局部位置可见

C.在方法外可以使用

D.在方法外可见
方法的形参( A ) 。

A.可以没有

B.至少有一个

C.必须定义多个形参

D.只能是简单变量
下列不属于面向对象程序设计的基本特征的是( D )。

A.多态

B.封装

C.继承

D.静态
构造方法在( D )时被调用。

A.类定义时

B.创建对象时

C.使用对象的变量时

D.调用对象方法时
下列方法的声明中不合法的是( C )。

A. float area( ){…}

B. void area( ){…}

C. double area{…}

D. int area(int r) {…}
有一个手机类Phone,现在要创建Phone类的对象，设置属性品牌(brand)的值，以下正确的代码是(B )。

A. Phone p=new Phone ;

p brand="苹果”;

B. Phone p= new Phone( );

p. brand=”华为”;

C. Phone p;

p. brand=”三星”;

D. Phone p= new Phone( );

brank="小米”;

设有double型变量x，int 型变量y，有方法myMethod的定义如下:

returnType myMethod{
return x/y* 3+1;

}

则返回值returnType的类型为(A )。

A. double

B. int

C. void

D. float

在Java语言中，下列关于类的继承的描述，正确的是( B )。

A.一个类可以继承多个父类

B.一个类可以具有多个子类

C.子类可以使用父类的所有方法

D.子类一定比父类有更多的成员方法
下列选项中，关于Java中super关键字的说法错误的是( B )。

A. super关键字是在子类对象内部指代其父类对象的引用

B. super关键字不仅可以指代子类的直接父类，还可以指代父类的父类

C.子类可以通过super关键字调用父类的方法

D.子类可以通过super关键字调用父类的属性
下面关于Java接口的说法错误的是( C )。

A.一个Java接口是一些方法特征的集合，但没有方法的实现

B. Java接口中定义的方法在不同的地方被实现，可以具有完全不同的行为

C. Java接口中可以声明私有成员

D. Java接口不能被实例化
在Java中，实现多态的步骤包括以下几个方面除了( B )。

A.子类重写父类的方法

B.子类方法设置为final类型

C.定义方法时，把父类类型作为参数类型；调用方法时，把父类或子类的对象作为参数传入方法

D. 运行时，根据实际创建的对象类型动态决定使用哪个方法
Java中，如果类C是类B的子类，类B是类A的子类，那么下面的描述正确的是( A )。

A. C不仅继承了B中的公有成员，同样也继承了A中的公有成员

B. C只继承了B中的成员

C.C只继承了A中的成员

D.C不能继承A或B中的成员

二、填空题

面向对象程序设计中，类是描述具有相同的属性和操作的一组对象。
return 语句从当前方法中退出，返回到调用该方法的语句处，并从紧跟该调用语

句的下一条继续执行。

如果一个方法不返回任何值，则该方法的返回值类型为 void 。
一般Java程序的类主体由两部份组成：一部分是属性，另一部分是方法。
JavaDoc注释的写法是 /**…*/ 。
在Java语言中，用 abstract 修饰符定义的类为抽象类。
面向对象的三大特征是封装、继承和多态。
如果想声明一个类继承另一个类，需要在类的声明中使用 extends 关键字，并指定要继承的类的名称。

三、操作题

编写一个商品类，并显示商品的信息，其中设定如下。

商品类

属性:商品类型、商品名称、价格、数量

方法:显示商品信息

public class P173_1_Product {  
    private String Type;  
    private String Name;  
    private double price;  
    private int quantity;  
  
    public P173_1_Product() {  
    }    public P173_1_Product(String type, String name, double price, int quantity) {  
        Type = type;  
        Name = name;  
        this.price = price;  
        this.quantity = quantity;  
    }  
    public String getType() {  
        return Type;  
    }  
  
    public void setType(String type) {  
        Type = type;  
    }  
  
    public String getName() {  
        return Name;  
    }  
  
    public void setName(String name) {  
        Name = name;  
    }  
  
    public double getPrice() {  
        return price;  
    }  
  
    public void setPrice(double price) {  
        this.price = price;  
    }  
  
    public int getQuantity() {  
        return quantity;  
    }  
  
    public void setQuantity(int quantity) {  
        this.quantity = quantity;  
    }  
  
  
    //显示商品信息  
    public void showProductInformation(){  
        System.out.println("商品类型："+Type);  
        System.out.println("商品名称："+Name);  
        System.out.println("商品价格："+price);  
        System.out.println("商品数量："+quantity);  
    }  
  
    public static void main(String[] args) {  
        P173_1_Product apple = new P173_1_Product("水果", "红富士苹果", 10.99, 10);  
        apple.showProductInformation();  
    }  
}

使用面向对象的思想编写一个计算机类( Calculator)，可以实现两个整数的加、减、乘、除运算。

public class P173_2_Calculator {  
  
    // 加法运算  
    public int add(int num1, int num2) {  
        return num1 + num2;  
    }  
  
    // 减法运算  
    public int subtract(int num1, int num2) {  
        return num1 - num2;  
    }  
  
    // 乘法运算  
    public int multiply(int num1, int num2) {  
        return num1 * num2;  
    }  
  
    // 除法运算，注意这里处理除以0的情况  
    public double divide(int num1, int num2) {  
        if (num2 == 0) {  
            throw new ArithmeticException("除数不能为0");  
        }  
        return (double) num1 / num2;  
    }  
  
    // 主方法，用于测试Calculator类  
    public static void main(String[] args) {  
        P173_2_Calculator calculator = new P173_2_Calculator();  
  
        // 加法测试  
        int sum = calculator.add(5, 3);  
        System.out.println("5 + 3 = " + sum);  
  
        // 减法测试  
        int difference = calculator.subtract(5, 3);  
        System.out.println("5 - 3 = " + difference);  
  
        // 乘法测试  
        int product = calculator.multiply(5, 3);  
        System.out.println("5 * 3 = " + product);  
  
        // 除法测试  
        double quotient = calculator.divide(10, 2);  
        System.out.println("10 / 2 = " + quotient);  
  
        // 尝试除以0，会抛出异常  
        // 注意：实际使用中应该使用try-catch块来处理可能出现的异常  
        // double divideByZero = calculator.divide(10, 0);  
    }  
}

定义一个形状抽象类，包含求周长和面积的方法。再定义圆类和正方形类继承形状类，实现求周长和面积的方法。

// 抽象类 Shapeabstract class Shape {  
    // 抽象方法：计算周长  
    public abstract double calculatePerimeter();  
  
    // 抽象方法：计算面积  
    public abstract double calculateArea();  
}  
  
// Round 类继承 Shape 类  
class Round extends Shape {  
    private double radius;  
  
    public Round(double radius) {  
        this.radius = radius;  
    }  
  
    // 实现 Shape 中的 calculatePerimeter 方法  
    @Override  
    public double calculatePerimeter() {  
        return 2 * Math.PI * radius;  
    }  
  
    // 实现 Shape 中的 calculateArea 方法  
    @Override  
    public double calculateArea() {  
        return Math.PI * Math.pow(radius, 2);  
    }  
}  
  
// Square 类继承 Shape 类  
class Square extends Shape {  
    private double side;  
  
    public Square(double side) {  
        this.side = side;  
    }  
  
    // 实现 Shape 中的 calculatePerimeter 方法  
    @Override  
    public double calculatePerimeter() {  
        return 4 * side;  
    }  
  
    // 实现 Shape 中的 calculateArea 方法  
    @Override  
    public double calculateArea() {  
        return side * side;  
    }  
}  
  
// 测试类  
public class P173_3 {  
    public static void main(String[] args) {  
        // 创建一个圆  
        Round circle = new Round(5);  
        System.out.println("圆的周长: " + circle.calculatePerimeter());  
        System.out.println("圆的面积: " + circle.calculateArea());  
  
        // 创建一个正方形  
        Square square = new Square(4);  
        System.out.println("正方形的周长: " + square.calculatePerimeter());  
        System.out.println("正方形的面积: " + square.calculateArea());  
    }  
}

第七章 Java异常处理

一、选择题

( B )类是所有异常类的父类。

A. Throwable

B. Exception

C. Error

D. AWTError
抛出异常应该使用的关键字是( C )。

A. try

B. catch

C. throw

D. throws
finally语句中的代码( A ) 。

A.总是被执行

B.当try语句块后面没有catch 时，finally中的代码才会执行

C.异常发生时才执行

D.异常没有发生时才被执行
对于try{…} catch子句的排列方式，下列正确的一项是(B )。

A.父类异常在前，子类异常在后

B.子类异常在前，父类异常在后

C.只能有子类异常

D.父类异常与子类异常不能同时出现
自定义异常类时，可以继承的类是( D )。

A. Error

B. Applet

C. AssertionError

D. Exception及其子类
在异常处理中，将可能抛出异常的方法放在( C )语句块中。

A. throws

B. catch

C. try

D. finally
使用catch( Exception e)的好处是( B )。

A.只会捕获个别类型的异常

B.捕获try语句块中产生的所有类型的异常

C.忽略一些异常

D.执行一些程序
当方法遇到异常又不知如何处理时，下列哪种说法是正确的( B )。

A.捕获异常

B.抛出异常

C.嵌套异常

D.声明异常

二、填空题

Java程序错误包括 Error 和 Exception 两种。
Throwable 类是Java语言中所有错误(Error)或异常(Exception)的超类。
声明异常使用 throws 关键字，抛出异常使用 throw 关键字。
无论是否发生异常， finally 代码块中的代码总会被执行。
如果要自定义一个检查性异常类，需要继承 Exception 类。

第八章 Java常用实用类

一、选择题

下面程序的输出结果可能是( A )。

public class Test1 {
    public static void main (String[ ] args) {
        int x, y;
        x = (int) Math. sqrt(5)/2 + (int) (Math. random()* 5)/2;
        y = (int) Math. sqrt(3)/2 + (int) (Math. random()* 3)/2;
        System. out. println(x+" "+y);
        if (x> y)
        System. out. println("x>y");
        else if (х == y)
        System. out. println("x=y") ;
        else
        System. out. println("x<y") ;
    }
}

A. x>y或x=y

B. x=y或x<y

C. 只能是x>y

D.三种情况都可能

下面程序输出的结果是( D )

public class Test2{
    public static void main(String[ ] args){
        double x = 2.2, y;
        y=Math. round (Math. pow(x, 2));
        System. out. println(y);
    }
}

A.4

B.4.0

C.5

D.5.0

下列程序正确的输出结果是( A )。

public class Test{
    public static void main(String[ ] args){
        String s1="abcd";
        String s2="abcd";
        String s3=new String (s1);
        if(s1==s2) {
        System. out. println("s1==s2");}
        if(s2==s3){
        System. out. println("s2==s3");}
        if(s1==s3) {
        System. out. println("s1==s3");}
    }
}

A.s1==s2

B.s1==s2

s2==s3

C.s1==s2

s1==s3

D.s1==s2

s2==s3

s1==s3

阅读下列代码段，正确的输出结果是( D )。

String s1=new String(“abc");
String s2=new String(“abc");
System. out. println(s1==s2)

A.s1==s2

B.1

C. true

D. false

运行下面的程序段，输出结果是( B )。

string s1=new String("abc");
stringBuffer s2 =new stringBuffer ("abc");
s2. append(s1);
s1=s2. tostring( );
s1. concat ("abc");
System. out. println(s1);

A. abc

B. bcabe

C.编译错误

D. abcabcabc

以下程序段，正确的结果是( A )。

int[ ] srcArray= {1,2,3,4,5,6};
int[ ] destArray= new int[3];
System.arraycopy(srcArray, 2, destArray, 1, 2);
for (int i =0; i< destArray. length; i++) {
System. out. print (destArray[i]+" ");
}

A.0 3 4

B.0 2 3

C.2 3 4

D.编译错误

Runtime类的( A )方法的作用是返回虚拟机的空闲内存量。

A. freeMemory( )

B. totalMemory( )

C. maxMemory( )

D. availableProcessors
要计算，以下哪个方法能正确算出( D )。

A. Math. pow(27，3)

B. sqrt(27)

C. exp(27)

D. cbrt(27)
已知String sb =“youareastudent"，则sb. substring(2, 7)截取的字符串为( C )。

A. area

B. ouarea

C. uarea

D. uareas
以下代码段，对其叙述正确的是( D )。
```
Calendar cd=Calendar. getInstance( );
cd. set (2018,3,2);
int dayOfWeek=cd. get (Calendar. DAY_OF_WEEK);(结果为2)
```
A.设置的年月日的值为2018年3月2日

B.设置的年月日的值为2018年2月2日

C. dayOfWeek值为2表示星期二

D. dayOfWeek值为2表示星期一

二、填空题

下列程序的运行结果是 HELLO 。

public class StrTest{
    public static void main(String[ ] args) {
        String str="hello!";
        System. out. println (str. toUpperCase( )) ;
  }
}

已知StringBuffer sb = new StringBuffer( ”abcde”)，则sb. delete(1, 2)后sb的值为 acde 。
已知String s=" abed\ n"，s. length( )的值为 5 。
已知String s=“aaa | bbb I ccc”，如果想正确拆分出aaa、bbb 和ccc,拆分字符串应该为 String t[]=s.split(“\|”); 。
要运用Random类获取1-100之间的随机数，代码为: Random r=new Radom(); int n=r.nextInt(100)+1; 。
调用Math类的sin( )、cos( )方法求正弦、余弦值时，给定的度数参数是弧度。
System类中包含了三个成员变量，分别代表 err 、 in 和 out 。
方法exit( int status)的作用是终止正在运行的Java虚拟机，statues 的值为 0 代表正常退出。

三、操作题

统计一段英文中包含单词的个数。

public class P222_1 {  
    public static void main(String[] args) {  
        String text = "Hello, this is a simple program to count words in a text.";  
  
        // 使用空格作为分隔符来分割文本  
        // 注意：这不会处理标点符号后跟随的空格作为单词分隔符的情况  
        String[] words = text.split("\\s+"); // "\\s+" 匹配一个或多个空白字符  
  
        // 单词数量即为数组的长度  
        int wordCount = words.length;  
  
        System.out.println("文中包含了" + wordCount + " 个单词。");  
    }  
}

给出两个日期，计算它们之间相隔的天数。

import java.util.Calendar;  
import java.util.Date;  
  
public class P222_2 {  
  
    public static void main(String[] args) {  
        // 设定两个固定日期    
Date date1 = setDate(2023, 3, 15); // 2023年3月15日    
Date date2 = setDate(2024, 3, 15);  // 2023年4月5日  
  
        // 计算天数差    
long daysBetween = getDaysBetween(date1, date2);  
  
        // 输出结果    
System.out.println("两个日期之间相隔的天数: " + daysBetween);  
    }  
  
    // 设定日期的辅助方法    
private static Date setDate(int year, int month, int day) {  
        Calendar calendar = Calendar.getInstance();  
        calendar.set(year, month - 1, day); // 注意月份是从0开始的    
return calendar.getTime();  
    }  
  
    // 计算两个日期之间的天数差    
private static long getDaysBetween(Date date1, Date date2) {  
        long diff = date2.getTime() - date1.getTime();  
        return diff / (1000 * 60 * 60 * 24); // 一天中的毫秒数    
}  
}

第九章集合框架

一、选择题

下列叙述中正确的是( C )。

A. List的特点是元素无序，可重复

B. List的特点是元素无序，不可重复

C. List的特点是元素有序，可重复

D. List的特点是元素有序，不可重复
下列叙述中正确的是( A )。

A. Set接口的特点是元素无序，且不可重复

B. Set接口的特点是元素无序，可以重复

C. Set接口的特点是元素有序，且不可重复

D. Set接口的特点是元素有序，可以重复
下列叙述中正确的是( D )。

A.使用ArrayList和LinkedList集合查找元素都很便捷，只是存储结构不同

B.使用ArrayList集合在增删元素和查找元素时速度都很快

C.使用LinkedList集合在增删元素和查找元素时速度都很快

D. ArrayList集合在查询元素时速度很快，LinkedList集合对增删元素操作效率高
下面关于集合的说法正确的是( B )。

A. List接口继承了Collection 接口以定义一个不允许重复项的有序集合

B. ArrayList和LinkedList 是List接口的实现类

C.要支持随机访问，选择LinkedList类较好；而顺序访问列表元素使用ArrayList类更好

D. Set接口继承Collection接口，而且它允许集合中存在重复项
以下关于ArrayList集合的说明，不正确的是( D )。

A. ArrayList是List 集合的实现类，是程序中较为常见的一种集合

B. ArrayList内部封装了一个长度可变的数组对象

C. ArrayList集合使用add( )和get( )方法实现元素的存取

D. ArrayList可以增加或者删除指定位置的元素，效率较高，适合做大量的增删操作
以下说法中，正确的是( A )。

A.相较ArrayList集合，LinkedList集合增删元素的时候效率更高

B. 需要遍历集合中的元素时，可以使用Iterator 进行遍历，用Iterator 的get( )方法对元素进行遍历

C.使用foreach对集合中的元素进行遍历的时候，需要知道集合的大小

D. Set接口和List接口类似，两者中的元素都是有序的
关于TreeSet集合的说法，不正确的是( C )。

A. TreeSet是Set接口的一个实现类

B. TreeSet内部采用自平衡的二叉树存储元素

C. TreeSet集合中的元素可以重复，但只能重复一次

D. TreeSet集合中没有重复的元素，且可以对元素进行排序

二、填空题

Map接口的特点是元素是键值对，其中值可以重复，键不可以重复。
ArrayList底层使用数组来保存元素，LinkedList 采用链表存储方式。
Java集合类和数组不同，数组元素既可以是基本数据类型，也可以是对象类型；而集合中的元素只能是对象类型。
Java集合类主要由两个接口派生，一个是 Collection ，另一个是 Map 。
Java集合可分成三类，其中Set集合中的元素不能重复；List集合非常像数组；Map 集合的元素由两个值组成，一个是键，一个是值。
Iterator接口是Java集合框架中的成员，和Collection、Map集合不一样，Iterator接口主要用于遍历 Collection集合中的元素。Iterator又称迭代器。
HashSet扩展自AbstractSet 并实现了Set接口，它创建了一个类集，该类集使用散列表进行存储，里面的数据不允许重复，并且没有顺序。
Properties是Hashtable的一个子类，能够操作的数据全部是String，键和值的类型全部是字符串。
Java中，标准类型的数组是定长的，一旦数组被创建，就不能被加长或缩短，但 ArrayList 类解决了这个问题，它支持可随需要而增长的动态数组。

三、操作题

在程序中声明一个HashSet集合类的对象，向集合对象中添加字符串元素，并使用Iterator迭代输出集合中的元素。

import java.util.HashSet;  
import java.util.Iterator;  
  
public class P261_1  {  
    public static void main(String[] args) {  
        // 声明一个HashSet集合类的对象    
HashSet<String> set = new HashSet<>();  
  
        // 向集合中添加字符串元素    
set.add("apple");  
        set.add("banana");  
        set.add("cherry");  
        set.add("date");  
  
        // 使用Iterator迭代输出集合中的元素    
Iterator<String> iterator = set.iterator();  
        while (iterator.hasNext()) {  
            String element = iterator.next();  
            System.out.println(element);  
        }  
    }}

使用Map, 以姓名为键，电话号码为值，实现以下电话通信录的功能：

(1)增加新联系人的电话号码；

(2)修改某个联系人的电话号码；

(3)显示所有联系人的信息。

import java.util.HashMap;  
import java.util.Map;  
  
public class P261_2 {  
    private Map<String, String> contacts;  
  
    public P261_2() {  
        contacts = new HashMap<>();  
    }  
  
    // （1）增加新联系人的电话号码    
public void addContact(String name, String phoneNumber) {  
        contacts.put(name, phoneNumber);  
        System.out.println("已添加联系人: " + name + ", 电话号码: " + phoneNumber);  
    }  
  
    // （2）修改某个联系人的电话号码    
public void updateContact(String name, String newPhoneNumber) {  
        if (contacts.containsKey(name)) {  
            contacts.put(name, newPhoneNumber);  
            System.out.println("已更新联系人 " + name + " 的电话号码为: " + newPhoneNumber);  
        } else {  
            System.out.println("联系人 " + name + " 不存在，无法更新电话号码。");  
        }  
    }  
    // （3）显示所有联系人的信息    
public void displayContacts() {  
        for (Map.Entry<String, String> entry : contacts.entrySet()) {  
            System.out.println("姓名: " + entry.getKey() + ", 电话号码: " + entry.getValue());  
        }  
    }  
    public static void main(String[] args) {  
        P261_2 phoneBook = new P261_2();  
  
        // 增加新联系人    
phoneBook.addContact("张三", "1234567890");  
        phoneBook.addContact("李四", "0987654321");  
  
        // 显示所有联系人信息    
System.out.println("当前通信录中的联系人:");  
        phoneBook.displayContacts();  
  
        // 修改联系人电话号码    
phoneBook.updateContact("张三", "1111111111");  
  
        // 再次显示所有联系人信息    
System.out.println("更新后通信录中的联系人:");  
        phoneBook.displayContacts();  
    }  
}