阅读下列代码段 class TestimplementsRunnable{ publicintrun(){ inti=0； while(true){ i++； System.out.println("i="+1)； } } } 上述代码的编译结果是( )。A．程序通过编译并且run()方法可以正常输出递增的i值B．程序通过编译，调用run()方法将不显示任何输出C．程序不能通过编译，因为while的循环控制条件不能为“true”D．程序不能通过编译，因为run()方法的返向值类型不是void

阅读下列代码段

Class Test implements Runnable {

Public int run( ) {

Int i = 0;

While (true) {

i++;

System.out.println ( “ i= ” +i);

}

}

}

上述代码的编译结果是

A ）程序通过编译并且 run () 方法可以正常输出递增的 i 值

B ）程序通过编译，调用 run () 方法将不显示任何输出

C ）程序不能通过编译，因为 while 的循环控制条件不能为 “ true ”

D ）程序不能通过编译，因为 run () 方法的返回值类型不是 void

A.输出：***

B.输出：$$$

C.有语法错误不能通过编译

D.可以通过编译,但不能通过连接

阅读下面代码 class Test implements Runnable { public int run() { int i=0； while(true) { i++; System.out.println("i="+i)； } } } 上述代码的编译结果是

A．程序通过编译，并且run()方法可以正常输出递增的i值

B．程序通过编译，调用run()方法将不显示任何输出

C．程序不能通过编译，因为while的循环控制条件不能为true

D．程序不能通过编译，因为run()方法的返回值类型不是void

阅读下面程序 class Test implements Runnable { public static void main(String[] args) { Test t=new Test()； t.start()： } public void run() {} } 下列关于上述程序的叙述正确的是

A．程序不能通过编译，因为start()方法在Test类中没有定义

B．程序编译通过，但运行时出错，提示start()方法没有定义

C．程序不能通过编译，因为run()方法没有定义方法体

D．程序编译通过，且运行正常

关于以下程序代码的说明正确的是 ( )(1)class HasStatic{(2)private static int x=100；(3)public static void main(String args[]){(4)HasStatic hs1=new HasStatic()；(5)hs1.x++；(6)HasStatic hs2=new HasStatic()；(7)hs2.x++；(8)hs1=new HasStatic()；(9)hs1.x++；(10)System.out.println("x="+x)；(11)}(12)}

A．(5)行不能通过编译，因为引用了私有静态变量

B．(10)行不能通过编译，因为x是私有静态变量

C．程序通过编译，输出结果为：x=103

D．程序通过编译，输出结果为：x=100

阅读下列代码段。 class Test implements Runnable{ public int run{ int i=0： while(true){ i++： System．OUt．println("i="+i)； } } } 上述代码的编译结果是（ ）。

A.程序通过编译并且run方法可以正常输出递增的i值

B.程序通过编译，调用run方法将不显示任何输出

C.程序不能通过编译，因为while的循环控制条件不能为“true”

D.程序不能通过编译，因为run方法的返回值类型不是void

阅读下列代码段。上述代码的编译结果是（ ）。

A.程序通过编译并且run（ ）方法可以正常输出递增的i值

B.程序通过编译，调用run（ ）方法将不显示任何输出

C.程序不能通过编译，因为while的循环控制条件不能为“true”

D.程序不能通过编译，因为run（ ）方法的返回值类型不是void

关于下面程序,( )的结论是正确的。

classJ_SubClassextendsJ_Test{}

publicclassJ_Test{

J_Test(inti){

System.out.println(i);

}

publicstaticvoidmain(String[]args){

J_SubClassa=newJ_SubClass();

}

}

A、不能通过编译,因为类J_Test没有定义无参数的构造方法

B、不能通过编译,因为类J_SubClass没有定义无参数的构造方法

C、不能通过编译,因为没有实现J_SubClass(inti)的构造方法

D、可以成功通过编译

有以下程序 #include＜iostream．h＞ void main( ) { int a=5，b=0，c=0； if(a=b+c) cout＜＜"* * *" ＜＜endl； else cout＜＜"$$$"＜＜endl；} 下列选项叙述正确的是

A．有语法错不能通过编译

B．可以通过编译但不能通过连接

C．输出* * *

D．输出 $ $ $

考虑如下类：

1. class Test(int i) {

2. void test(int i) {

3. System.out.println("I am an int.");

4. }

5. void test(String s) {

6. System.out.println("I am a string.");

7. }

8.

9. public static void main(String args[]) {

10. Test t=new Test();

11. char ch="y";

12. t.test(ch);

13. }

14. }

以下哪条为真?

A.行 5 不能通过编译,方法不能被覆盖.

B.行 12 不能通过编译, 因为没有一个test()方法含字符参数.

C.代码可以编译但在12行将出现异常.

D.代码可以编译且产生如下输出: I am an int.

E.代码可以编译且产生如下输出: I am a String.

A.不能通过编译

B.能正确运行

C.能正确编译

D.输出结果为1

阅读下列程序：class ThreadTest extends Thread{ public static void main(String[]args){ Thread t=new Thread(this)； t.start()； } public void run(){ System.out.print("A thread test．")； }} 对该程序而言，正确结论是 ( )

A．该程序能够通过编译并打印输出“A thread test．”

B．该程序能够通过编译，但运行时将不调用ThreadTest类中的run()方法，因此不产生任何输出

C．该程序存在编译错误，因为在main()方法中不能使用this指针

D．上述选项都不正确

关于以下程序代码的说明正确的是( ) (1) class HasStatic{ (2) private static int x=100： (3) public static void main (String args[]{ (4) HasStatic hs1=new Has Static()； (5) hs1.x + +； (6) Has Static hs2=new HasStatic()； (7) hs2.x + +; (8) hs1=new HasStatic()； (9) hs1.x + +： (10) System.out.println("x="+ x)； (11) } (12) }

A．(5)行不能通过编译，因为引用了私有静态变量

B．(10)行不能通过编译，因为x是私有静态变量

C．程序通过编译，输出结果为：x=103

D．程序通过编译，输出结果为：x=100

下面程序的执行结果是______。 public class ex27 { public static void main(String[] args) { try { return; } finally { System. out. print in ( "Finally" ); } }

A．程序正常运行，并输出Finally

B．程序正常运行，但不输出任何结果

C．编译能通过，但运行时会出现一个异常

D．因为没有catch字句，所以不能通过编译

对于下面一段代码的描述中，正确的是______。 public class ex36 { public static void run main(String[] args) throws Excepion { method(); } static void method() throws Exception try { System.out.println("test"); } finally { System.out.println ("finally"); } } }

A．代码编译成功，输出“test”和“fmally”

B．代码编译成功，输出“test”

C．代码实现选项A中的功能，之后Java停止程序运行，抛出异常，但是不进行处理

D．代码不能编译

给定如下JAVA程序片断下述程序将()。

A.不能通过编译

B.通过编译,输出为:AB

C.通过编译,输出为:B

D.通过编译,输出为:A

当你编译运行下列程序代码，会得到什么结果?

private class Base{ Base(){ int i = 100; System.out.println(i); } }

public class Pri extends Base{ staticint i = 200;

public static void main(String argv[]){ Pri p = new Pri(); System.out.println(i); } }

A.这段代码不能通过编译

B.输出200

C.输出100和200

D.输出100

关于下面程序,( )的结论是正确。

publicclassJ_Test{

publicstaticvoidmain(String[]args){

int[]a=newint[5];

boolean[]b=newboolean[5];

System.out.println(a[4]);

System.out.println(b[5]);

}

}

A、程序可以通过编译并正常运行,结果输出“0false”

B、程序可以通过编译并正常运行,结果输出“1true”

C、程序无法通过编译

D、程序可以通过编译,但无法正常运行

类A及其派生类B定义如下：class A{ public int getInfo(int a) { return a； }}public class B extends A{ public float getInfo(int b) { return b； } public static void main(String[]args) { A a=new A()； B b=new B()； System.out.println(a.getInfo(3)+"，"+b.getInfo(5))； }}关于上述程序代码的叙述中正确的是 ( )

A．第10行不能通过编译

B．程序通过编译，输出结果为:3，3

C．程序通过编译，输出结果为3，5

D．程序通过编译，输出结果为:5，5