一、选择题
1.下面程序的运行结果是
int i=0;
while(true){
if(i++>10) break;
System.out.println(i);
}
1-11
2.下面程序的运行结果是
int a=2;
switch(a){
case 1: a+=1;break;
case 2: a+=2;
case 3: a+=3; break;
case 4: a+=4; break;
default : a=0;
}
System.out.println(a);
}
3.下面程序的运行结果是
public class J_Test {
static boolean mb_fun(char c){
System.out.println(c);
return true;
}
public static void main(String[] args) {
int i=0;
for(mb_fun(‘A’);mb_fun(‘B’)&&(i<2);mb_fun(‘C’)){
i++;
mb_fun(‘D’);
}
}
}
ABDCBDCB
4.下面哪些单词不是JAVA的关键字( )
A sizeof B abstract C null D String
5.下面哪个语句不会产生编译错误( )
A float a=2.0; B char c=”a”;
C byte b=25; D boolean d=null;
6.下面哪些语句可以通过编译( )
A float a=1; B float b=1.0;
C float c=2elf; D float d=0×1234;
7.下面程序的运行结果是
int a=3, b=1;
if(a==b) System.out.println(“a=”+a);
A a=1 B a=3
C 编译错误 D 正常运行但没有输出
8.下面程序的运行结果是
int a=1,b=2;
int c=(a+b>3?a++:++b);
A a=2,b=3 B a=1,b=3
C a=1,b=2 D c=false
9.下面程序的运行结果
public class J_Test {
public static int mb_fun(int c){
return (c%2);
}
public static void main(String[] args) {
if(mb_fun(3))
System.out.println(“1″);
else System.out.println(“2″);
} }
A 1 B 2 C 编译错误 D 运行时错误
10.当整数变量值为多少时，会输出” message 2″
switch(i){
Case 1: System.out.println(“Message1″);
case 2:
Case 3: System.out.println(“Message2″);
break;
}
A 0 B 1 C 2 D 3 E 4
11.下面程序的运行结果，哪个是正确的
byte b=1;
while(++b>0)
;
System.out.println(“LOOP”);
A 运行程序将会进入死循环导致无输出
B 每运行一次程序则输出一次LOOP并退出
C 每运行一次程序，会输出多次LOOP
D 程序中含有编译错误
12.写出下面程序的运行结果
public class J_SuperClass {
J_SuperClass(){
System.out.println(“J_SuperClass”);
} }
Class J_SubClass extends J_SuperClass{
J_SubClass(){
System.out.println(“J_SubClass”);}
Public static void main(String args[]){
new J_SubClass();
} }
J_SuperClass
J_SubClass
13.写出下面程序的运行结果
public class J_Base {
public void mb_method(){
System.out.println(“Base”);
} }
Public class J_Test extends J_Base{
public void mb_method(){
System.out.println(“Test”);
}
public static void main(String[] args) {
Object a=new J_Test();
((J_Base)a).mb_method();
} }
Test
14.下面的程序输出是：
public class J_SuperClass {
public void mb_method() {
System.out.println(“J_SuperClass::mb_method”);
}
static void mb_methodStatic(){
System.out.println(“J_SuperClass::mb_methodStatic”);
} }
public class J_Test extends J_SuperClass{
void mb_method(){
System.out.println(“J_Test::mb_method”);
}
Static void mb_methodStatic(){
System.out.println(“J_Test::mb_methodStatic”);
}
Public static void main(String args[]){
J_SuperClass a=new J_Test();
a.mb_method();
a.mb_methodStatic();
J_Test b=new J_Test();
b.mb_method();
b.mb_methodStatic();
} }
15.下面程序输出的结果：
public class J_Test{
static int m_data =0;
public int mb_method(){
m_data++;
return m_data;
}
public static void main(String args[]){
J_Test a=new J_Test();
J_Test b=new J_Test();
J_Test c=new J_Test();
a.mb_method();
b.mb_method();
c.mb_method();
int i=a.mb_method();
System.out.println(i);
} }
16.关于下面程序，哪些结论是正确的
public class J_Test{
public J_Test(){
System.out.println(“2″);
}
public static void main(String args[]){
J_Test s=new J_Test();
s.J_Test();
System.out.print(“1″);
} }
A 程序可以通过编译并正常运行，结果输出21；
B 程序可以通过编译并正常运行，结果输出221
C程序无法通过编译
D 程序可以通过编译，但无法正常运行
17.关于下面程序，哪些结论是正确的
public class J_Super {
public int m_dataSuper;
public J_Super(int d) {
m_dataSuper = d;
} }
Public class J_Test extends J_Super {
public int m_data;
public J_Test(int ds, int d) {
m_data = d;
super(ds);
}
public static void main(String args[]) {
J_Test s = new J_Test(2, 3);
System.out.println(s.m_data + s.m_dataSuper);
} }
A 程序可以通过编译度正常运行，输出5
B 程序可以通过编译并正常运行，输出23
C 程序无法通过编译，没有输出
D 程序可以通过编译，但无法正常运行
18.关于下面的程序，哪些结论是正确的
public class J_Super {
public J_Super() {
System.out.println(“1″);
} }
public class J_Sub extends J_Super {
public J_Sub() {
System.out.println(“2″);
} }
public class J_Test extends J_Sub{
public J_Test (){
super.super();
System.out.println(“3″);
}
public static void main(String args[]) {
J_Test s = new J_Test();
} }
A 程序可以编译并正常运行，结果为123
B 程序可以编译并正常运行，结果为13
C 程序可以编译并正常运行，结果为213
D 程序无法编译
19.关于下面程序的结论，哪些结论是正确的
class J_SubClass extends J_Test{ }
public class J_Test{
J_Test(int i) {
System.out.println(i);
}
public static void main(String args[]){
J_SubClass a=new J_SubClass();
} }
A 不能通过编译，因为类J_Test没有定义无参的构造方法
B 不能通过编译，因为类J_SubClass没有定义无参的构造方法
C 不能通过编译，没有实现J_SubClass(int i)构造方法
D可以成功通过编译
20.下面的程序输出什么
public class J_Test{
int m_i=2;
String m_s=null;
public J_Test() {
m_i=3;
m_s=”constructor”;
}
public static void main(String args[]){
J_Test app=new J_Test();
System.out.println(app.m_i+app.m_s);
} }
A 3null B 3constructor
C 2constructor D 2null
21. 关于JAVA的垃圾回收机制，下面哪些结论是正确的
A 程序可以任意指定释放内存的时间
B JAVA程序不能依赖于垃圾回收的时间或者顺序
C 程序可明确地标识某个局部变量的引用不再被使用
D 程序可以显式地立即释放对象占有的内存
22.下面程序的运行结果正确的是
class J_Class {
public int m_data=3;
}
public class J_Test{
public static void main(String args[]){
Object a=(Object)new J_Class();
J_Class b=(J_Class)a;
System.out.println(“data=”+b.m_data);
} }
A 能编译，结果输出data=3
B 不能编译
C Object a=(Object)new J_Class();会抛出一个异常
D J_Class b=(J_Class)a会抛出一个异常
23.关于下面程序，哪个结论是正确的
class J_SuperClass { }
public class J_SubClass extends J_SuperClass{
public static void main(String args[]){
J_SuperClass a=new J_SuperClass();
J_SubClass b=new J_SubClass();
b=(J_SubClass)a;
} }
A 无法通过编译，因为没有构造方法
B 可以通过编译，但在运行时将出错
C 可以通过编译，也可以正常运行
D 无法通过编译，b=(J_SubClass)a错误
24.下面程序在指定位置插入哪句会导致程序输出“sub”
class J_Base{ }
class J_SubClass extends J_Base{
public String mb_getString(){
return “sub”;
}
public static void main(String args[]){
J_Base app=new J_SubClass();
//插入需要的语句
} }
A System.out.println(app.mb_getString());
B System.out.println((J_Base)app.mb_getString());
C System.out.println((J_SubClass)app.mb_getString());
D System.out.println(((J_SubClass)app).mb_getString());
25.下面程序在指定位置插入哪句会导致程序输出“sub”
class J_Base{
public String mb_getString(){
return “Base”;
} }
class J_SubClass extends J_Base{
public String mb_getString(){
return “sub”;
}
public static void main(String args[]){
J_Base app=new J_SubClass();
//插入需要的语句
} }
A System.out.println(app.mb_getString());
B System.out.println((J_Base)app.mb_getString());
C System.out.println((J_SubClass)app.mb_getString());
D System.out.println(((J_SubClass)app).mb_getString());
26.下面程序的正确结论是
class J_Base{ }
class J_SubClass extends J_Base{
public String mb_getString(){
return “sub”;
}
public static void main(String args[]){
J_SubClass app=(J_SubClass)new J_Base();
System.out.println(((J_SubClass)app).mb_getString());
} }
A 发生编译错误
B 能编译但不能运行
C 能编译能运行，输出sub
D ((J_SubClass)app).mb_getString() 是不正确的语法
27.下面程序的输出结果是
class J_Base{
public int m_data=5;
public void mb_print(){
System.out.print(m_data);
} }
class J_SubClass extends J_Base{
public int m_data=2;
public void mb_print(){
System.out.print(m_data);
}
public static void main(String args[]){
J_Base app=new J_SubClass();
app.mb_print();
System.out.println(app.m_data);
} }
A 22 B 55 C 25 D 52
28.下面哪些方法置于指定位置会导致编译错误
public class J_Super {
public float getNum(){
return 3.0f;
} }
public class J_Sub extends J_Super{
//指定位置
}
A public float getNum(){return 4.0f;}
B public void getNum(){}
C public void getNum(double d){}
D public double getNum(float d){return 4.0d; }
29.已知字母a和b对应的数值分别是97和98,关于下面程序哪些选项是正确
public class J_Test {
static char m_name;
static int m_age;
public static void mb_setData(char n){
m_name=n;
}
public static void mb_setData(int age){
m_age=age;
}
public static void main(String[] args) {
mb_setData((int)’a');
mb_setData((char)98);
System.out.println(m_name+” “+m_age);
} }
A 结果输出 a 98 B 结果输出 b 97
C 结果输出 b 98 D 结果输出a 97
30.下面程序哪些结论是正确的
public class J_Test {
static short m_index;
static int m_age;
public static void mb_setData(short n){
m_index=n;
}
public static void mb_setData(int age){
m_age=age;
}
public static void main(String[] args) {
mb_setData(98);
System.out.println(m_index+” “+m_age);
} }
A 结果输出 98 0 B结果输出0 98
C 结果输出 0 0 D 结果输出98 98
E 程序编译错误
31.下面程序哪些结论是正确的
public class J_Test {
static short m_index;
static int m_age;
public static void mb_setData(short n){
m_index=n;
}
public static void main(String[] args) {
mb_setData(98);
System.out.println(m_index+” “+m_age);
} }
A 结果输出 98 0 B结果输出0 98
C 结果输出 0 0 D 结果输出98 98
E 程序编译错误