全国信息技术应用水平大赛历届经典试题解析

第二届预赛A

2．阅读以下程序，写出输出结果。

class  First{

public  First(){

aMethod();}

public  void  aMethod(){

System.out.println(“in  First  class”);}

}

public  class  Second  extends  First{

public  void  aMethod(){

System.out.println(“in  Second  class”);}

public static void main(String[ ]  args){

new  Second( ); }

}

答案是：In second class  second类继承first second类没有构造函数 程序会自动有一个默认无参构造函数 在这个无参构造函数里面会有默认的super（）调用父类的

构造函数 但是子类又覆写了aMethod（）函数 所以答案是in second class 

1．编写一个Java程序要求：开启一个文本文件，一次读取其内的一行文本。令每一行形成一个String，并将读出的String对象置于LinkedList中。

请以相反次序印出LinkedList内的所有文本行。

import java.io.*;

　　import java.util.*;

　　public class E01_FileIntoList {

　　// Report all exceptions to console:

　　public static void main(String args[])

　　throws Exception {

　　LinkedList lines = new LinkedList();

　　BufferedReader in =

　　new BufferedReader(

　　new FileReader("E01_FileIntoList.java"));

　　String s;

　　while((s = in.readLine())!= null)

　　lines.add(s);

　　in.close();

　　ListIterator it =

　　lines.listIterator(lines.size());//迭代器索引在最后

　　while(it.hasPrevious())

　　System.out.println(it.previous());

　　}

　　}

用链表很容易实现，linkedlist   再用迭代器反向输出 把索引放到最后是 ListIterator it = 　lines.listIterator(lines.size()); 

第二届预赛

（12）编译运行以下程序后，关于输出结果的说明正确的是 （  C  ）

public  class   Conditional{

public  static  void  main(String  args[  ]){

int  x=4;

System.out.println(“value  is  “+ ((x>4) ? 99.9 :9));

}

}

A．输出结果为：value  is  99.99    B．输出结果为：value  is  9

C．输出结果为：value  is  9.0      D．编译错误                 

  三目运算应该是转型向级别高的转化

（13）执行完以下代码int [ ]  x = new int[10]；后，以下哪项说明是正确的（     A    ）

A．x[9]为0 B．x[9]未定义 C．x[10]为0 D．x[0]为空       默认值是0

3、写出以下程序的运行结果。

public class FooDemo{ 

static boolean foo(char c) { 

System.out.print(c); 
  return true; 
 } 
 public static void main(String[] args ) { 
  int i =0; 
  for ( foo(’a’); foo(’b’)&&(i<2); foo(’c’)){ 
  i++ ; 
  foo(’d’); 
    } 
} 

}

abdcbdcb        这个题最容易犯错的是循环的初始化语句就执行一次  所以foo（‘a’）就执行一次   最后执行foo（‘b’）就结束

第三届java预赛

1、 下面是Example.java文件的完整代码，请找出会产生编译错误的行（　　　　）。

１) class BaseClass { 
２) public String str; 
３) public BaseClass(){ 
４) System.out.println(“ok”);} 
５) public BaseClass(String s){ 
６) str=s;}} 
７) class SubClass extends BaseClass{ 
８) }

9) public class Example{ 
10) public void method(){ 
11) SubClass s=new SubClass(“hello”); 
12) BaseClass b=new BaseClass(“world”); 
13) } 
14) } 

A. 7

B. 10

C. 11

D. 12

解答：C         这个题和上面构造函数题类似  subclass 没有构造函数 系统默认是无参构造函数 构造函数里默认有super（），super（）在每一个

子类构造函数里面都有，就是调用父类的构造函数，尽管父类有string构造函数，但是向subclass的默认构造函数传string参数还是会出错，因为

调用的是无参构造函数

30、关于对话框（Dialog）说法错误的是（      ）。

A、对话框是Window类的子类。

B、对话框和一般窗口的区别在于它依赖于其他窗口。

C、对话框分为模式和非模式两种。

D、文件对话框的构造方法：Filedialog fdlg=new FileDialog("filedialog");

解答：D          文件对话框的构造方法没有这种方法  filedialog 都要传入一个frame参数

      35、假定有变量定义: int k=7,x=12; 则能使值为3的表达式是（　　　　　）。

     A、x%=(k%=5)

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

    C、x%=k-k%5

    D、(x%=k)-(k%=5) 

    解答：D             关于%=运算时候不要拆开运算  把%=作为最低运算级  结果就正确了

48、已知A类被打包在packageA , B类被打包在packageB ，且B类被声明为public ，且有一个成员变量x被声明为protected控制方式 。

C类也位于packageA包，且继承了B类 。则以下说法正确的是（      ）。

A、A类的实例不能访问到B类的实例        b类是public所以能访问

B、A类的实例能够访问到B类一个实例的x成员    protected保护的变量包外不能访问

C、C类的实例可以访问到B类一个实例的x成员    继承后肯定能访问

D、C类的实例不能访问到B类的实例            

解答：C

第四届java预赛

11、当类的成员未用访问权限修饰符时，Java认为此成员的访问权限为（      ）。

A. private  B. protected  C.friendly  D.public

解答：C          friendly 和 protected 区别在于  friendly 包外继承也不能访问

27、阅读下列代码后，下列选项说法正确的是（　　　）。

public class Person 

{ 

int arr[]=new int[10]; 

public static void main(String args[]) 

{ 

System.out.println(arr[1]); 

} 

}

A、编译时将产生错误 

B、编译时正确，运行时将产生错误

C、输出零

D、输出空

解答：A       静态方法不能访问实例成员  main方法也不行  只能访问静态成员或者在main方法内声明的实例成员

36、有以下程序段：

class MyThread extends Thread { 

public static void main(String args[]) { 

MyThread t = new MyThread(); 

MyThread s = new MyThread(); 

t.start(); 

System.out.print("one."); 

s.start(); 

System.out.print("two."); 

} 

public void run() { 

System.out.print("Thread"); 

} 

}

则下列选项说法正确的是（     ）。

A、编译失败

B、程序运行结果为：one.Threadtwo.Thread

C、程序运行结果是：one.two.ThreaThread

D、程序运行结果不确定 

解答：D           子线程和主线程执行速度 和 分配的时间片不一样

37、仔细分析下面程序，其正确的输出结果是（     ）。 

publicclass Test1 {   

    

    publicstaticvoid changeStr(String str){   

        str="welcome";   

    }   

    publicstaticvoid main(String[] args) {   

    

        String str="1234";   

        changeStr(str);   

        System.out.println(str);   

    }   

}  

A、welcome

B、welcome1234

C、1234

D、1234welcome

解答：C        string类虽然是引用类 传递是地址传递 但是string类是不可变类  一旦改变内容地址就会改变 所以还是没有改变原来的值 

如果是stringbuilder就会改变

38、编译和运行下面代码后显示的结果是（    ）。

public class Inc{

public static void main(String argv[]){

                Inc inc = new Inc();

                int i =0; 

                inc.fermin(i);

                i = i++;         //   分两步进行 i++ i值增1但是i++的值是0 所以最后i最后等于零

                System.out.println(i);

        }

        void fermin(int i){

                i++;

        }

} 

A、编译报错误 

B、2 

C、1 

D、0 

解答：D    这个题在网上搜了很多版本  各有各解释 而且难懂  其中有一种说法挺合理而且容易理解 ，以前书上总是说j=i++；先赋值再++ 

这种说法就不能解释++运算级大于=，如果换一种说法就是：i先++，然后i++表达式赋值给i，i++表达式的值是没加以前

i=0—》i++ —》i为1—》i++表达式的值是0，赋值给i  i最后还是0  

54、下面2个文件位于相同目录下，编译运行后会出现的情况是（      ）。 

//File P1.java

package MyPackage;

class P1{

void afancymethod(){

        System.out.println("What a fancy method");

        }

}

//File P2.java//p2没有包名

public class P2 extends P1{

    public static void main(String argv[]){

P2 p2 = new P2();

p2.afancymethod();

    }

}

A、2个文件都可以编译，P2运行输出“What a fancy method”

B、2个文件都不能编译 

C、2个文件都可以编译，P2运行时报错误 

D、P1编译成功，P2编译时报错误 

解答：D                    这个题的关键是p2没有包名 和目录没有关系  而且没有引入包

5、下列选项中，能有效地描述浮点数的有（    ）。

A. Float foo = -1;  整数转换float不用强制

B. Float foo = 1.0;  错误 默认是double

C. Float foo = 42e1;  科学计数法也是默认double 需强制转换

D. Float foo = 2.02f; 

E. Float foo = 3.03d; 

F. Float foo = 0x0123;

解答：A, D, F            整数自动变成float double需要强制转换

16、下列选项中，能有效声明一个字符的语句有（      ）。

A. Char ch = “a”; 

B. Char ch = ‘\' ‘;   特殊字符需要 \  转换

C. Char ch = ‘cafe'; 

D. Char ch = “cafe”; 

E. Char ch = ‘\ucafe';  unicode 后面跟四位十六进制0000--FFFF

F. Char ch = ‘\u10100';  unicode最多四位

G. Char ch = (char) true;

解答：B,E

第五届java预赛

(1) 编译和运行下面代码时显示的结果是（）。A

 public class ThisConstructorCall {

 public ThisConstructorCall（String s） {

  System.out.println（"s = " + s）;

 }

 public ThisConstructorCall（int i） {

  this（"i = " + i）;

 }

 public static void main（String args[]） {

  new ThisConstructorCall（"String call"）;

  new ThisConstructorCall（47）;

 }

}

　A、s = String call

     s = i = 47

　B、String call

     s = i

　C、s = String call

     i = 47

　D、String call

     s = i = 47          这个题主要是this（）；的用法this（）相当于调用类的构造函数括号里面的作为参数传进去

(1) 下面代码执行后，正确的输出结果是（）。A

String s1="You are hired!"; 

System.out.println（s1.replace（’h’,’f’））; //用f把字串中的h替换了 

System.out.println（s1）;

　A、You are fired!

     You are hired!

　B、You are fired!

     You are fired!

　C、You are hired!

     You are hired!

　D、You are hired!

     You are fired!            这个值得注意的是replace不会真正替换里面的字符  也可以用string引用说明s1.replace（’h’,’f’）执行后

地址改变原来地址的值没有改变

(1) 下列程序段的输出结果是（）。D

public class OperatorsandExpressions{ 

       public static void main（String args[]）{ 

                int a=5,b=4,c=3; 

                System.out.println（"abc"+a+b+c+3）; 

        } 

}

　A、abc15

　B、abcabc3

　C、abc3

　D、abc5433        当“abc” 先与数字出现的时候就会把数字当成string处理   当数字先与string出现时数字就会先求和  再输出string

(1) 下面语句段处理后，ch的值是（）。D

  char ch = ’A’;

  ch = （char） （ch ^ 7）;

　A、A

　B、C

　C、D

　D、F            A的ascii是65  先把65换成二进制再和7的二进制做异或运算  

(1) 下面语句正确的是（）。D

　A、char=’abc’;

　B、long l=oxfff;    重点在b选项  0x  那是小写的o（欧）  但是0x中的0是（零）！！

　C、float f=0.23;

　D、double d=0.7E-3;

(1) 下面说法错误的有（）。ABC

　A、用new运算符来创建的对象，在JVM退出时才会被做垃圾回收 

　B、判断一个对象是否可以被垃圾回收的条件为是否还有对该对象的引用     //垃圾回收满足两个条件：1.没有这个对象的引用 2. jvm需要这个内存的时候

　C、java函数的参数传递规定，所有的原始类型（如整数）和对象（使用new来创建的）都为地址传递   //原始类型是值传递

　D、java函数支持重载，但函数必须至少有一个参数的类型不同或个数不同