SCJP试题集及解析(基础知识常温习)

 

SCJP试题集及解析<o:p></o:p>

1.      Which of the following range of short is correct? <o:p></o:p>

A. -2⁷ -- 2⁷-1
B. 0 – 2¹⁶<st1:chmetcnv w:st="on" unitname="C" sourcevalue="1" hasspace="False" negative="True" numbertype="1" tcsc="0">-1 </st1:chmetcnv>
C. -2¹⁵ – 2¹⁵-1
D. 2³¹ – 2³¹-1
翻译：下面哪些是short型的取值范围。 <o:p></o:p>

答案:：C <o:p></o:p>

解析：短整型的数据类型的长度是16 bits，有符号。另外需要说明的是java中所有的整（Integral）数(包括byte,short,int,long)全是有符号的。 <o:p></o:p>

2.      Which declarations of identifiers are legal? <o:p></o:p>

A. $persons
B. TwoUsers
C. *point
D. this
E. _endline
翻译：下面哪些是合法的标识符。
答案：A,B,E <o:p></o:p>

解析：Java的标识符可以以一个Unicode字符，下滑线（_），美元符（$）开始，后续字符可以是前面的符号和数字，没有长度限制，大小写敏感，不能是保留字。 <o:p></o:p>

3.      Which statement of assigning a long type variable to a hexadecimal value is correct? <o:p></o:p>

A. long number = <st1:chmetcnv w:st="on" unitname="l" sourcevalue="345" hasspace="False" negative="False" numbertype="1" tcsc="0">345L</st1:chmetcnv>;
B. long number = 0345;
C. long number = <st1:chmetcnv w:st="on" unitname="l" sourcevalue="345" hasspace="False" negative="False" numbertype="1" tcsc="0">0345L</st1:chmetcnv>;
D. long number = 0x<st1:chmetcnv w:st="on" unitname="l" sourcevalue="345" hasspace="False" negative="False" numbertype="1" tcsc="0">345L</st1:chmetcnv>
翻译：哪些是将一个十六进制值赋值给一个long型变量。
答案D <o:p></o:p>

解析：十六进制数以0x开头，long型数以L（大小写均可，一般使用大写，因为小写的l和数字1不易区分）。 <o:p></o:p>

4.      Which of the following fragments might cause errors?
A. String s = "Gone with the wind";
String t = " good ";
String k = s + t;
B. String s = "Gone with the wind";
String t;
t = s[3] + "one";

C. String s = "Gone with the wind";
String standard = s.toUpperCase();

D. String s = "home directory";
String t = s - "directory";

翻译：下面的哪些程序片断可能导致错误。
答案B,D <o:p></o:p>

解析 A：String类型可以直接使用+进行连接运算。
B：String是一种Object，而不是简单的字符数组，不能使用下标运算符取其值的某个元素，错误。
C：toUpperCase()方法是String对象的一个方法，作用是将字符串的内容全部转换为大写并返回转换后的结果（String类型）。
D：String类型不能进行减（-）运算，错误。 <o:p></o:p>

5.      Which are syntactically valid statement at// point x? <o:p></o:p>

class Person {
private int a;
public int change(int m){ return m; }
}
public class Teacher extends Person {
public int b;
public static void main(String arg[]){
Person p = new Person();
Teacher t = new Teacher();
int i;
// point x
}
}<o:p></o:p>

A. i = m;
B. i = b;
C. i = p.a;
D. i = p.change(30);
E. i = t.b.
翻译：在// point x处的哪些申明是句法上合法的。
答案D,E <o:p></o:p>

解析 A：m没有被申明过，不能使用。
B：虽然b是类Teacher的public成员变量，但是在静态方法中不能使用类中的非静态成员。
C：a是类Person的private成员，在类外不能直接引用。
D：change(int m)方法是public方法，并且返回一个int型值，可以通过类的实例变量p引用并赋值给一个int型变量。
E：b是类Teacher的public成员变量，且是int型，可以通过类的实例变量t引用并赋值给一个int型变量。

6. Which layout manager is used when the frame is resized the buttons's position in the Frame might be changed? <o:p></o:p>

A. BorderLayout
B. FlowLayout
C. CardLayout
D. GridLayout
翻译：当Frame的大小被改变时Frame中的按钮的位置可能被改变时使用的哪一个布局管理器。
答案：B <o:p></o:p>

解析 A：该布局管理器将容器划分为五个部分，容器大小的改变不会影响其中的组件的位置而是影响他们的大小。
B：该布局管理器根据放入其中的组件的最合适大小调整组件的位置，根据组件放入的顺序安排，一行不能容纳时放入下一行，因此容器的大小改变可能改变组件的位置。
C：该布局管理器显示放入该容器的当前页中的组件，一次显示一个，容器大小的改变不能影响其中组件的位置。
D：该布局管理器将容器划分为固定的网格，组件加入后占据一个单元，各组件的相对位置不会因为容器的大小变化而变化，改变的只是组件的大小。 <o:p></o:p>

6.      Given the following code fragment:<o:p></o:p>

1) public void create() {
2} Vector myVect;
3} myVect = new Vector();
4} }
Which of the following statements are true?
A. The declaration on line 2 does not allocate memory space for the variable myVect.
B. The declaration on line 2 allocates memory space for a reference to a Vector object.
C. The statement on line 2 creates an object of class Vector.
D. The statement on line 3 creates an object of class Vector.
E. The statement on line 3 allocates memory space for an object of class Vector
翻译：
给出下面的代码片断。。。下面的哪些陈述为true(真)?
A. 第二行的声明不会为变量myVect分配内存空间。
B. 第二行的声明分配一个到Vector对象的引用的内存空间。
C. 第二行语句创建一个Vector类对象。
D. 第三行语句创建一个Vector类对象。
E. 第三行语句为一个Vector类对象分配内存空间。
答案A,D,E <o:p></o:p>

解析 SL-275中指出：要为一个新对象分配空间必须执行new Xxx()调用，new调用执行以下的操作：
1．为新对象分配空间并将其成员初始化为0或者null。
2．执行类体中的初始化。（例如在类中有一个成员声明int a=10;在第一步后a=0 ，执行到第二步后a=10）
3．执行构造函数。
4．变量被分配为一个到内存堆中的新对象的引用。

8. Which of the following answer is correct to express the value <st1:chmetcnv w:st="on" unitname="in" sourcevalue="8" hasspace="True" negative="False" numbertype="1" tcsc="0">8 in</st1:chmetcnv> octal number? <o:p></o:p>

A. 010
B. 0x<st1:chmetcnv w:st="on" unitname="C" sourcevalue="10" hasspace="False" negative="False" numbertype="1" tcsc="0">10
</st1:chmetcnv>C. 08
D. 0x8
翻译：下面的哪些答案可以用以表示八进制值8。
答案：A <o:p></o:p>

解析 八进制值以0开头，以0x开头的为十六进制值，八进制中不能出现数字8，最大只有7。<o:p></o:p>

9. Which are not Java keywords?
A. TRUE
B. sizeof
C. const
D. super
E. void

翻译：哪些不是Java关键字。
答案A,B <o:p></o:p>

解析 A：不是，Java中有true,但是这也不是关键字而是字面量（literal）。
B：不是，Java中不需要这个操作符，所有的类型（原始类型）的大小都是固定的。
C、D、E都是，需要说明的是const是java中未被使用的关键字。<o:p></o:p>

10. Which of the following statements are true? <o:p></o:p>

A. The equals() method determines if reference values refer to the same object.
B. The == operator determines if the contents and type of two separate objects match.
C. The equals() method returns true only when the contents of two objects match.
D. The class File overrides equals() to return true if the contents and type of two separate objects match.
翻译:下面的哪些叙述为真。A. equals()方法判定引用值是否指向同一对象。
B. == 操作符判定两个分立的对象的内容和类型是否一致。
C. equals()方法只有在两个对象的内容一致时返回true。
D. 类File重写方法equals()在两个分立的对象的内容和类型一致时返回true。
答案A,D <o:p></o:p>

解析  严格来说这个问题的答案是不确定的，因为equals()方法是可以被重载的，但是按照java语言的本意来说：如果没有重写（override）新类的equals()，则该方法和 == 操作符一样在两个变量指向同一对象时返回真，但是java推荐的是使用equals()方法来判断两个对象的内容是否一样，就像String类的equals()方法所做的那样：判定两个String对象的内容是否相同，而==操作符返回true的唯一条件是两个变量指向同一对象。从这个意义上来说选择给定的答案。从更严格的意义来说正确答案应该只有d。<o:p></o:p>

11. Which statements about inheritance are true?
A. In Java programming language only allows single inheritance.
B. In Java programming language allows a class to implement only one
interface.
C. In Java programming language a class cannot extend a class and implement
a interface together.
D. In Java programming language single inheritance makes code more
reliable. <o:p></o:p>

翻译：下面关于继承的哪些叙述是正确的。<o:p></o:p>

A．在java中只允许单一继承。
B．在java中一个类只能实现一个接口。
C．在java中一个类不能同时继承一个类和实现一个接口。
D．java的单一继承使代码更可靠。
答案A,D <o:p></o:p>

解析  在java中一个类只能有一个直接父类，但是可以实现多个接口，在继承的同时可以实现接口，之所以取消多继承的原因是多继承使得代码产生很多问题,而使用单一继承则可以使代码更可靠。

12.
1) class Person {
2} public void printValue(int i, int j) {/*…*/ }
3} public void printValue(int i){/*...*/ }
4} }
5) public class Teacher extends Person {
6} public void printValue() {/*...*/ }
7} public void printValue(int i) {/*...*/}
8} public static void main(String args[]){<o:p></o:p>

将一个子类的实例赋值给一个父类的变量是不用进行强制类型转换，反之则需要进行强制类型转换
9} Person t = new Teacher();<o:p></o:p>

Teacher t1 = new (Teacher) Person();  <o:p></o:p>

10} t.printValue(10);
11} }
12} }

Which method will the statement on line 10 call?
A. on line 2
B. on line <st1:chmetcnv w:st="on" unitname="C" sourcevalue="3" hasspace="False" negative="False" numbertype="1" tcsc="0">3
</st1:chmetcnv>C. on line 6
D. on line 7
翻译：第十行的声明将调用哪些方法。<o:p></o:p>

答案：D <o:p></o:p>

解析  变量t是一个Person对象，但是它是用Teacher实例化的，这个问题涉及到java的编译时多态和运行时多态的问题，就编译时多态来说，t实际上是一个Person类，这涉及到类型的自动转换（将一个子类的实例赋值给一个父类的变量是不用进行强制类型转换，反之则需要进行强制类型转换，而且被赋值的变量实际上应该是一个子类的对象），如果对t调用了子类中新增的方法则造成编译时错误编译将不能通过，而在运行时，运行时系统将根据t实际指向的类型调用对应的方法，对于本例来说，t.print(10)将调用t实际指向的Teacher类的对应方法。在java中，可以用一个子类的实例实例化父类的一个变量，而变量在编译时是一个父类实例，在运行时可能是一个子类实例。<o:p></o:p>

13. Which are not Java primitive types?
A. short
B. Boolean
C. unit
D. float <o:p></o:p>

翻译：下面哪些不是java的原始数据类型。
答案：B,C <o:p></o:p>

解析  Java的原始数据类型一共就八个，分别是：byte,short,int,long,boolean,char,float,double。注意这些是大小写敏感的，而Boolean是booelan的封装类（wrapper class）。<o:p></o:p>

14. Use the operators "<<", ">>", which statements are true?
A. 0000 0100 0000 0000 0000 0000 0000 0000<<5 gives
1000 0000 0000 0000 0000 0000 0000 0000
B. 0000 0100 0000 0000 0000 0000 0000 0000<<5 gives
1111 1100 0000 0000 0000 0000 0000 <st1:chmetcnv w:st="on" unitname="C" sourcevalue="0" hasspace="False" negative="False" numbertype="1" tcsc="0">0000
</st1:chmetcnv>C. 1100 0000 0000 0000 0000 0000 0000 0000>>5 gives
1111 1110 0000 0000 0000 0000 0000 0000
D. 1100 0000 0000 0000 0000 0000 0000 0000>>5 gives
0000 0110 0000 0000 0000 0000 0000 0000
翻译：使用"<<"和 ">>"操作符的哪些陈述是对的。 <o:p></o:p>

答案A,C <o:p></o:p>

解析  Java的移位操作符一共有三种，分别是”>>”,”>>>”,”<<”,执行的操作分别是有符号右移，无符号右移，左移，有符号右移的意思是说移入的最高位和原最高符号位相同，无符号右移是移入位始终补零，左移时最低位始终补零，最高位被舍弃。移位操作符另一个非常值得注意的特点是其右操作数是取模运算的，意思是说对于一个int型数据而言，对它移位32位的结果是保持不变而非变成零，即：a>>32的结果是a而不是