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的文件。
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处出错。(Student的构造函数是带有参数的构造函数)
C. 编译时在//2处出错。
D. 编译时在//1处出错。
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”.(字符在ASCii码中是以整数形式存在的)
D. 编译通过，运行时输出“I am a string”.
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处有错误，不能这样定义变量
5.在Java中，关于让垃圾回收器强制回收对象的说法中，正确的是( )。
A．垃圾回收不能强制
B.
调用System.gc()方法
C. 调用System.gc()方法，并且将需要回收的对象引用作为参数传递给这个方法
D. 调用Runtime.gc()方法
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。
7. 将当前目录下的所有文件都压缩到一个test.jar包中，并且将压缩信息显示到控制台上，可以使用下列的( )命令。
A. jar vf
test.jar
. B. jar cvf test.jar
C. jar cv
test.jar D. jar cv test.jar .
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
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能够顺利通过编译。
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是略过当前循环中剩余的语句进入下一次循环。
12. 下面标识符合法的有( )
A. IAMAClass B. $byte C. const D. _year
13. 关于垃圾收集的哪些叙述是对的?
A. 程序开发者必须自己创建一个线程进行内存释放的工作。
B. 垃圾收集将检查并释放不再使用的内存。
C. 垃圾收集允许程序开发者明确指定并立即释放该内存。
D. 垃圾收集能够在期望的时间释放被java对象使用的内存。
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()/
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()/
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);
17. 下列描述正确的是：( )
A. hashCode()返回是对象在内存唯一的标识，对象不同，hashCode()返回值一定不同。
B. hashCode()方法可以重写，但重写的逻辑要和equals()保持一致性。
C. 语句System.out.println("java"=="java");打印出的结果为“false”。
D. HashSet容器在存放某一类的对象时，改变该类的hashCode()方法可能会影响到HashSet容器的效率
18. 属于Collection容器的方法是：( )
A. iterator B. hasNextElement C. toArray D. next
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/
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
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 {}
}
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
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[i]+"/");
}
}
}
A. J2EE10/Java9/Java10/ B. Java9/J2EE10/Java10/
C. Java10/Java9/J2EE10/ D. J2EE10/Java10/Java9/
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
(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个不同的字符串，并打印到控制台。
PS:如果有做的错的地方，还请留言帮忙指出，多谢了~
378
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
