单元测试一

一、单选题

1

public  class  Test{
	public  static  void  main(String[]  args){
		int  i=1;
		switch(i){
			case  0:
				System.out.println("1"+(i++));
			case  1:
				System.out.println("2"+(++i));
				break;
			case  2:
				System.out.println("3"+(i++));
			default:
				break;
		}
	}
}

2

public  class  Test{
	public  static  void  main(String[]  args){
		System.out.print(1.0/0);
	}
}

编译运行输出

Infinity

老师说一切以运行结果为准

3

正确答案应该为A.double java小数默认为double

public  class  Test{
	public  static  void  main(String[]  args){
		System.out.println(8%(-3));
		System.out.println(-5+12.0/5+8%(-3));
	}
}

2
-0.6000000000000001

4

5

6

public  class  Test{
	public  static  void  main(String[]  args){
		int num = 0XFFFFFFFF;//0X表示16进制
		System.out.println(num);//8个F,计算机内部表示为32个1，补码形式,值为-1
		// int num = 0XFFFFFFFFF;//多一个F的情况
		/*
		Test.java:3: 错误: 整数太大
		int num = 0XFFFFFFFFF;//0X表示16进制
		          ^
		1 个错误
		*/
	}
}

输出：-1，这个其实没问题。 

public  class  Test{
	public  static  void  main(String[]  args){
		int num = 0XFFFFFFFF;
		long lnum = 1e9;
		double dnum = 1.324e9;//java小数默认为double
		float f = 1.0;
	}
}

Test.java:4: 错误: 不兼容的类型: 从double转换到long可能会有损失
		long lnum = 1e9;
		            ^
Test.java:6: 错误: 不兼容的类型: 从double转换到float可能会有损失
		float f = 1.0;
		          ^
2 个错误

正确形式

public  class  Test{
	public  static  void  main(String[]  args){
		int num = 0XFFFFFFFF;
		long lnum = (long)1e9;
		double dnum = 1.324e9;//java小数默认为double
		float f = 1.0F;//Java默认小数为double，所以定义float必须强转
	}
}

7

这个可能题目有问题

二、填空题

1

public  class  Test{
	public  static  void  main(String[]  args){
		xMethod(5);
	}
	public static void xMethod(int n){
		if( n > 0 ){
			xMethod( n -1 );
			System.out.print( "1" + n );
		}
	}
	/*
	递归：xMethod(5)->xMethod(4)->xMethod(3)->xMethod(2)->xMethod(1)->xMethod(0) 然后逆向输出
	输出：11 12 13 14 15
	
	*/
}

2

 replace方法参见Java replace() 方法 | 菜鸟教程 (runoob.com)

public  class  Test{
	public  static  void  main(String[]  args){
		String str = "World Wide Web";
		String s = str.toUpperCase().replace("D","B").substring(6);
		System.out.println(s);
	}
	/*
	World Wide Web -> WORLD WIDE WEB -> WORLB WIBE WEB -> 保留从下标6开始到后面的部分 WIBE WEB
	
	*/
}

3

public  class  Test{
	public  static  void  main(String[]  args){
		int[] list = {1, 2, 3, 4, 5, 6};
		int temp = list[0];
		for( int i = 0; i < list.length-1; i++ )
			list[i] = list[i+1];
		//223456
		//233456
		//234456
		//234556
		//234566
		list[list.length-1] = temp;
		//234561
		for ( int n: list )
			System.out.print(n);
	}
}

三、简答题

题目

下面这段代码从标准输入接受一字符串输入，字符串由小写字母构成，将字符串中内容按字母表顺序排序后重新输出。若字符有重复则输出同等数量字符。如输入字符串
“beaaoln”，则输出为“aabelno”。在下列代码中存在多处错误，请分别指明存在的错误及相应的行号，若几行的错误相同，计做一处，写一起即可，并指明该如何修正错误，以使程序能够顺利通过编译并正确运行。

 参考答案

第1行 java.io.*;==>java.util.*;

第3行 main()==>main(String[] args)

第6行 input.nextString()==>input.next();

第10行 public String ==> public static String

第12行 str; ==>str="";

第13行 ss.length==>ss.length()

第14行 ss[i]==>ss.charAt(i)

第17行 ccount.length()==>ccount.length

第20行 'a'+i==>(char)('a'+i)

第23行 加上return str;

代码

import java.util.*;	//java.io.*;==>java.util.*;
public class Test {
	public static void main(String[] args) {	//main()==>main(String[] args)
		Scanner input = new Scanner(System.in);
		System.out.print("请输入一个字符：");
		String ss = input.next();	//input.nextString()==>input.next();
		String result = mySort(ss);
		System.out.println("排序后的结果为" + result);
	}
	public static String mySort(String ss) {	//public String ==> public static String
		int[] ccount = new int[26];
		String str="";	//	str; ==>str="";
		for( int i = 0; i < ss.length(); i++ ) {	//ss.length==>ss.length()
			int id = ss.charAt(i)-'a';	//ss[i]==>ss.charAt(i)
			ccount[id]++;
		}
		for( int i = 0; i < ccount.length; i++ ) {	//ccount.length()==>ccount.length
			int temp = ccount[i];
			while( temp > 0 ) {
				str+=(char)('a' + i);	// 'a'+i==>(char)('a'+i)
				temp--;
			}
		}
		return str;	//第23行 加上return str;
	}
		
}

运行输出

请输入一个字符：gfedcba
排序后的结果为abcdefg

一个小细节

public class Test{
	public  static  void  main(String[]  args){
		System.out.println( 'a' + 1 );
		System.out.println( (char)('a' + 1) );
	}
}

输出 

98
b

四、编程题

题目

参考答案

import java.util.Scanner;
public class Test{
	public static void main(String[] args){
		Scanner input=new Scanner(System.in);
		int m;
		System.out.print("Please enter a number:");
		m=input.nextInt();
		int[] carr=new int[m];
		for(int i=0;i<m;i++)
			carr[i]=(int)(Math.random()*10000);	//Math.random()是令系统随机选取大于等于 0.0 且小于 1.0 的伪随机 double 值
		System.out.println("最大值为"+Test.maxElement(carr));
		System.out.println("最小值为"+Test.minElement(carr));
		Test.mostFrequentNum(carr);
		System.out.println("平均值为"+Test.average(carr));
	}//(2分)

	public static int maxElement(int[] arr){
		int max=arr[0];
		for(int i=0; i<arr.length; i++){
			if(arr[i]>max)
				max=arr[i];
			}
		return max;
	}//(2分)

	public static int minElement(int[] arr){
		int min=arr[0];
		for(int i=0; i<arr.length; i++){
			if(arr[i]<min)
				min=arr[i];
		}
		return min;
	}//(2分)

	public static void mostFrequentNum(int[] arr){
		int[] freq=new int[10000];
		for(int i=0;i<arr.length; i++)
			freq[arr[i]]++;
		int maxIndex=0;
		int maxCnt=0;
		for(int i=0; i<freq.length; i++){
			if(freq[i]>maxCnt){
				maxCnt=freq[i];
				maxIndex=i;
			}
		}
		System.out.println("出现次数最多的数是"+maxIndex+",共有"+maxCnt+"次");
	}//(2分)

	public static double average(int[] arr){
		double sum=0;
		for(int n:arr)
			sum+=n;
		return sum/arr.length;
	}//(2分)
	
}

单元测试二

一、单选题

1

代码

import java.util.Scanner;
public class Test{
	public static void main(String[] args){
		String s1 = "abc";
		String s2 = new String("abc");	//new 了一个，地址与s1不同
		String s3 = "ab";
		String s4 = s3;	//赋值地址，s3,s4地址和内容都相同 s4内容：ab
		s3 = s3 + "c";	//相当于指向了一串新的字符串，地址变了，内容也变成：abc
		System.out.println(s1 == s2);	//地址不同，为false
		System.out.println(s1.equals(s2));	//内容相同，为true
		System.out.println(s1 == s4);	//s1和s4地址不同，为false
		System.out.println(s1.equals(s4));	//s1和s4内容不同，为false
		System.out.println(s1.equals(s3));	//内容相同，为true
		System.out.println(s1 == s3);	//地址不同，为false
		
	}
}

false
true
false
false
true
false

AI分析

 2

解释：

A. 父类可以new一个子类的空间

B. 子类不能new一个父类的空间

C. 子类不能new一个兄弟的空间

D. 子类的子类更不能new一个父类的空间

总结：

1. 创建父类对象可以new自己和子类

2. 子类不能new父类

3. 子类不能new兄弟

class C1{}
class C2 extends C1{}
class C3 extends C1{}
class C4 extends C2{}
public class C{
	public static void main(String[] args){
		C1 c1 = new C1();
		C1 c12 = new C2();
		C1 c13 = new C3();
		C1 c14 = new C4();
		
		C2 c2 =new C2();
		C3 c3 =new C3();
		C4 c4 =new C4();
			
		C2 c22 = new C4();
		
		// C4 c44 = new C2();	//父类无法转为子类
		// C2 c23 = new C3();	//兄弟无法转为自己
	}
}

3

父类无法转为子类

4

static方法
static方法也成为静态方法，由于静态方法不依赖于任何对象就可以直接访问，因此对于静态方法来说，是没有this的，因为不依附于任何对象，既然都没有对象，就谈不上this了，并且由于此特性，在静态方法中不能访问类的非静态成员变量和非静态方法，因为非静态成员变量和非静态方法都必须依赖于具体的对象才能被调用。
————————————————

5

6

1. 一个类只能继承一个父类，只能有一个爸爸！

2. 一个类能够实现多个接口

7

个人感觉这个题的D项应该是D、以上说法都正确 

AI解释

8

二、填空题

 1

构建一个时间类 Time，用于显示一天中的几点几分。类中需要包括以下内容： 

• 构建方法，用于构建 Time 对象，其中 hour 取值范围为 0–23，minutes 取值范围为 0–59 

• addMinutes 方法，在当前时间上增加分钟数，返回一个新的 Time 对象

• toString 方法，显示输出 Time 对象的信息，其中 00:00AM 输出 Midnight，12:00PM 输出 Noon，其余输出时间信息 

• priorTo 方法，用于比较两个时间对象，若在前，则返回 true 

如在 main 方法中按以下顺序调用语句： 

• Time dawn=new Time(6,35);//构建一个时间对象为早上 6 点 35 分 

• Time dusk=dawn.addMinutes(60*12);//构建一个对象，为下午 18 点 35 分 

• Time m=new Time(0,0);//构建一个对象，为午夜 0 点 

• Time n=new Time(12,0);//构建一个对象，为中午 12 点 

• System.out.println(dawn); 

• System.out.println(dusk); 

• System.out.println(m); 

• if(m.priorTo(dusk)) System.out.println(”Hello”);

输出为 

06:35AM 

06:35PM 

Midnight 

Noon 

Hello

在下述代码中，请补全缺失处的代码。 

注意事项：toString() 方法需要按 12 小时格式输出，小时与分钟均占两个字符位 

11:05AM 不能输出为 11:5AM，09:05AM 也不能输出为 9:05AM

class Time{ 

  private int hour, minute; 

  public Time(int hour, int minute){ 

     ______1______; 

  } 

  public Time addMinutes(int m){

     int totalMinutes=(60*hour+minute+m)%(24*60); 

     return ______2______; 

  } 

  public String toString(){ 

    if((hour==0)&&(minute==0)) 

      return ”Midnight”; 

    else if(______3______) 

      return ”Noon”; 

    else{ 

      ______4______; 

    } 

  } 

  public boolean priorTo(Time t){ 

    ______5______; 

  } 

} 

花点时间是能把代码看懂的

参考答案：

1：

this.hour=hour;this.minute=minute;

2：

new Time(totalMinutes/60,totalMinutes%60);

3：

(hour==12)&&(minutes==0)

4：

(hour>9?””:”0”)+hour%12+”:”+(minutes>9?””:”0”)+minutes+(hour>=12?” PM”:”AM”);

5：

return (hour*60+minutes)-(t.hour*60+t.minutes)>0

个人认为参考答案第5空不对。应该为：return (hour*60+minute)<(t.hour*60+t.minute);

代码

class Time{
	private int hour;
	private int minute;
	
	private Time( int hour, int minute ) {
		this.hour = hour;
		this.minute = minute;
	}
	public Time addMinutes(int m){
		int totalMinutes = ( 60 * hour + minute + m ) % ( 24 * 60);	//取余以限制在一天之中
		return new Time( totalMinutes / 60, totalMinutes % 60 );		
	}
	public String toString() {
		if( (hour == 0) && (minute == 0) )
			return "Midnight";
		else if( (hour == 12) && (minute == 0) )
			return "Noon";
		else
			return (hour>9?"":"0") + hour%12 + ":" + (minute>9?"":"0") + minute + (hour>=12?"PM":"AM");
	}
	public boolean priorTo( Time t ) {
		return (hour*60+minute)<(t.hour*60+t.minute);
	}
	
	public static void main(String[] args) {
		Time dawn = new Time(6,35);	//构建一个时间对象为早上 6 点 35 分 
		Time dusk =	dawn.addMinutes(60*12);	//构建一个对象，为下午 18 点 35 分 
		Time m = new Time(0,0);	//构建一个对象，为午夜 0 点
		Time n = new Time(12,0);	//构建一个对象，为中午 12 点 
		System.out.println(dawn);
		System.out.println(dusk);
		System.out.println(m);
		System.out.println(n);
		if(m.priorTo(dusk))
			System.out.println("Hello");
	}
}

06:35AM
6:35PM
Midnight
Noon
Hello

2

代码

public class Test {
	public static void main(String[] args) {
		new Person().printPerson();
		new Student().printPerson();
	}
}

class Student extends Person {
	private String getInfo() {
		return "Student";
	}
}

class Person {
	private String getInfo() {
		return "Person";		
	}
	public void printPerson() {
		System.out.println(getInfo());
	}
}

Person
Person

AI分析

当我们在 main 方法中创建 Person 和 Student 对象并调用 printPerson() 方法时：

1. new Person().printPerson() 调用 Person 类中的 printPerson() 方法，该方法调用 Person 类的 getInfo() 方法，输出 "Person"。
2. new Student().printPerson() 调用 Person 类中的 printPerson() 方法（因为 Student 没有覆盖 printPerson()），该方法调用 Person 类的 getInfo() 方法，输出 "Person"。Student 类中的 getInfo() 方法不会被调用，因为 printPerson() 调用的是它自己的类（Person）中的 getInfo()。

3

传给alter()方法的不过是形参，改变不了原来的值

4

public class Test {
	public static long method( int n, long m ) {
		System.out.println("int,long");
		return 3*m;
	}
	public static int method( long n, int m ) {
		System.out.println("long,int");
		return 2*m;
	}
	public static void main(String[] args) {
		System.out.println(method(1L,2));
	}
}

long,int
4

以运行结果为准

这里的 知识点叫函数的重载

三、编程题

代码

abstract class Human {
	public void eat() {
		System.out.println("Human Eat");
	}
	public void sleep() {
		System.out.println("Human Sleep");
	}
}
interface Dreamable {
	public abstract void dream();	//接口中的所有数据域都是public static final								
}									//接口中的所有方法都是public abstract
interface Flyable {
	public abstract void fly();
}
class Superman extends Human implements Flyable {
	public void eat() {
		System.out.println("Superman Eat");
	}
	public void sleep() {
		System.out.println("Superman Sleep");
	}
	public void fly() {
		System.out.println(this);
	}
	public String toString() {
		return "Superman Flying";
	}
}
class Mortal extends Human implements Dreamable {
	public void eat() {
		System.out.println("Mortal Eat");
	}
	public void sleep() {
		System.out.println("Mortal Sleep");
	}
	public void dream() {
		System.out.println(this);	//注意，父类或接口的抽象方法必须在子类中实现，
	}								//否者错误: Mortal不是抽象的, 并且未覆盖Dreamable中的抽象方法dream()
	public String toString() {
		return "Mortal Dreaming";
	}
}
class Eagle implements Flyable {
	public void fly() {
		System.out.println(this);
	}
	public String toString() {
		return "Eagle Flying";
	}
}
public class Test {
	public static void main(String[] args) {
		Mortal mortal = new Mortal();
		System.out.println(mortal);
		Flyable[] flys = {
			new Superman(),	//注意逗号
			new Eagle()
		};	//注意分号
		for( Flyable fb : flys ) {
			System.out.println(fb);
		}
	}
}

运行 

Mortal Dreaming
Superman Flying
Eagle Flying

单元测试三

一、单选题

1

运行上述程序后，往文件 `t.dat` 中写入的字节数可以通过分析每个写入方法的字节数来计算。

1. `output.writeUTF("中");`
   - `writeUTF` 方法用于写入一个 UTF-8 编码的字符串，并在前面加上两个字节的长度信息。一个汉字（"中"）在 UTF-8 编码下占3个字节，再加上2个字节的长度信息，总共占5个字节。

2. `output.writeDouble(5.5);`
   - `writeDouble` 方法用于写入一个 `double` 类型的值，占8个字节。

3. `output.writeInt(1234);`
   - `writeInt` 方法用于写入一个 `int` 类型的值，占4个字节。

将所有这些字节数加起来：
- `writeUTF("中")`: 5个字节
- `writeDouble(5.5)`: 8个字节
- `writeInt(1234)`: 4个字节

总字节数 = 5 + 8 + 4 = 17个字节。

因此，运行上述程序后，往文件 `t.dat` 中写入的字节数是 **17个字节**。

2

3

执行一个 SQL 查询时，应该使用 executeQuery 方法，而不是 executeUpdate 方法。executeUpdate 是用来执行插入、更新或删除操作的，它返回一个整数表示受影响的行数。 executeQuery 返回一个 ResultSet，用来处理查询结果。

4

5

在两台机器间建立连接传输视频或音频数据的情况下，应该选择 C、DatagramPacket 类来打包数据。

原因是视频和音频数据通常是流式数据，传输过程中需要高效处理，DatagramPacket 类用于通过UDP协议发送和接收数据包。UDP协议是面向无连接的协议，适合实时传输多媒体数据，因为它具有较低的延迟。

尽管如此，实际应用中也可能使用其他方法来传输视频或音频数据，例如使用 Socket 类通过TCP协议传输，因为TCP虽然延迟较高，但能保证数据的可靠传输。因此具体选择还要看应用需求，比如对延迟还是数据完整性的侧重。

所以综合考虑实时性，选择 C、DatagramPacket 是较为合理的。

6

在 ServerSocket 中用于接收来自客户端请求的方法是：

A、accept()

accept() 方法用于在服务器端阻塞等待，直到有客户端连接请求到达时才会返回一个新的 Socket 对象，用于与客户端进行通信。

7

用于处理一般形式的输入输出，不只针对字符，该流称为：

A、ByteStream

ByteStream 是处理二进制数据的输入输出流，适用于所有类型的数据，包括字符数据。它与 CharacterStream 的区别在于，CharacterStream 主要处理字符数据，而 ByteStream 处理的是原始的二进制数据。

8

以下关于流的说法中正确的是：

C、一个流可以作为另一个流的数据源，一些流可以相互连接在一起

在 Java 中，一个流可以作为另一个流的数据源。例如，BufferedInputStream 可以包装在 FileInputStream 上，以提高读取效率。类似地，PrintWriter 可以包装在 OutputStream 上，以便更方便地写入文本数据。这种流的连接机制在 Java 的 I/O 系统中是非常常见的。

9

A、list.add(100);

解释：
在 Java 中，List<Number> list = new ArrayList<>() 创建了一个 Number 类型的列表。由于 Integer 是 Number 的子类，所以可以将 100 作为 Number 添加到列表中。

其他选项的分析：

• B、list.add('a', 'b', 'c'); 不正确，因为 List 的 add 方法只接受一个参数，不接受多个字符参数。
• C、list.add(new java.util.Date()); 不正确，因为 java.util.Date 不是 Number 的子类，不能添加到 List<Number> 中。

10

下列关于泛型使用的说法中正确的是

D、以上说法都不正确

解释：

• A、泛型参数可用于new操作符，如E obj=new E();
  不正确，因为在 Java 中无法直接实例化泛型参数。编译器在编译时不知道 E 的具体类型，因此无法执行 new E() 操作。

• B、泛型参数可用于构建数组，如E[] ele=new E[10];
  不正确，因为同样的原因，编译器在编译时无法确定 E 的具体类型，无法创建泛型数组。不过，可以创建泛型数组的通配符数组（例如：new ArrayList<E>[10]）。

• C、泛型参数可用于静态方法中，如public static void m(E o){}
  不正确，因为静态方法不能直接使用类的泛型类型参数。静态方法应该定义自己的泛型参数，例如：public static <T> void m(T o){}。

因此，以上说法都不正确。

11

JDBC中，用于表示数据库中带参数的查询语句对象的是：

D、PreparedStatement

解释：

• DriverManager 用于管理一组 JDBC 驱动程序，并建立数据库连接。
• Connection 表示与特定数据库的连接（会话），用于发送 SQL 语句到数据库。
• Statement 用于执行不带参数的静态 SQL 查询语句。
• PreparedStatement 用于执行带参数的预编译 SQL 查询语句，允许在运行时动态绑定参数，并且提供了更高的安全性和性能。

12

下列对于异常处理机制的描述中，正确的是：

A、一个try块可对应于多个catch块

解释：

• A、一个try块可对应于多个catch块 正确，一个 try 块可以有多个 catch 块，每个 catch 块可以处理不同类型的异常。这允许对不同类型的异常进行不同的处理。

• B、catch语句必须对异常类型进行精确匹配 不正确，catch 块可以捕获其指定类型及其子类的异常。

• C、一旦出现异常，异常处理机制会自动终止程序的运行 不正确，异常处理机制是为了捕获和处理异常，使程序可以继续运行或安全地终止。

• D、以上说法都不正确 不正确，因为选项 A 是正确的。

所以，正确答案是 A、一个try块可对应于多个catch块。

13

已知某方法会产生异常，下列哪种异常必须放在try-catch块中处理：

A、FileNotFoundException

解释：

• FileNotFoundException 是一个受检异常（Checked Exception）。在 Java 中，受检异常必须要么在方法签名中声明（使用 throws 关键字），要么在方法内部用 try-catch 块进行处理，否则编译器会报错。

• ArithmeticException 是一个运行时异常（Runtime Exception），也称为未受检异常（Unchecked Exception）。这类异常不强制要求必须在 try-catch 块中处理。

• IllegalArgumentException 也是运行时异常，不需要强制在 try-catch 块中处理。

• NullPointerException 同样是运行时异常，不需要强制在 try-catch 块中处理。

因此，正确答案是 A、FileNotFoundException。

二、填空题

1

1. output.writeInt(1234);

   • writeInt 方法会将一个 int 类型的值写入输出流，int 在 Java 中占 4 个字节。

2. output.writeChars("AB");

   • writeChars 方法会将每个字符以两个字节的 Unicode 形式写入输出流。
   • "AB" 有两个字符，每个字符占 2 个字节，因此共占 4 个字节。

3. output.writeUTF("汉");

   • writeUTF 方法使用 UTF-8 编码写入字符串。
   • UTF-8 编码会首先写入 2 个字节的长度信息，然后是实际字符串的字节数据。
   • "汉" 在 UTF-8 编码中占 3 个字节（一个汉字在 UTF-8 中通常占 3 个字节）。

计算总字节数：

• writeInt(1234) 写入 4 个字节。
• writeChars("AB") 写入 4 个字节。
• writeUTF("汉") 写入 2 个字节（长度信息） + 3 个字节（实际数据），共 5 个字节。

总共写入的字节数是：4 + 4 + 5 = 13 个字节。

因此，执行完上述代码片段后，往文件 t.dat 中写入的字节数是 13 个字节。

2

在分析给定的 Java 代码后，可以确定在执行完代码后 `arrayList` 的内容。我们逐行分析代码，查看每一步对列表的影响：

import java.util.*;
public class Test {
  public static void main(String[] args) {
    List<Character> arrayList = new ArrayList<>();
    arrayList.add('a'); // [a]
    arrayList.add('b'); // [a, b]
    arrayList.add('c'); // [a, b, c]
    arrayList.add('a'); // [a, b, c, a]
    arrayList.remove(new Character('b')); // [a, c, a]
    arrayList.add(2, 'd'); // [a, c, d, a]
    arrayList.remove(new Character('a')); // [c, d, a]
  }
}

### 详细分析：

1. **初始化并添加字符**
  

List<Character> arrayList = new ArrayList<>();
arrayList.add('a'); // [a]
arrayList.add('b'); // [a, b]
arrayList.add('c'); // [a, b, c]
arrayList.add('a'); // [a, b, c, a]

    经过上述操作后，`arrayList` 的内容为 `[a, b, c, a]`。

2. **移除字符 'b'**
    

arrayList.remove(new Character('b')); // [a, c, a]

    `remove` 方法根据传入的 `Character` 对象来移除列表中的第一个匹配项。因此，'b' 被移除后，列表变为 `[a, c, a]`。

3. **在索引 2 处插入字符 'd'**

arrayList.add(2, 'd'); // [a, c, d, a]

    在索引 2 处插入 'd' 后，列表变为 `[a, c, d, a]`。

4. **移除字符 'a'**
   

arrayList.remove(new Character('a')); // [c, d, a]

    再次调用 `remove` 方法移除第一个匹配的 'a'，移除后列表变为 `[c, d, a]`。

### 最终列表内容
执行完所有操作后，`arrayList` 的内容是 `[c, d, a]`。

因此，运行上述代码后，`arrayList` 的内容是 **[c, d, a]**。

3

4

代码分析：

1. Test 类和 main 方法

   public class Test {
     public static void main(String[] args) {
       try {
         method();
         System.out.println("A");
       } catch (ArithmeticException ex) {
         System.out.println("Exception A");
       } catch (RuntimeException ex) {
         System.out.println("Exception B");
       } catch (Exception e) {
         throw e;
       } finally {
         System.out.println("C");
       }
     }
     static void method() throws Exception {
       String s = "cba";
       System.out.println(s.charAt(3));
     }
   }
   

2. 调用 method 方法

   • main 方法调用了 method()，这是在 try 块中进行的调用。

3. method 方法内容

   static void method() throws Exception {
     String s = "cba";
     System.out.println(s.charAt(3));
   }
   

   • 该方法创建了一个字符串 s，其内容为 "cba"。
   • 然后尝试打印 s.charAt(3)。

4. 字符索引越界异常

   • s.charAt(3) 试图访问字符串 s 的第四个字符（索引从0开始），但是 "cba" 只有三个字符，索引范围为 0 到 2。
   • 因此，s.charAt(3) 会抛出一个 StringIndexOutOfBoundsException，这是一个 RuntimeException。

5. 捕获异常和输出

   • StringIndexOutOfBoundsException 被 catch (RuntimeException ex) 捕获。
   • 进入第二个 catch 块，输出 "Exception B"。
   • finally 块始终会执行，无论是否发生异常，输出 "C"。

程序的输出

综上所述，程序将输出：

Exception B
C

程序在捕获到 RuntimeException 后输出 "Exception B"，然后进入 finally 块输出 "C"。

三、简答题

参考答案：

• (2 分) this.id=id; this.balance=balance; 

• (2 分) balance+=amount; 

• (2 分) if(balance<0) return true; else return false; 

• (2 分) overdraft(amount) 或加上 ==true 

• (2 分) ””+this.id+this.balance;

四、编程题

interface Geometry {
    public double getArea();
    public double getPerimeter();
}

class Rectangle implements Geometry {
    private double width;
    private double height;

    Rectangle() {
        this.width = 1.0;
        this.height = 1.0;
    }

    Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }

    public double getWidth() {
        return this.width;
    }

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

    public double getHeight() {
        return this.height;
    }

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

    public double getArea() {
        return this.width * this.height;
    }

    public double getPerimeter() {
        return 2 * (this.width + this.height);
    }
}

class Circle implements Geometry {
    private double radius;

    Circle() {
        this.radius = 1.0;
    }

    Circle(double radius) {
        this.radius = radius;
    }

    public double getRadius() {
        return this.radius;
    }

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

    public double getArea() {
        return Math.PI * radius * radius;
    }

    public double getPerimeter() {
        return 2 * Math.PI * radius;
    }
}

public class Test {
    public static void main(String[] args) {
        Geometry[] geos = new Geometry[]{new Circle(1.0), new Rectangle(1.0, 2.0)};
        for (Geometry geo : geos) {
            System.out.println("Area is " + geo.getArea() + ", Perimeter is " + geo.getPerimeter());
        }
    }
}