IBM选择题 IBM java考试题目

更新时间：2023-11-18 01:10:02 阅读量：教育文库文档下载

说明：文章内容仅供预览，部分内容可能不全。下载后的文档，内容与下面显示的完全一致。下载之前请确认下面内容是否您想要的，是否完整无缺。

IBM选择供应商有哪些经验值得总结推荐度：
相关推荐

1.下面说法正确的是（）。

(A) Java程序的源文件名称与主类（公共类）的名称相同，后缀可以是.java或.txt等。 (B) JDK的编译命令是java。

2.下面的说法正确的是（）。

(A) Java语言面向对象的、解释执行的网络编程语言。 (B) Java语言具有可移植性，是与平台无关的编程语言。 (C) Java语言可对内存垃圾自动收集。

(D) Java语言编写的程序虽然是“一次编译，到处运行”，但必须要Java的运行环境。

3.下面（）不是Java的关键字。

(A) integer (B) double (C) float (D) char

4.以下语句中没有编译错误或警告提示信息的是（）。

(A) byte b=256；（B）double d=89L； (C) char c=”a”； (D) short s=8.6；

5.以下选项中能正确表示Java语言中的一个整型常量的是（）。 (A) 35.d (B) -20 (C) 1,234 (4) “123”

6.下面的数据类型（）是float型。

(A) 33.8 (B) 129 (C) 89L (D) 8.6F

7.以下的变量定义中，合法的语句是（）。

(A) float l_variable=3.4； (B) int abc_=21； (C) double a=1+4e2.5； (D) short do=15；

8.以下语句输出的没有编译错误的是（）。

(A) int i=7.8； (B) float f=7.8； (C) Boolean b=l； (D) String str=null；

9.以下赋值语句，错误的是（）。

(A) char c1=?\\””； (B) char c3=?x?； (C) char c4=??； (D) char c5=65；

10.定义变量如下： char c=?w?； int i=8； long L=15；

float f=8.9;

以下赋值语句正确的是（）。

(A) i=c+i； (B) c=c+i；（C）L=f+L； (D) f=i+L+f;

11．定义变量如下：

int i=18; long L=5; float f=9.8f; double d=1.2;

String s=”123”;

以下赋值语句正确的是（）。

(A) s=s+i; (B) f=L+i; (C) L=f+i; (D) s=s+i+f+d;

12.下面关于float数的定义正确的是（）。

(A) float f= -5; (B) f=1.0; (C) L=0x0678 (D) s=7.8f;

13.以下语句输出的结果是（）。

String str=”123”；

int x=4,y=5; str=str+x+y;

System.out.println(str);

(A) 1239 (B) 12345 (C) 会产生编译错误 (D) 123+4+5

1.以下选项中变量均已正确定义，合法的赋值语句是（）。 (A) a= =1; (B) ++i; (C) a=a+1=5; (D) y=int(i);

2.以下选项中变量均已正确定义，错误的赋值语句是（）。

(A) i--; (B) i+=7; (C) k+=x+2; (D) y+x=z;

3.设x为int型变量，则执行以下语句段后，x的值为（）。 x=10;

x+=x-=x-x;

(A) 10 (B) 20 (C) 40 (D) 30

4.若有定义int a=2,则执行完语句a-=a*a;后，a的值是（）。 (A) 0 (V) 4 (C) -2 (D) -4

5.若以下变量均已正确定义并赋值，下面符合Java语言语法的表达式是（）。 (A) a=a≤7 （B）a=7+b+c (C) int 12.3%4 (D) a=a+7=c+b

6.定义整型变量：int n=456; ,表达式的值为5的是（）。

(A) n/10 (n/10) (B) (n-n/100*100)/10 (C) n (D) n/10

7.对下面的语句序列正确的说法是（）。

int c=?A?/3; c+=?1?%5;

System.out.println(c);

(A) 产生编译错误 (B) 输出结果25 (C) 输出结果21 (D) 输出结果2

8.若所有变量都已正确定义，以下选项中，符合Java语言语法的表达式是（）。 (A) a!=4||b==1 (B) ?a?%3 (C) ?a?= =1/2 (D) ?A?+32

9.执行下列程序段后，b、x、y的值正确的是（）。 int x=6,y=8; boolean b;

b=x

(A) true，6，8 (B) false，7，7 (C) true，7，7 (D) flase，6，8

10．下列的程序输出的结果是（）。 public class Class1 {

public static void main(String[] args) {

System.out.println(5^2); }

}

(A) 7 (B) 8 (C) 2 (D) 6

11.下列程序段后，t5的结果是（）。 int t1=5, t2=6,t3=7,t4,t5;

t4=t1

(A) 5 (B) 6 (C) 7 (D) 以上都不对

12.若a和b均是整型变量并已正确赋值，正确的switch语句是（）。 (A) switch(a+1) (B) switch(a*a+b*b); {??} {??} (C) switch a (D) switch[a+b] {??} {??}

13.下列语句序列执行后，k的值是（）。 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) 0 (C) 15 (D) -2

14．下列语句序列执行后，r的值是（）。 int x=5,y=10,r=5; switch(x+y) {

case 15: r+=x; case 20: r-=y; case 25: r*=x/y; default: r+=r;

}

(A) 15 (B) 10 (C) 0 (D) 20

15.下列语句序列执行后，j的值是（）。 int j=9,i=6;

while(- -i!=3) j=j+2;

(A) 9 (B) 11 (C) 13 (D) 15

16.下面的while 循环执行的次数是（）。

int i=3;

while (++i<6) i+=2;

(A) 1 (B) 2 (C) 3 (D) 4

17.设变量k已定义，以下由while语句构成的循环执行的次数是（）。 While (true) k++;

(A) 无限次 (B) 有语法错误，不能执行 (C) 一次也不执行 (D) 执行一次

18.下列语句序列执行后，j的值是（）。 int j=9,i=6;

while (i--> 3) - -j;

(A) 5 (B) 6 (C) 7 (D) 8

19.下列语句序列执行后，i的值是（）。 int i=0;

do { i+=3;} while(i<10);

(A) 3 (B) 6 (C) 9 (D) 12

20.以下由do-while语句构成的循环执行的次数是（）。 int k=0;

do {++k; } while(k<1);

（A）无限次 (B) 有语法错，不能执行 (C) 一次也不执行（D）执行1次

21.下列语句序列执行后，i的值是（）。 int i=2;

do { i*=i;} while (i<16);

(A) 4 (B) 8 (C) 16 (D) 32

22.下列语句序列执行后，j的值是（）。 int j=0;

for (int i=1;i<6;i=i+2) j+=i;

(A) 9 (B) 10 (C) 11 (D) 12

23.下列语句序列执行后，j的值是（）。

int j=0;

for (int i=5;i>0&j<10; i- -) j+=i;

（A）9 (B) 10 (C) 11 (D) 12

24.能从循环语句的循环体中跳出的语句是（）。

(A) for语句 (B) break语句 (C) while语句 (D) continue语句

25．执行完下面的程序段后，k的值是（）。

int k=0;

label: for(int i=1;i<3;i++) {

for(int j=1; j<3; j++) {

k+=i+j;

System.out.println(k); if(i= =2)

continue label; }

}

(A) 3 (B) 5 (C) 8 (D) 12

26.下列方法x的定义中，正确的是（）。

(A) int x() { char ch=?a?; return (int)ch; (B) void x {??}

27.下列方法定义中，方法头不正确的是（）。

(A) public int x() {??} (B) public static int x(double y) {??}

28．若已定义：int a[]={0,1,2,3,4,5,6,7,8,9}；则对a数组元素正确的引用是（）。

(A) a[-3] (B) a[9] (C) a[10] (D) a(0)

29．下面的程序段输出的结果是（）。

int i=1,b,c;

int [] a=new int[3];//数组没初始化数族元素默认值为0

b=a[i]; c=b+i;

System.out.println(c);

(A) 0 (B) 2 (C) 1 (D) 4

30．设有定义语句int a[]={66,88,99};则以下对此语句的叙述错误的是（）。

（A）定义了一个名为a的一维数组

(B) a数组有3个元素 (C) a数组的下标为1~3 (D) 数组中的每个元素是整型

31．下面是在命令行运行Java应用程序A: java A the first snow ， the first snow came. 怎样才能在main(String args[])方法中访问单词”first”（）。

(A) args[0] (B) args[1] (C) args[2] (D) args[5]

1. 面向对象程序设计的基本特征是（）。

(A) 抽象 (B) 封装 (C) 继承 (D) 多态

2．下面( )是面向对象编程中对象的特征。

(A) 对象的状态 (B) 对象的行为 (C)对象的标识 (D) 以上都不对

3.下面关于类的说法正确的是( )。

(A) 类是Java语言中的一种复合数据类型 (B)类中包含数据变量和方法

(C)类是对所有具有一定共性的对象的抽象 (D) Java语言的类只支持单继承

4.能作为类及其成员的修饰符是（）。protected和private可以修饰内部类

(A) interface (B) class (C) protected (D) public

5.定义类头可以使用的访问控制符是（）。

(A) private (B) protected (C)public (D) 缺省的，即没有访问控制符

6.有一个类A，对于其构造函数的声明正确的是（）。 (A) void A(int x) {??} (B) A(int x) {??} (C) A A(int x) {??} (D) int A(int x) {??}

7.设X为已定义的类名，下列声明对象x1的语句正确的是（）。 (A) static X x1; (B) private X x1=new X(); (C)abstract X x1; (D) final X x1=new X(); 注：变量不可用abstract修饰

8.设已经声明了一个类A的两个对象a1、a2，为了初始化a1和a2，下面语句正确的是( )。

(A) a1,a2=new A(); (B) a1=A.new(); a2=A.new(); (C)a1=new();a2=new(); (D) a1=new A(); a2=new A();

9.现有两个类A、B，以下描述中表示B继承自A的是( )。 (A)class A extends B (B) class B implements A (C) class A implements (D) class B extends A

10.下面是有关子类调用父类构造函数的描述正确的是（）。 (A) 子类定义了自己的构造函数，就不会调用父类的构造函数 (B) 子类必须通过super关键字调用父类的构造函数

(C)如果子类的构造没有通过super调用父类构造函数，那么子类会先调用父类不含参数的构造函数，再调用子类自己的构造函数。

(D) 创建子类的对象时，先调用子类自己的构造函数，然后调用父类的构造函数。

11.定义类B和类C如下，并将其保存为:B.java，编译B.java，得到的结果是（）。 class B {

int b; B(int i) {b=i;}

}

class C extends B {

double c=7.8; }

(A) 代码能够成功编译并运行

(B) 代码无法编译，因为类B不是一个应用程序或小程序 (C)代码无法编译，因为类B没有定义不带参数的构造器

(D) 代码无法编译，因为类C没有定义一个不带参数的构造器

12.设类B是类C的父类，下列声明对象x1的语句中不正确的是（）。 (A) B x1=new B(); (B) B x1=new C(); (C)C x1=new C(); (D) C x1=new B();

13.设x、y均为已定义的类名，下列声明对象x1的语句中不可能的是（）。 (A) public x x1=new y(); (B) x x1=x();

(C)x x1=new x(); (D) public y x1=new x();

14.编译运行下面的程序，结果是（）。 public class A {

public static void main(String[] args) {

B b=new B(); b.test(); }

void test() {

System.out.print(“A”);

}

class B extends A

{

void test() {

super.test();

System.out.println(“B”); } }

(A) 产生编译错误

(B) 代码可以编译运行，并输出结果：AB (C)代码可以编译运行，但没有输出

(D)编译没有错误，但会产生运行时异常

15.为了区分重载多态中同名的不同方法，要求（）。 (A)采用不同的形式参数列表 (B) 返回值类型不同

16.在下面指定位置添加（）选项中定义的方法，编译时会产生错误。 public class C extends B {

//此处添加选项中的方法 }

class B {

public float getNum() {

return 1.0f; } }

(A) public float getNum() { return 4.0f;}

(B) public double getNum(float D) { return 3.0f;} (C) public void getNum(double D) { } (D) public void getNum() { }

17.定义类A如下，下面( )是对构造函数的正确重载。 class A {

int a,b,c;

public A(int x,int y,int z)

{

a=x;b=;c=z; } }

(A) public A() { a=0;b=0;c=0;}

(B) public A(int x,int y,byte z) { a=x;b=y;c=z;} (C) public A(int x,int y,float z) { a=x;b=y;c=(int)z;} (D) public void A() { a=0;b=0;c=0;}

18.定义类A及类中的方法setVar(),下面（）是对该方法的重载。 public class A {

public void setVar(int a,int b,float c) {??} }

(A) protected float setVar(int a,int b,float c) {return c;} (B) protected void setVar(int a,int b,float c) { }

19.有如下类定义，对于类B中的变量a增加修饰符，下面（）是合法的。

public class B {

int a=8;

public B(int i) {a=i;}

}

(A)public (B) private (C) static (D) abstract

20.下面（）修饰符所定义的方法必须被子类所覆盖。

(A) final (B) abstract (C) static (D) volatile

21.下面（）修饰符所定义的方法不能被子类所覆盖。

(A) final (B) abstract (C) static (D) volatile

22.下面（）陈述是不对的。

(A) 一个实例方法可以同时为protected和abstract类型 (B) static 变量也可以是final类型 (C) static 方法也可以是protected类型 (D) final方法也可以是abstract类型

23.定义两个类如下，如果编译类B和类C时，得到的结果是（）。

abstract class B {

abstract void show(); }

abstract class C extends B { }

(A) 类B和类C都可成功地编译 (B) 类B和类C都不能编译

24.下面关于抽象方法的定义（）是合法的。 (A) public abstract method();

(B) public abstract void method(); (C) public void abstract method();

(D) public abstract void method(); { }

25.编译并运行下面的程序，产生的结果是（）。 public class A {

int a1=1; int a2;

public static void main(String[] args) {

int a3=2; A a=new A();

System.out.println(“Result=”+a.a1+a.a2+a3);

}

(A) Result=3 (B) Result=102;

(D) 不会产生编译错误，但也没有结果输出

//局部变量要初始化，成员变量默认初始化了并把0赋给他 26.定义一个包的关键字是（）。

(A) import (B) package (C) interface (D) protected

27下列选项中，用于在程序开头引入包的关键字是（）。

(A) import (B) implements (C) integer (D) protected

28.下面( )说法正确。

(A) 如果某公共的接口被声明在一个源文件中，则接口必须与源文件具有相同的名字

(B) 如果源文件包含import语句，则该语句必须是除空行和注释行外的第一个语句行

(D) 接口中的方法必定是抽象方法，但可以不用关键字abstract修饰

29.下面（）是Java语言的所有类的祖先类（基类）。

(A) Object (B) Double (C) Integer (D) package

30．以下语句输出的结果是（）。

System.out.println(Math.floor(-0.8)); //floor（）是取＜=括号中的整数

(A) 0 (B) -1 (C) -0.8 (D) 0.8

31.下面的程序段执行后，变量a、b、c的值分别是（）。 int a,b,c;

a=(int)Math.round(-4.51);//round四舍五入 b=(int)Math.ceil(-4.51);//ceil c=(int)Math.floor(-4.1);

(A) -5, -4, -5 (B) -4,-4,-5 (C) -5,-5,-5 (D) -4,-4,-4

32.定义字符串s:String s=”Microsoft公司”；执行下面的语句，c的值为（）。 char c=s.charAt(9);

(A) 产生数组下标越界异常 (B) 司 (C) null (D)公

33．以下语句执行后输出的结果是（）。 String s0=new String(“hello,Java!”);

System.out.println(s0.length());

(A) 10 (B) 11 (C) 9 (D) 15

34．定义字符串：String s1=”hello”；下面的程序段输出的结果是（）。 if(s1.equals(“hello”))

System.out.println(“s1 equals\\”hello\\””); else

System.out.println(“s1 does not equals\\”hello\\””);

(A) “s1 equals\\”hello\\”” (B) “s1 does not equals\\”hello\\”” (C) s1 equals”hello” (D) s1 does not equals\\”hello\\”

35.下面的程序段输出的结果是（）。 String s1=”Java”,s2=”java”;

System.out.println(s1.equalsIgnoreCase(s2));

(A) true (B) false (C) Java (D) java

36.下面的程序段输出的结果是（）。 String s1=”Abc”, s2=”Bcd”;

System.out.println(s1.compareTo(s2));

(A) -1 (B) 1 (C) false (D)true

37.下面的程序段执行完后，cont的值是（）。

String strings[]={“string”,”starting”,”strong”,”street”,”soft”}; int cont=0;

for (int i=0;i

if(Strings[i].endsWith(“ng”)) cont++;

(A) 1 (B) 2 (C) 3 (D) 4

38.定义字符串：String str=”abcdefg”;则str.indexOf(‘d’)的结果是（）。 (A) ?d? (B) true (C) 3 (D) 4

39.定义变量b: boolean b=true;则String.valueOf(b)的类型是（）。 (A) boolean (B) String (C) false (D) int

40.下面的程序段输出的结果是（）。 StringBuffer buf1=new StringBuffer(20);

System.out.println(buf1.length()+”,”+buf1.capacity());

(A) 0,20 (B) 0,null (C) 20,20 (D) 0,0

41.下面的程序段输出的结果是（）。 StringBuffer buf1;

String str=”北京2008”； buf1=new StringBuffer(str);

System.out.println(buf1.charAt(2));

(A) 2 (B) 京 (C) 0 (D) null

42.下面的程序段输出的结果是（）。 StringBuffer buf1;

String str=”007beijing”； buf1=new StringBuffer(str); buf1.setChar(0,?6?);

System.out.println(buf1.toString());

(A) 007bei0jing (B) 007beijing (C) 607beijing (D) 667beijing

43.下面的语句序列的输出结果为（）。 String s=”ABCD”； s.concat(“E”); s.replace(?C?,?F?); System.out.println(s);

(A) ABCDEF (B) ABFDE (C) ABCDE (D) ABCD

44.下面这些选项中（）能够定义一个长度为50的字符串。 (A) String a=new String[50]; (B) String a[] (C) String[] a; (D) String a[50];

45.下面的语句序列执行完后，n的值是（）。 int n=0;

StringTokenizer st=new StringTokenizer(“I wonder shoud I go,or should I stay?”);

while (st.hasMoreTokens()) { n++; }

(A) 9 (B) 10 (C) 11 (D)12

1. FlowLayout的默认对齐方式是（）

a．CENTER b. LEFT c.RIGHT d. 使用时定义

2. 关于布局管理器，以下说法正确的是：（）

a. FlowLayout在布局处理时使用了硬性编码的方式

b. FlowLayout和CardLayout都是布局管理器 c. Button是一个布局管理器

d. FlowLayout和BorderLayout是同一个布局管理器

3. 下面哪个类不是从Container继承的？( )

a. Panel b. Dialog c. Button

d. Java.applet.Applet

4. 以下类中不从Component派生的是：（）

a． Canvas b． Container

c． Label d． Menu

5. 以下说法正确的是：（）

a． java net包中包含了java awt包。

b． “import java awt.*”表示使用一个java.awt包中名称为“*”的类。 c． Java的import关键字用来通知编译器当前正在编写一个数据输入类。 d． Java lang包被隐式包含到所有程序中。

6.下列哪种java组件为容器组件？（） (A) List列表框

(B) Choice下拉列表框 (C) Panel面板

(D) MenuItem命令式菜单项

1.那些类可以用来实现TCP/IP客户服务器程序（）。

(A) ServerSocket (B) Server (C) Socket

(D) DatagramPacket

(E) DatagramSocket

1. 下面关于线程的说法正确的是（）。 (A) Java支持多线程机制

(B) 一个线程创建并启动后，它将执行自己的run()方法，如果通过派生Thread类实现多线程，则需要在子类中重新定义run()方法，把需要执行的代码写入run()方法中；如果通过实现Runnable接口实现多线程，则需要编写接口中的抽象方法——run()方法的

方法体。

2. 如果程序中创建了两个线程，一个优先级是Thread.MAX_PRIORITY，另一个的

优先级是正常的默认优先级，下列陈述（）是对的。

(A) 正常优先级的线程不运行，直到拥有最高优先级的线程停止运行 (B) 即使拥有最高优先级的线程结束运行，正常优先级的线程也不会运行 (C) 正常优先级的线程运行（D）上述说法都不对

3. 在（）可以设置线程的优先级别。 (A) 当第一次创建线程时 (B) 创建线程的任何时间

4. 下面（）是Runnable接口中的抽象方法。 (A) start (B) stop (C) yield (D)run

5. 编译下面的程序，得到的结果是（）。 public class A implements Runnable {

public void run() {

System.out.println(“OK.”); }

public static void main(String[] args) {

Thread Th=new Thread(new A()); } }

(A) 程序不能编译，产生异常

(B) 程序能编译运行，但没有任何结果输出 (C) 程序能编译运行，输出结果：OK (D) 以上说法都不对

6.关于下面的程序，说法正确的是（）。 public class A implements Runnable {

public static void main(String args[]) {

A a=new A();

Thread t=new Thread(a); t.satrt(); }

public void run() {

while(true) {

Thread.currentThread().sleep(1000); System.out.println(“looping while”); } }

}

(A) 程序编译通不过，因为sleep()方法抛出InterruptedException异常，应该方法的调用语句放到try块中，并捕获异常

(B) 程序能编译运行，在屏幕上重复输出“looping while” (C) 程序能编译运行，在屏幕上输出一次“looping while” (D) 程序能编译运行，但没有结果输出

7.一个正在执行的线程遇到下列（）情况时会暂时停止执行。 (A) 休眠 (B) 执行suspend被挂起 (C) 执行输入输出操作 (D) 执行wait()方法

8.一个正在执行的线程在遇到（）情况时会终止执行。

(A) 其run()方法运行完后 (B) 执行sleep()方法后 (C) 执行其stop()方法 (D) 执行wait()方法

9．关于线程的说法不正确的是（）。

(A) 因为休眠而暂时停止运行的线程，休眠时间到了后立即直接运行 (B) 线程执行wait()方法后，必须调用notify()方法唤醒它

(D) 挂起、休眠或等待的线程都可恢复到可运行状态，但停止运行的线程将不能再重新运行异常，即停止运行的线程将不能再重新运行

10.为什么处于激活状态的线程可能不是当前正在执行的线程（）。 (A) 因为已经执行完run()方法 (B) 线程正在等待键盘输入 (C) 该线程调用了wait()方法 (D) 该线程正在休眠状态

11．以下（）情况下会造成一个线程停止运行。

(A) 调用了start()方法 (B) 另一个级别更高的线程就绪 (C) 调用了线程类的stop()方法 (D) 在程序中调用了exit(0)

12.下面（）方法不会使线程停止运行。

(A) sleep(); (B) stop(); (C) notify(); (D)notify All();

13.关于下面的程序说法正确的是（）。 public class A implements Runnable {

public void run(Thread t) {

System.out.println(“OK.”); }

public static void main(String[] args) {

Thread Th=new Thread(this);

Th.start();

} }

(A) 程序能编译运行，输出结果:OK.

(B) 程序编译不能通过，因为没有实现Runnable接口中的run()方法

(D) 在main()方法中语句：Thread Th=new Thread(this);不能通过this引用，因为main()是静态方法，静态方法不能通过this引用。

14.下面的说法正确的是（）。

(A) 调用sleep()的语句应放到try块中

(B) sleep()方法只有一个参数，参数类型为整型，表示休眠的秒数 (C) sleep()方法只有一个参数，参数类型为整型，表示休眠的毫秒数 (D) sleep()方法是静态方法

15.下面的方法（）被Java2推荐使用以使用线程阻塞。 (A) sleep(); (B) suspend (C)wait/ notify(); (D)stop

1. 为了捕获一个异常，代码必须放在下面（）语句块中。

(A) try块 (B) catch块 (C) throws块（D）finally块

2．下面关于try块的说法正确的是（）。 (A) try块后至少应有一个catch块 (B)try块后必须有finally块

3．finally块中的代码将（）。 (A) 总是被执行

(B) 如果try块后面没有catch块时，finally块中的代码才会执行 (C)异常发生时才被执行

(D)异常没有发生时才被执行

4.一个异常将终止（）。

(A) 整个程序 (B) 只终止抛出异常的方法 (C) 产生异常的try块 (D)以上说法都不对

5.阅读下面的程序，选择正确的说法（）。 class A {

public static void main(String args[]) throws Exception {

method(); }

static void method() throws Exception { try {

System.out.print(“try:performed\\t”); } finally

{

System.out.print(“finally:always performed”); } }

}

(A) 编译该程序会显示产生编译错误，因为method()抛出异常，而调用它时没有进行处理

(B) 程序编译成功，运行该程序输出：try:performed finally:always performed (C) 程序编译成功，运行该程序输出：try:performed (D) 程序编译成功，运行该程序输出：try:always performed 6.阅读下面的程序，关于该程序的说法错误的是（）。 public class A {

public static void main(String[] args)

{

int index=3;

Boolean[] test=new Boolean[3]; Boolean b=!test[index];

System.out.println(b);

}

(A) 程序没有编译错误

(B) 程序没有编译错误，但会产生运行时错误 (C) b的值是false (D) b的值是null

本文来源：https://www.bwwdw.com/article/mfvv.html

相关文章：