Java 软件工程师 初级阶段测试题

china1985

               
软件工程师（Java）初级阶段测试题
一、选择题：（每题2分）
1.         
名为HelloWorld.java的Java应用程序如下：
public class
HelloWorld   
{
public static void main(String
args[])   
{
System.out.println("Hello
World!");   
}
}
将这个程序放在C:\Test下，然后在命令行窗口中，进入到C:\Test路径执行如下指令：
javac helloworld.java将得到（  ）结果。
A.      
编译出错。
B.      
编译成功，生成名为HelloWorld.class的文件。
C.      
编译成功，生成名为helloworld.class的文件。
D.      
找不到名为helloworld.java的文件。
答案： D。在JAVA中是严格区分大小写的
2.         
下面的程序名为Student.java：
public class Student
{
private String name;
public Student(String
s_name)    //1
{
name =
s_name;      //2
}

public static void main(String args[])
{
Student s = new
Student();    //3
}
}
使用如下指令编译：javac Student.java。将会得到的结果（  ）。
A.      
将会顺利通过编译，并将产生一个Student.class的类文件。
B.      
编译时在//3处出错。
C.      
编译时在//2处出错。
D.      
编译时在//1处出错。
答案：B。因为Student的构造函数是带有参数的构造函数。
3.         
关于下面的类描述中正确的是（  ）。
class Test
{                                   
         // 1
void test(int i)
{                                    
// 2
System.out.println("I am an
int.");                  
// 3
}                                                
// 4
void test(String s)
{                                 
// 5
System.out.println("I am a
string.");               
// 6
}                                                
// 7
// 8
public static void main(String args[])
{              
    // 9
Test t=new
Test();                              
// 10
char
ch='y';                                    
// 11
t.test(ch);                                       
// 12
}                                                
// 13
}                                                   
// 14

A.      
编译出错
B.      
编译通过，运行出错
C.      
编译通过，运行时输出“I am
an int”
D.      
编译通过，运行时输出“I am
a string”
答案：C。字符在ASCii码中是以整数形式存在的。
4.         
关于下述程序：
public class Test3
{
public static void main(String[] agrs)
{
byte b = 2,e =3;
     //1
byte f = b+e;
       //2
System.out.println(f);  //3
}
}
描述正确的是（  ）。
A.      
编译通过，运行时打印出5。
B.      
编译通过，运行时打印出23。
C.      
编译不通过，在//2处有错误，因为此处f必须是一个int类型的变量。
D.      
编译不通过，在//1处有错误，不能这样定义变量
答案：C

5.         
在Java中，关于让垃圾回收器强制回收对象的说法中，正确的是（  ）。
A．垃圾回收不能强制
B. 调用System.gc()方法
C. 调用System.gc()方法，并且将需要回收的对象引用作为参数传递给这个方法
A.      
D. 调用Runtime.gc()方法
答案：B
6.         
关于下述程序：
public class Test4
{
public static void main(String[] agrs)
{
double x = 1.234;   //1
double y = 2;   //2
System.out.println(""+x+y);  
//3
System.out.println(x+y+"");  
//4
}
}
描述正确的是（  ）。
A.      
编译出错。
B.      
编译通过，执行的时候在//2处报错。
C.      
编译通过，执行时在//3处打印出3.234，在//4处打印出3.234。
D.      
编译通过，执行时在//3处打印出1.2342.0，在//4处打印出3.234。
答案：D
7.         
将当前目录下的所有文件都压缩到一个test.jar包中，并且将压缩信息显示到控制台上，可以使用下列的（   ）命令。
A.   jar vf test.jar .//      B.
jar cvf test.jar
C.   jar cv test.jar
/                  
D.  jar cv test.jar .
答案：B
8.         
下述程序：
public class Test9
{
static int i = 1;
static
{
i++;
}

public Test9()
{
i++;
}

public static void main(String[] args)
{
Test9 t1 = new Test9();
System.out.println(t1.i);  //1

Test9 t2 = new Test9();
System.out.println(t2.i);  //2
}
}
编译运行后在//1和//2处分别打印出（）。
A.   2和2         
B.  3和3         
C.  3和4         
D.  4和3
答案：C
9.         
关于下述三个接口：
public interface IA
{
public void methodA();
}

public interface IB
{
public void methodB();
}

public interface IC extends IA,IB
{
public void methodA();
}
正确的是（）。
A.      
接口IC不能通过编译，因为它继承了两个接口。
B.      
接口IC不能通过编译，因为它定义了一个和IA中一样的方法methodA()。
C.      
接口IC不能通过编译，因为它继承了两个接口，并且还定义了一个和IA一样的methodA()方法。
D.      
接口IC能够顺利通过编译。
答案：D
10.      
下述语句执行结果为（  ）。
int[] arr = new int[10];
A.   arr[0] 是0                        
B.  arr[9] 是0  
C.   arr[10]是0                        
D.  arr[0] 是null
答案：A。对象数组保存的是引用，基本类型数组保存的是基本类型的值
11.      
关于break和continue语句，下面说法错误的有（  ）。
A.      
break只能用于循环语句中。
B.      
continue只能用于循环语句中。
C.      
在循环语句中，break语句将终止循环；而continue是略过当前循环中剩余的语句进入下一次循环。
D.      
在循环语句中，continue语句将终止循环；而break是略过当前循环中剩余的语句进入下一次循环。
答案：C
12.      
下面标识符合法的有（  ）
A.  
IAMAClass           B.
$byte           C.
const           D.
_year
答案：：D。 标识符只能是字母和下划线开头。
13.      
关于垃圾收集的哪些叙述是对的?
A.      
程序开发者必须自己创建一个线程进行内存释放的工作。
B.      
垃圾收集将检查并释放不再使用的内存。
C.      
垃圾收集允许程序开发者明确指定并立即释放该内存。
D.      
垃圾收集能够在期望的时间释放被java对象使用的内存。
答案：B
14.      
下面的程序的输出结果是：（   ）
class SuperClass {
  static {
   
System.out.println("SuperClass");
  }
  SuperClass() {
    System.out.println("SuperClass()");
  }
  public static void main(String[]
args) {
    SubClass sc = new
SubClass();
  }
}
class SubClass extends SuperClass {
  static {
   
System.out.println("SubClass");
  }
  SubClass() {
   
System.out.println("SubClass()");
  }
}
A.      
SuperClass/SubClass/SuperClass()/SubClass()/
B.      
SuperClass/
SuperClass()/SubClass /SubClass()/
C.      
SubClass / SuperClass /
SubClass()/SuperClass()/
D.      
SubClass/
SubClass()/SuperClass / SuperClass()/
答案：A
15.      
下面程序的运行结果是：（   ）
class SuperClass {
  public void f() {
   
System.out.print("SuperClass.f()/");
  }
}
class SubClass extends SuperClass {
  public void f() {
  
System.out.print("SubClass.f()/");
}
}
class ThirdClass {
  public void g(SuperClass arg) {
   
System.out.print("g(SuperClass)/");
    arg.f();
  }
  public void g(SubClass arg) {
   
System.out.print("g(SubClass)/");
    arg.f();
  }
  public static void main(String[]
args) {
    ThirdClass tc = new
ThirdClass();
    SuperClass sc = new
SubClass();
    tc.g(sc);
  }
}
A.  
g(SubClass)/SubClass.f()/         
B.  g(SuperClass)/SuperClass.f()/
C.  
g(SuperClass)/SubClass.f()/        
D.  g(SubClass)/SuperClass.f()/
答案：A
16.  取出字符串String target =
"IbmSunJavaBeaWeblogicOracle..."中的子串“Java”的语句是：（   ）
A.  
target.substring(5,10);            
B.  target.substring(6,10);
C.  
target.substring(5,9);            
D.  target.substring(6,9);
D
17.      
下列描述正确的是：（   ）
A.      
hashCode()返回是对象在内存唯一的标识，对象不同，hashCode()返回值一定不同。
B.      
hashCode()方法可以重写，但重写的逻辑要和equals()保持一致性。
C.      
语句System.out.println("java"=="java");打印出的结果为“false”。
D.      
HashSet容器在存放某一类的对象时，改变该类的hashCode()方法可能会影响到HashSet容器的效率
答案:B
18.      
属于Collection容器的方法是：（  
）
A.  
iterator        B.
hasNextElement      C.
toArray     D.  next
答案：D
19.      
下列三条输出语句输出的结果为：（   ）
System.out.print(Math.floor(156.1)+"/");
System.out.print(Math.ceil(-166.3)+"/");
System.out.print(Math.round(-123.5)+"/");
A.   156.0/-167.0/-124/                 
B.  157.0/-167.0/-123/
C.  
157.0/-166.0/-124/                 
D.  156.0/-166.0/-123/
答案： D
20.      
下面的程序会有编译错误，更正的方法为：（   ）
class OuterClass {
  public void f() {
    String s1 =
"inner";
    class InnerClass {
      public void
g() {
      
System.out.println(s1);
      }
    }
  }
}
A.   将变量s1声明为static              
B.  将变量s1声明为public
C.   将变量s1声明为final               
D.  将内部类InnerClass声明为static
答案：C.从内部类中访问局部变量，必须声明为最终类型
21.      
已有接口定义：
package test;
public interface Role {
  public void action() throws
java.io.IOException;
}
下面的类定义不会有编译错误的是：
A.      

package test;
public class A implements Role {
  public void action() throws
java.io.FileNotFoundException {}
}
B.      

package test;
public class B implements Role {
  public void action() throws
java.io.IOException {}
}
C.      

package test;
public class C implements Role {
  public void action() {};
}
D.      

package test;
public class D implements Role {
  public void action() throws
Exception {}
}
答案：D
22.      
下面程序的输出结果为：
import java.io.*;
class TestRandomAccessFile {
  public static void main(String[]
args) throws Exception {
    RandomAccessFile file
= new RandomAccessFile("temp.dat", "rw");
   
file.writeBoolean(true);
    file.writeInt(100);
    file.writeInt(12345);
    file.writeInt(6789);
    file.seek(5);
   
System.out.println(file.readInt());
  }
}
A.  
100         B.
6789            C.
12345           D.
16777216
答案：C
23.      
下面程序输出的结果是：（   ）
class SomeClass
    implements Comparable
{
  private int number;
  private String name;
  SomeClass(int number, String
name) {
    this.name = name;
    this.number = number;
  }
  public String toString() {
    return name + number;
  }
  public int compareTo(Object obj)
{
    SomeClass sc =
(SomeClass) obj;
    int f =
name.compareTo(sc.name);
    int f1 = number >
sc.number ? 1 : number == sc.number ? 0 : -1;
    return f != 0 ? f :
f1;
  }
  public static void main(String[]
args) {
    SomeClass[] array = {
      
new SomeClass(10, "Java"), new SomeClass(9, "Java"),
      
new SomeClass(10, "J2EE")};
   
java.util.Arrays.sort(array);
    for(int i =
0;i     
System.out.print(array+"/");
    }
  }
}
A.  
J2EE10/Java9/Java10/                  
B.  Java9/J2EE10/Java10/
C.   Java10/Java9/J2EE10/                  
D.  J2EE10/Java10/Java9/
答案:A
24.      
下面的程序输出的结果为：
public class Test {
  public static void main(String[]
args) {
    StringBuffer buffer =
new StringBuffer();
    int value = 18;
    do {
      int temp
= value & 0x07;
     
buffer.append(temp);
   
}while((value>>>=3)!=0);
   
System.out.println(buffer.reverse());
  }
}
A.  
24            
B.
23            
C.  25            
D.  22
答案：D。0x7是十六进制写法，其最后3位为1（00000111），所以将18（00010010）与0x7作安位与后变为00000010（即十进制数字2），temp变为2，然后循环执行两次buffer.append(temp)后，buffer就变为了22，buffer.reverse()是数组反转，22反转之后还是22所以最后输出为22
二、简答题：（每题4分）
1.         
简述单子模式的思路，并且写出一种实现方案：
2.           
写出private、public、protected以及Default各自的访问范围：
3.           
用简短的语言解释下列词汇
a)      
JVM
b)      
垃圾回收机制
c)      
多态
d)      
动态绑定
e)      
关键字synchronized
三、编程题（每题8分）
1.         
写一个类，当该类的实例创建时即启动一个线程，按照指定格式每隔5秒循环打印出当前的时间（提示：使用Runnable接口或内部类创建线程，格式化日期使用java.text.SimpleDateFormat），指定的日期格式为：
××××年××月××日 ××点××分××秒。
2.           
写一个方法将一个字符串中连续出现的“Java”替换为一个“Java”。例如：字符串“JavaJavaBeaJ2eeJavaIBMJavaJavaJava”替换的结果为“JavaBeaJ2eeJavaIBMJava”。（提示：可以使用正则表达式）
3.           
写一个程序统计输入字符串中以“,”分隔的各种单词出现的次数。例如：输入的字符串为“java,java,j2ee,ibm,j2ee,ibm,j2me,java”，则该程序的输出结果应该为：
java3个;j2ee2个;ibm2个;j2me1个
（提示：可以使用java.util.StringTokenizer和Map容器）
4.           
已知在文件路径“c:\temp\target.bmp”，写出Java程序将该文件同名拷贝到路径“c:\bak”下。注意，由于文件较大，应考虑到程序的效率问题。
5.  
写出一段程序，从备选字符串“red”、“green”、“blue”、“black”、“white”中随机选出3个不同的字符串，并打印到控制台。
四、请从技术的角度谈谈你在该阶段课程中的收获和困惑。（此题不计分）
我只做了选择题部分，不知道我有没有做错，如果有错误请麻烦指正！谢谢！
               
               

本文来自ChinaUnix博客，如果查看原文请点：http://blog.chinaunix.net/u/20276/showart_397130.html