李云泽 2009-10-16 11:50 发表评论

李云泽 2009-10-16 11:44 发表评论

§1.1.1     一

What will happen when you attempt to compile and run the following code?

class MyThread extends Thread

{

public void run()

{

System.out.println("MyThread: run()");

}

public void start()

{

System.out.println("MyThread: start()");

}

}

class MyRunnable implements Runnable

{

public void run()

{

System.out.println("MyRunnable: run()");

}

public void start()

{

System.out.println("MyRunnable: start()");

}

}

public class MyTest

{

public static void main(String args[])

{

MyThread myThread  =  new MyThread();

MyRunnable myRunnable = new MyRunnable();

Thread thread  =  new Thread(myRunnable);

myThread.start();

thread.start();

}

}

Choices:

a. Prints : MyThread: start() followed by MyRunnable:run()

b. Prints : MyThread: run() followed by MyRunnable:start()

c. Prints : MyThread: start() followed by MyRunnable:start()

d. Prints : MyThread: run() followed by MyRunnable:run()

e. Compile time error

f. None of the above

―――――――――――――――

A is the correct choice. In the above code there is not any compilation error. Thus choice E is incorrect. Inside main() method, objects of MyThread and MyRunnable class are created followed by creation of Thread with object of MyRunnable class. Note that MyThread class extends Thread class and overrides the start() method of the Thread class. Thus on execution of "myThread.start()" statement, the start() method of the MyThread class will be executed and as a result "MyThread:start()" will be printed. Had the start() method not there in MyThread class, the start() method of the Thread class would be called which in turn would call the run() method of the MyThread class. On execution of "thread.start();", the start() method of the Thread class would be called which in turn will call the run() method of the class which is passed to Thread constructor (i.e. MyRunnable class). Thus "MyRunnable:run()" will be printed out. Thus choice A is correct.

 

§1.1.2       二

What will be the output on compiling/running the following code?

public class MyThread implements Runnable

{

  String myString = "Yes ";

  public void run()

  {

    this.myString = "No ";

  }

  public static void main(String[] args)

  {

    MyThread t = new MyThread();

    new Thread(t).start();

    for (int i=0; i < 10; i++)

     System.out.print(t.myString);

  }

}

E is correct. Please note that there will not be any compilation error when the above code is compiled. Also note that calling start() method on a Thread doesn't start the Thread. It only makes a Thread ready to be called. Depending on the operation system and other running threads, the thread on which start is called will get executed. In the above case it is not guaranteed that the thread will be executed(i.e. run() method will be called), always before "for" loop is executed. Thus the output cannot be determined.

 

§1.1.3       三

Multiple objects of MyClass (given below) are used in a program that uses

multiple Threadsto create new integer count. What will happen when other threads

use the following code?

class MyClass

{

static private int myCount = 0;

int yourNumber;

private static synchronized int nextCount()

{

return ++myCount;

}

public void getYourNumber()

{

yourNumber = nextCount();

}

}

Choices:

a. The code will give compilation error.

b. The code will give runtime error.

c. Each thread will get a unique number.

d. The uniqueness of the number among different Threads can't be guaranteed.

―――――――――――――

C is correct. The use of synchronized ensures that the number generated will not be duplicated, no matter how many Threads are trying to create the number. Thus D is incorrect. A and B are incorrect as the above code will not give any compiletime or runtime error.

§1.1.4       四

What will happen when you attempt to compile and run the following code?

public class MyThread extends Thread

{

String myName;

MyThread(String name)

{

myName = name;

}

public void run()

{

for(int i=0; i<100;i++)

{

System.out.println(myName);

}

}

public static void main(String args[])

{

try

{

MyThread mt1 = new MyThread("mt1");

MyThread mt2 = new MyThread("mt2");

mt1.start();

// XXX

mt2.start();

}

catch(InterruptedException ex)

{

}

}

}

Choices:

a.The above code in its current condition will not compile.

b. In order to make the MyThread class prints "mt1" (100 times) followed by

"mt2" (100 times), mt1.join(); can be placed at //XXX position.

c. In order to make the MyThread class prints "mt1" (100 times) followed by

"mt2" (100 times), mt1.sleep(100); can be placed at //XXX position.

d. In order to make the MyThread class prints "mt1" (100 times) followed by

"mt2" (100 times), mt1.run(); can be placed at //XXX position.

e. In order to make the MyThread class prints "mt1" (100 times) followed by

"mt2" (100 times), there is no need to write any code.

――――――――――――――

A and B are correct. In its current condition, the above code will not compile as "InterruptedException" is never thrown in the try block. The compiler will give following exception: "Exception java.lang.InterruptedException is never thrown in the body of the corresponding try statement." Note that calling start() method on a Thread doesn't start the Thread. It only makes a Thread ready to be called. Depending on the operating system and other running threads, the thread on which start is called will get executed. After making the above code to compile (by changing the InterruptedException to some other type like Exception), the output can't be predicted (the order in which mt1 and mt2 will be printed can't be guaranteed). In order to make the MyThread class prints "mt1" (100 times) followed by "mt2" (100 times), mt1.join() can be placed at //XXX position. The join() method waits for the Thread on which it is called to die. Thus on calling join() on mt1, it is assured that mt2 will not be executed before mt1 is completed. Also note that the join() method throws InterruptedException, which will cause the above program to compile successfully. Thus choice A and B are correct.

 

§1.1.5       五

What will happen when you attempt to compile and run the following code?

public class MyThread extends Thread{

String myName;

MyThread(String name){

myName = name;

}

public void run(){

for(int i=0; i<100;i++){

System.out.println(myName);

}

}

public static void main(String args[]){

try{

MyThread mt1 = new MyThread("mt1");

MyThread mt2 = new MyThread("mt2");

mt1.start();

// XXX

mt2.start();

}catch(InterruptedException ex){}

}

}

A. compile error

B. mt1.join();

C. mt1.sleep(100);

D. mt1.run()

E. nothing need

 

Choice A and B are correct. In its current condition, the above code will not compile as "InterruptedException" is never thrown in the try block. The compiler will give following exception: "Exception java.lang.InterruptedException is never thrown in the body of the corresponding try statement."

Note that calling start() method on a Thread doesn't start the Thread. It only makes a Thread ready to be called. Depending on the operating system and other running threads, the thread on which start is called will get executed. After making the above code to compile (by changing the InterruptedException to some other type like Exception), the output can't be predicted (the order in which mt1 and mt2 will be printed can't be guaranteed). In order to make the MyThread class prints "mt1" (100 times) followed by "mt2" (100 times), mt1.join() can be placed at //XXX position. The join() method waits for the Thread on which it is called to die. Thus on calling join() on mt1, it is assured that mt2 will not be executed before mt1 is completed. Also note that the join() method throws InterruptedException, which will cause the above program to compile successfully. Thus choice A and B are correct.

§1.1.6       六

Multiple objects of MyClass (given below) are used in a program that uses multiple Threads to create new integer count. What will happen when other threads use the following code?

class MyClass{

static private int myCount = 0;

int yourNumber;

private static synchronized int nextCount(){

return ++myCount;   //myCount为static

}

public void getYourNumber(){

yourNumber = nextCount();

}

}

A. the code ill give ompilation error

B. the code ill give runtime error

C. each thread will get a unique number

D. the uniqueness of the number different Threads can’t be guaranteed.

 

C is correct. The use of synchronized ensures that the number generated will not be duplicated, no matter how many Threads are trying to create the number. Thus D is incorrect. A and B are incorrect as the above code will not give any compiletime or runtime error.

 

§1.1.7       七

What will be the output on compiling/running the following code?

public class MyThread implements Runnable {

  String myString = "Yes ";

  public void run() {

    this.myString = "No ";

  }

  public static void main(String[] args)  {

    MyThread t = new MyThread();

    new Thread(t).start();

    for (int i=0; i < 10; i++)

     System.out.print(t.myString);

  }

}

A. compile error

B. prints: yes yes yes yes yes yes and so on

C. prints: no no no no no no no no and so on

D. prints: yes no yes no ye no ye no and so on

E. the output cannot be determinated

 

E is correct. Please note that there will not be any compilation error when the above code is compiled. Also note that calling start() method on a Thread doesn't start the Thread. It only makes a Thread ready to be called. Depending on the operation system and other running threads, the thread on which start is called will get executed. In the above case it is not guaranteed that the thread will be executed(i.e. run() method will be called), always before "for" loop is executed. Thus the output cannot be determined.

§1.1.8       八

Which statements about thread are true?

　　A. Once a thread is created, it can star running immediately.

 

　　B. To use the start() method makes a thread runnable, but it does not

necessarily start immediately.

 

　　C. When a thread stops running because of pre-emptive, it is placed at

the front end of the runnable queue.

 

　　D. A thread may cease to be ready for a variety of reasons.

 

　　(bd)

 

　　题目：有关线程的哪些叙述是对的。

 

　　A. 一旦一个线程被创建，它就立即开始运行。

 

　　B. 使用start()方法可以使一个线程成为可运行的，但是它不一定立即开始运行。

 

　　C. 当一个线程因为抢先机制而停止运行，它被放在可运行队列的前面。

 

　　D. 一个线程可能因为不同的原因停止（cease）并进入就绪状态。

 

　　一个新创建的线程并不是自动的开始运行的，必须调用它的start()方法使之将线程放入

可运行态（runnable

state），这只是意味着该线程可为JVM的线程调度程序调度而不是意味着它可以立即运行。

线程的调度是抢先式的，而不是分时间片式的。具有比当前运行线程高优先级的线程可以使当

前线程停止运行而进入就绪状态，不同优先级的线程间是抢先式的，而同级线程间是轮转式的

。一个线程停止运行可以是因为不同原因，可能是因为更高优先级线程的抢占，也可能是因为

调用sleep()方法，而即使是因为抢先而停止也不一定就进入可运行队列的前面，因为同级线

程是轮换式的，它的运行可能就是因为轮换，而它因抢占而停止后只能在轮换队列中排队而不

能排在前面。

 

§1.1.9       九

Which two CANNOT directly cause a thread to stop executing? (Choose Two)

 

A.Existing from a synchronized block

B.Calling the wait method on an object

C.Calling notify method on an object

D.Calling read method on an InputStream object

E.Calling the SetPriority method on a Thread object

Answer：AC。同55题

 

§1.1.10 十

 public class SyncTest{

 public static void main(String[] args)  {

 final StringBuffer s1= new StringBuffer();

 final StringBuffer s2= new StringBuffer();

 new Thread ()   {

   public void run() {

     synchronized(s1) {

         s2.append(“A”);

          synchronized(s2) {

   s2.append(“B”);

     System.out.print(s1);

       System.out.print(s2);

      }

     }

   }  

 }.start();

 new Thread() {

   public void run() {

     synchronized(s2) {

       s2.append(“C”);

       synchronized(s1) {

        s1.append(“D”);

         System.out.print(s2);

         System.out.print(s1);

        }

      }

      }

    }.start();

   }

 }

Which two statements are true? (Choose Two)

A. The program prints “ABBCAD”

B. The program prints “CDDACB”

C. The program prints “ADCBADBC”

D. The output is a non-deterministic point because of a possible deadlock condition

E. The output is dependent on the threading model of the system the program is running on.

Answer：DE

 

§1.1.11 十一

What will happen when you attempt to compile and run the following code?

public class Test{  

   int i = 0;  

   public static void main(String argv[]) {      

     Test t = new Test();      

     t.myMethod();  

   }  

   public void myMethod(){       

     while(true) {          

                 try {               

                   wait();          

                 }catch (InterruptedException e) {}          

                 i++;      

     }  

   }

}

A. Compile time error, no matching notify within the method.

B. Compile and run but an infinite looping of the while method.

C. Compilation and run without any output.

E. Runtime Exception "IllegalMonitorStatException".

Answer: E

Note: The wait/notify protocol can only be used within code that is synchronized. In this case calling code does not have a lock on the object(not synchronized) and will thus cause an Exception at runtime.

 

§1.1.12 十二

1.10 What is the result of compiling and executing the following code?

public class ThreadTest extends Thread { 

     public void run() {     

                 System.out.println("In run");     

                 yield();    

                 System.out.println("Leaving run"); 

     }  

     public static void main(String args []) {  

                 (new ThreadTest()).start(); 

     }

}

A. The code fails to compile in the main() method.

B. The code fails to compile in the run() method.

C. Only the text "In run" will be displayed.

D. The text "In run" followed by "Leaving run" will be displayed.

E. The code compiles correctly, but nothing is displayed.

Answer: D

 

§1.1.13 十三

Which of the following will definitely stop a thread from executing?A. wait()B. notify()C. yield()D. suspend()E. sleep()Answer: ACDE

 

§1.1.14 十四

Which of the following will definitely stop a thread from executing?

A. wait()

B. notify()

C. yield()

D. suspend()

E. sleep()

Answer: ACDE

 

§1.1.15 十五

 Which of the following statements about threading are true?

A. You can only obtain a mutually exclusive lock on methods in a class that extends Thread or implements runnable.

B. You can obtain a mutually exclusive lock on any object.

C. You can't obtain a mutually exclusive lock on any object.

D. Thread scheduling algorithms are platform dependent.

Answer: BD

8:

Consider the following statement:  

Thread myThread = new Thread();

Which of the following statements are true regarding myThread?

A. The thread myThread is now in a runnable state.

B. The thread myThread has a priority of 5.

C. On calling the start() method on myThread, the run method in the Thread class will be executed.

D. On calling the start() method on myThread, the run method in the calling class will be executed.

Answer: C

Note: the priority of myThread will be inherited from the Thread that called the constructor.

§1.1.16 十六

What is the effect of issuing a wait() method on an object？（Mutiple）

1) If a notify() method has already been sent to that object then it has no effect

2) The object issuing the call to wait() will halt until another object sends a notify() or notifyAll() method

3) An exception will be raised

4) The object issuing the call to wait() will be automatically synchronized with any other objects using the receiving object.

ANSWER 1)

10:

Pick all the true statements below.

1) If a thread wants to call wait() on an object, the thread must own that object's lock.

2) There is a method that you can call on an instance of the Thread class that puts the instance to sleep for a specified    number of milliseconds.

3) At the moment when a thread is notified, it automatically gets the lock of the object for which it was waiting.

ANSWER 1

 

李云泽 2009-10-16 11:43 发表评论

李云泽 2009-10-16 11:43 发表评论

§1.1.1       一

3. What will happen when you attempt to compile and run the following code?

class MyParent

{

int x, y;

MyParent(int x, int y)

{

this.x = x;

this.y = y;

}

public int addMe(int x, int y)

{

return this.x + x + y + this.y;

}

public int addMe(MyParent myPar)

{

return addMe(myPar.x, myPar.y);

}

}

class MyChild extends MyParent

{

int z;

MyChild (int x, int y, int z)

{

super(x,y);

this.z = z;

}

public int addMe(int x, int y, int z)

{

return this.x + x + this.y + y + this.z + z;

}

public int addMe(MyChild myChi)

{

return addMe(myChi.x, myChi.y, myChi.z);

}

public int addMe(int x, int y)

{

return this.x + x + this.y + y;

}

}

public class MySomeOne

{

public static void main(String args[])

{

MyChild myChi = new MyChild(10, 20, 30);

MyParent myPar = new MyParent(10, 20);

int x = myChi.addMe(10, 20, 30);

int y = myChi.addMe(myChi);

int z = myPar.addMe(myPar);

System.out.println(x + y + z);

}

}

 

Choices:

a. 300

b. 240

c. 120

d. 180

e. Compilation error

f. None of the above

――――――――――――

A is the correct choice. In the code, MyChild class overrides the addMe(int x, int y) method of the MyParent class. And in both the MyChild and MyParent class, addMe() method is overloaded. There is no compilation error anywhere in the above code. On execution, first, the object of MyChild class will be constructed. Please note that there is a super() call from the constructor of MyChild class, which will call the constructor of MyParent class. This will cause the value of z variable of MyChild class to be 30 and x, y variables of MyParent class will become 10 and 20 respectively. The next statement will again call the constructor of MyParent class with same x and y values. This is followed by execution of addMe() method of MyChild class with x as 10, y as 20 and z as 30. Also x and y are inherited by MyChild class from the MyParent class. Thus in the addMe() method of the MyChild class, the value of this.x will be 10, this.y will be 20 and this.z will be 30. The return value of this method will be "10 + 10 + 20 + 20 + 30 + 30", which is equal to 120. Thus x will become 120. This is followed by the invocation of the other addMe() method which takes object reference of the MyChild class. From this method, the method which was called earlier is invoked. This call is exactly the same as the earlier one. Thus the value of y will also be 120 like x. Now the addMe() method of MyParent class is invoked. This method invokes another addMe() method of the same class. Its equivalent to the invocation of addMe(int x, int y) method with x as 10 and y as 20. Also the value of instance variables x and y of My Parent class is 10 and 20 respectively. The value of z will be evaluated to "10 + 10 + 20 + 20", which is equal to 60. Thus the value of x, y and z after all the invocations will be 120, 120 and 60 respectively. As a result of this finally, "120 + 120 + 60" which is equal to 300 will be printed. Thus A is the correct choice.

 

§1.1.2       二

Given the code below, and making no other changes, which access modifiers

(public, protected or private) can legally be placed before myMethod() on line 3?

If line 3 is left as it is, which keywords can legally be placed before myMethod

on line 8?

1.class HumptyDumpty

2.{

3.void myMethod() {}

4.}

5.

6.class HankyPanky extends HumptyDumpty

7.{

8.void myMethod() {}

9.}

A is correct. The basic principle is that a method cannot be overridden to be more private. Since the method is being overridden to be friendly(default modifier) it can only be private or friendly in the superclass. Secondly if the method in superclass is left as it is(i.e. friendly access) the method in subclass can be friendly, protected or public.

§1.1.3       三

What results from the following code?

1.class MyClass

2.{

3.void myMethod(int i) {System.out.println("int version");}

4.void myMethod(String s) {System.out.println("String version");}

5.public static void main(String args[])

6.{

7.MyClass obj = new MyClass();

8.char ch = 'c';

9.obj.myMethod(ch);

10.}

11.}

Choices:

a. Line 4 will not compile as void methods can't be overridden.

b. An exception at line 9.

c. Line 9 will not compile as there is no version of myMethod which takes a char as argument.

d. The code compiles and produces output: int version.

e. The code compiles and produces output: String version.

――――――――――

D is correct. A is incorrect as void methods can be overridden without any problem. B is incorrect as char ch declaration is valid. C is incorrect as char type in java is internally stored as integer and there is a method which takes int as an input. D is correct, on line 9 char ch is widened to an int and passed to int version of the myMethod(). E is incorrect as int version of myMethod() is called.

§1.1.4       四

What is displayed when the following is executed?

class Parent

{

private void method1()

{

System.out.println("Parent's method1()");

}

public void method2()

{

System.out.println("Parent's method2()");

method1();

}

}

class Child extends Parent

{

public void method1()

{

System.out.println("Child's method1()");

}

public static void main(String args[])

{

Parent p = new Child();

p.method2();

}

}

Choices:

a. Compile time error

b. Run time error

c. prints : Parent's method2()

          Parent's method1()

d. prints : Parent's method2()

          Child's method1()

―――――――

C is correct. The code will compile without any error and also will not give any run time error. The variable p refers to the Child class object. The statement p.method2() on execution will first look for method2() in Child class. Since there is no method2() in child class, the method2() of Parent class will be invoked and thus "Parent's method2()" will be printed. Now from the method2() , there is a call to method1(). Please note that method1() of Parent class is private, because of which the same method (method1() of Parent class) will be invoked. Had this method(method1() of Parent class) been public/protected/friendly (default), Child's class method1() would be called. Thus C is correct answer.

 

§1.1.5       五

What is displayed when the following is executed?

class Parent{

private void method1(){

System.out.println("Parent's method1()");

}

public void method2(){

System.out.println("Parent's method2()");

method1();

}

}

class Child extends Parent{

public void method1(){

System.out.println("Child's method1()");

}

public static void main(String args[]){

Parent p = new Child();

p.method2();

}

}

 

A. compile time error

B. run time error

C. prints: parent’s method2()  parent’s method1()

D. prints: parent’s method2()  child’s method1()

 

C is correct. The code will compile without any error and also will not give any run time error. The variable p refers to the Child class object. The statement p.method2() on execution will first look for method2() in Child class. Since there is no method2() in child class, the method2() of Parent class will be invoked and thus "Parent's method2()" will be printed. Now from the method2() , there is a call to method1(). Please note that method1() of Parent class is private, because of which the same method (method1() of Parent class) will be invoked. Had this method(method1() of Parent class) been public/protected/friendly (default), Child's class method1() would be called. Thus C is correct answer.

 

§1.1.6       六

　　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[]){

 

　　9) Person t = new Teacher();

 

　　10) t.printValue(10);

 

　　11) }

 

　　12) }

 

　　Which method will the statement on line 10 call?

　　A. on line 2

 

　　B. on line 3

 

　　C. on line 6

 

　　D. on line 7

　　翻译

　　第十行的声明将调用哪些方法。

 

　　答案　D

 

　　解析　变量t是一个Person对象，但是它是用Teacher实例化的，这个问题涉及到java的

编译时多态和运行时多态的问题，就编译时多态来说，t实际上是一个Person类，这涉及到类

型的自动转换（将一个子类的实例赋值给一个父类的变量是不用进行强制类型转换，反之则需

要进行强制类型转换，而且被赋值的变量实际上应该是一个子类的对象），如果对t调用了子

类中新增的方法则造成编译时错误编译将不能通过，而在运行时，运行时系统将根据t实际指

向的类型调用对应的方法，对于本例来说，t.print(10)将调用t实际指向的Teacher类的对应

方法。在java中，可以用一个子类的实例实例化父类的一个变量，而变量在编译时是一个父类

实例，在运行时可能是一个子类实例。

 

§1.1.7       七

35、public class Parent {

　　public int addValue( int a, int b) {

　　int s;

　　s = a+b;

　　return s;

　　}

　　}

　　class Child extends Parent {

 

　　}

　　Which methods can be added into class Child?

　　A. int addValue( int a, int b ){// do something...}

 

　　B. public void addValue (){// do something...}

 

　　C. public int addValue( int a ){// do something...}

 

　　D. public int addValue( int a, int b )throws MyException {//do

something...}

 

　　(bc)

 

　　题目：哪些方法可以加入类Child中。

 

　　此题涉及方法重载（overload），方法重写（override）以及类派生时方法重写的规则

。方法重载的规则是：一、参数列表必须不同，个数的不同完全可以，如果个数相同则参数类

型的不同不能引起歧意，例如int

和long,float和double就不能作为唯一的类型不同；二、返回值可以不同，但是不能是重载

时唯一的不同点（这点和c++中不同，c++中返回类型必须一致）。方法重写发生在类继承时，

子类可以重写一个父类中已有的方法，必须在返回类型和参数列表一样时才能说是重写，否则

就是重载，java中方法重写的一个重要而且容易被忽略的规则是重写的方法的访问权限不能比

被重写的方法的访问权限低！重写的另一个规则是重写的方法不能比被重写的方法抛弃(thro

ws)更多种类的异常，其抛弃的异常只能少，或者是其子类，不能以抛弃异常的个数来判断种

类，而应该是异常类层次结果上的种类。此题中答案a的错误就是重写的访问权限比被重写的

方法的低，而b,c都属于重载，d的错误在于比被重写的方法抛弃了更多种类的异常。

李云泽 2009-10-16 11:42 发表评论

§1.1.1       一

Which of the following lines will print false?

1.public class MyClass

2.{

3.static String s1 = "I am unique!";

4.public static void main(String args[])

5.{

6.String s2 = "I am unique!";

7.String s3 = new String(s1);

8.System.out.println(s1 == s2);

9.System.out.println(s1.equals(s2));

10.System.out.println(s3 == s1);

11.System.out.println(s3.equals(s1));

12.System.out.println(TestClass.s4 == s1);

13.}

14.}

15.

16.class TestClass

17.{

18.static String s4 = "I am unique!";

19.}

Choices:

a. Lines 10 and 12

b. Line 12 only

c. Line 8 and 10

d. None of these

――――――――――

D is correct. Only line 10 will print false. Strings are immutable objects. That is, a string is read only once the string has been created and initialized, and Java optimizes handling of string literals; only one anonymous string object is shared by all string literals with the same contents. Hence in the above code the strings s1, s2 and s4 refer to the same anonymous string object, initialized with the character string: "I am unique!". Thus s1 == s2 and TestClass.s4 will both return true and obviously s1.equals(s2) will return true. But creating string objects using the constructor String(String s) creates a new string, hence s3 == s1 will return false even though s3.equals(s1) will return true because s1 and s3 are referring to two different string objects whose contents are same.

 

§1.1.2       二

What is displayed when the following code is compiled and executed?

String s1 = new String("Test");

String s2 = new String("Test");

if (s1==s2)

         System.out.println("Same");

if (s1.equals(s2))

         System.out.println("Equals");

Choices:

a. Same

Equals

b. Equals

c. Same

d. The code compiles, but nothing is displayed upon execution.

e. The code fails to compile.

B is correct. Here s1 and s2 are two different object references, referring to different objects in memory. Please note that operator == checks for the memory address of two object references being compared and not their value. The "equals()" method of String class compares the values of two Strings. Thus s1==s2 will return "false" while s1.equals(s2) will return "true". Thus only "Equals" will be printed.

§1.1.3       三

Given the following code, what will be the output?

class Value

{

public int i = 15;

}

public class Test

{

public static void main(String argv[])

{

        Test t = new Test();

t.first();

   }

public void first()

{

      int i = 5;

        Value v = new Value();

v.i = 25;

second(v, i);

    System.out.println(v.i);

}

public void second(Value v, int i)

{

i = 0;

        v.i = 20;

Value val = new Value();

        v =  val;

    System.out.println(v.i + " " + i);

               

}

}

Choices:

a. 15 0

   20

b. 15 0

   15

c. 20 0

  20

d. 0 15

  20

―――――――――――――――

A is correct. When we pass references in Java what actually gets passed is the value of that reference (i.e. memory address of the object being referenced and not the actual object referenced by that reference) and it gets passed as value (i.e a copy of the reference is made). Now when we make changes to the object referenced by that reference it reflects on that object even outside of the method being called but any changes made to the reference itself is not reflected on that reference outside of the method which is called. In the example above when the reference v is passed from method first() to second() the value of v is passed. When we assign the value val to v it is valid only inside the method second() and thus inside the method second() what gets printed is 15 (initial value of i in the object referenced by val), then a blank space and then 0 (value of local variable i). After this when we return to the method first() v actually refers to the same object to which it was referring before the method second() was called, but one thing should be noted here that the value of i in that object (referred by v inside the method first()) was changed to 20 in the method second() and this change does reflect even outside the method second(), hence 20 gets printed in the method first(). Thus overall output of the code in consideration is 15 0 20

 

§1.1.4       四

 What will happen when you attempt to compile and run the following code?

interface MyInterface

{

}

public class MyInstanceTest implements MyInterface

{

static String s;

public static void main(String args[])

{

MyInstanceTest t = new MyInstanceTest();

if(t instanceof MyInterface)

{

System.out.println("I am true interface");

}

else

{

System.out.println("I am false interface");

}

if(s instanceof String)

{

System.out.println("I am true String");

}

else

{

System.out.println("I am false String");

}

}

}

Choices:

a. Compiletime error

b. Runtime error

c. Prints : "I am true interface" followed by " I am true String"

d. Prints : "I am false interface" followed by " I am false String"

e. Prints : "I am true interface" followed by " I am false String"

f. Prints : "I am false interface" followed by " I am true String"

――――――――――――

E is the correct choice. The "instanceof" operator tests the class of an object at runtime. It returns true if the class of the left-hand argument is the same as, or is some subclass of, the class specified by the right-hand operand. The right-hand operand may equally well be an interface. In such a case, the test determines if the object at left-hand argument implements the specified interface. In the above case there will not be any compiletime or runtime error. The result of "t instance of MyInterface" will be true as "t" is the object of MyInstanceTest class which implements the MyInstance interface. But the result of "s instanceof String" will be false as "s" refers to null. Thus the output of the above program will be : "I am true interface" followed by " I am false String". Thus choice E is correct and others are incorrect.

 

 

§1.1.5        五

What will happen when you attempt to compile and run the following code snippet?

String str = "Java";

StringBuffer buffer = new StringBuffer(str);

if(str.equals(buffer)){

System.out.println("Both are equal");

}else{

System.out.println("Both are not equal");

}

A. it will print – both are not equal

B. it will print – both are equal

C. compile time error

D. Runtime error

 

A is the correct choice. The equals method overridden in String class returns true if and only if the argument is not null and is a String object that represents the same sequence of characters as this String object. Hence, though the contents of both str and buffer contain "Java", the str.equals(buffer) call results in false.

The equals method of Object class is of form -public boolean equals(Object anObject). Hence, comparing objects of different classes will never result in compile time or runtime error.

 

§1.1.6       六

10. Which of the following statements are true?

　　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

　

　　解析　严格来说这个问题的答案是不确定的，因为equals()方法是可以被重载的，但是

按照java语言的本意来说：如果没有重写（override）新类的equals()，则该方法和

==

操作符一样在两个变量指向同一对象时返回真，但是java推荐的是使用equals()方法来判断

两个对象的内容是否一样，就像String类的equals()方法所做的那样：判定两个String对象的

内容是否相同，而==操作符返回true的唯一条件是两个变量指向同一对象。从这个意义上来说

选择给定的答案。从更严格的意义来说正确答案应该只有d。

 

§1.1.7       七

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 0000

 

　　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

　　翻译

　　使用"<<"和 ">>"操作符的哪些陈述是对的。

 

　　答案　A,C

　　

　　解析　Java的移位操作符一共有三种，分别是”>>”,”>>>”,”<<”,执行的操作分别

是有符号右移，无符号右移，左移，有符号右移的意思是说移入的最高位和原最高符号位相同

，无符号右移是移入位始终补零，左移时最低位始终补零，最高位被舍弃。移位操作符另一个

非常值得注意的特点是其右操作数是取模运算的，意思是说对于一个int型数据而言，对它移

位32位的结果是保持不变而非变成零，即：a>>32的结果是a而不是0，同理，对long型数是对

右操作数取64的模，a>>64==a；还有一点需要注意的是移位操作符”>>>”只对int型和long型

有效，对byte或者short的操作将导致自动类型转换，而且是带符号的。

 

§1.1.8       八

　　String s= "hello";

　　String t = "hello";

　　char c[] = {'h','e','l','l','o'} ;

　　Which return true?

　　A. s.equals(t);

 

　　B. t.equals(c);

 

　　C. s==t;

 

　　D. t.equals(new String("hello"));

 

　　E. t==c.

 

　　(acd)

 

　　题目：哪些返回true。

 

　　这个在前面第10题的equals()方法和==操作符的讨论中论述过。==操作符比较的是操作

符两端的操作数是否是同一个对象，而String的equals()方法比较的是两个String对象的内容

是否一样，其参数是一个String对象时才有可能返回true，其它对象都返回假。需要指出的是

由于s和t并非使用new创建的，他们指向内存池中的同一个字符串常量，因此其地址实际上是

相同的（这个可以从反编译一个简单的测试程序的结果得到，限于篇幅不列出测试代码和反编

译的分析），因此答案c也是正确的。

§1.1.9       九

Class Teacher and Student are subclass of class Person.

　　Person p;

　　Teacher t;

　　Student s;

　　p, t and s are all non-null.

　　if(t instanceof Person) { s = (Student)t; }

　　What is the result of this sentence?

　　A. It will construct a Student object.

 

　　B. The expression_r is legal.

 

　　C. It is illegal at compilation.

 

　　D. It is legal at compilation but possible illegal at runtime.

 

　　(c)

 

　　题目：类Teacher和Student都是类Person的子类

　　…

　　p,t和s都是非空值

　　…

　　这个语句导致的结果是什么

 

　　A. 将构造一个Student对象。

 

　　B. 表达式合法。

 

　　C. 编译时非法。

 

　　D. 编译时合法而在运行时可能非法。

 

　　instanceof操作符的作用是判断一个变量是否是右操作数指出的类的一个对象，由于ja

va语言的多态性使得可以用一个子类的实例赋值给一个父类的变量，而在一些情况下需要判断

变量到底是一个什么类型的对象，这时就可以使用instanceof了。当左操作数是右操作数指出

的类的实例或者是子类的实例时都返回真，如果是将一个子类的实例赋值给一个父类的变量，

用instanceof判断该变量是否是子类的一个实例时也将返回真。此题中的if语句的判断没有问

题，而且将返回真，但是后面的类型转换是非法的，因为t是一个Teacher对象，它不能被强制

转换为一个Student对象，即使这两个类有共同的父类。如果是将t转换为一个Person对象则可

以，而且不需要强制转换。这个错误在编译时就可以发现，因此编译不能通过。

 

李云泽 2009-10-16 11:41 发表评论

§1.1.1       一

1. What will happen when you attempt to compile and run the following code?

public class Static

{

static

{

int x = 5;

}

static int x,y;

public static void main(String args[])

{

       x--;

       myMethod();

       System.out.println(x + y + ++x);

}

public static void myMethod()

{

y = x++ + ++x;

}

}

Choices:

a. Compiletime error

b. prints : 1

c. prints : 2

d. prints : 3

e. prints : 7

f. prints : 8

――――――――――――――――――――

1) D is the correct choice. The above code will not give any compilation error. Note that "Static" is a valid class name. Thus choice A is incorrect. In the above code, on execution, first the static variables (x and y) will be initialized to 0. Then static block will be called and finally main() method will be called. The execution of static block will have no effect on the output as it declares a new variable (int x). The first statement inside main (x--) will result in x to be -1. After that myMethod() will be executed. The statement "y = x++ + ++x;" will be evaluated to y = -1 + 1 and x will become 1. In case the statement be "y =++x + ++x", it would be evaluated to y = 0 + 1 and x would become 1. Finally when System.out is executed "x + y + ++x" will be evaluated to "1 + 0 + 2" which result in 3 as the output. Thus choice D is correct.

 

§1.1.2       二

Considering the following code, Which variables may be referenced correctly at line 12?

1.public class Outer

2.{

3.public int a = 1;

4.private int b = 2;

5.public void method(final int c)

6.{

7.int d = 3;

8.class Inner

9.{

10.private void iMethod(int e)

11. {

12.

13.}

14.}

15.}

16.}

Choices:

a. a

b. b

c. c

d. d

e. e

A, B, C and E are correct. Since Inner is not a static inner class, it has a reference to an enclosing object, and all the variables of that object are accessible. Therefore A and B are correct, even if b is private. Variables in the enclosing method are only accessible when they are marked as final hence c is accessible but not d. E is obviously correct as it is a parameter to the method containing line 12 itself.

 

§1.1.3       三

What will be the result of executing the following code?

// Filename; SuperclassX.java

package packageX;

public class SuperclassX

{

protected void superclassMethodX()

{

}

int superclassVarX;

}

 

// Filename SubclassY.java

1.package packageX.packageY;

2.

3.public class SubclassY extends SuperclassX

4.{

5.SuperclassX objX = new SubclassY();

6.SubclassY objY = new SubclassY();

7.void subclassMethodY()

8.{

9.objY.superclassMethodX();

10.int i;

11.i = objY.superclassVarX;

12.}

13.}

Choices:

a.Compilation error at line 5

b. Compilation error at line 9

c. Runtime exception at line 11

d. None of these

――――――――

D is correct. When no access modifier is specified for a member, it is only accessible by another class in the package where its class is defined. Even if its class is visible in another package, the member is not accessible there. In the question above the variable superclassVarX has no access modifier specified and hence it cannot be accessed in the packageY even though the class SuperclassX is visible and the protected method superclassMethodX() can be accessed. Thus the compiler will raise an error at line 11.

 

§1.1.4       四

 Consider the class hierarchy shown below:

     --------------------------------------------------------------------

class FourWheeler implements DrivingUtilities

class Car extends FourWheeler

class Truck extends FourWheeler

class Bus extends FourWheeler

class Crane extends FourWheeler

----------------------------------------------------------------------

   

Consider the following code below:

1.DrivingUtilities du;

2.FourWheeler fw;

3.Truck myTruck = new Truck();

4.du = (DrivingUtilities)myTruck;

5.fw = new Crane();

6.fw = du;

Which of the statements below are true?

Choices:

a. Line 4 will not compile because an interface cannot refer to an object.

b. The code will compile and run.

c. The code will not compile without an explicit cast at line 6, because going

down the hierarchy without casting is not allowed.

d.The code at line 4 will compile even without the explicit cast.

e.The code will compile if we put an explicit cast at line 6 but will throw an exception at runtime.

―――――――――――

C and D are correct. A and B are obviously wrong because there is nothing wrong in an interface referring to an object. C is correct because an explicit cast is needed to go down the hierarchy. D is correct because no explicit cast is needed at line 4, because we are going up the hierarchy. E is incorrect because if we put an explicit cast at line 6, the code will compile and run perfectly fine, no exception will be thrown because the runtime class of du (that is Truck) can be converted to type FourWheeler without any problem.

 

§1.1.5       五

What will be printed when you execute the following code?

class X

{

Y b = new Y();

       X()

{

System.out.print("X");

}

}

class Y

{

       Y()

{

System.out.print("Y");

}

}

public class Z extends X

{

       Y y = new Y();

       Z()

{

System.out.print("Z");

}

       public static void main(String[] args)

{

               new Z();

       }

}

Choices:

a. Z

b. YZ

c. XYZ

d. YXYZ

―――――――――

D is correct. A difficult but a fundamental question, please observe carefully. Before any object is constructed the object of the parent class is constructed(as there is a default call to the parent's constructor from the constructor of the child class via the super() statement). Also note that when an object is constructed the variables are initialized first and then the constructor is executed. So when new Z() is executed , the object of class X will be constructed, which means Y b = new Y() will be executed and "Y" will be printed as a result. After that constructor of X will be called which implies "X" will be printed. Now the object of Z will be constructed and thus Y y = new Y() will be executed and Y will be printed and finally the constructor Z() will be called and thus "Z" will be printed. Thus YXYZ will be printed.

 

§1.1.6       六

What will happen when you attempt to compile and run the following code?

class Base

{

int i = 99;

public void amethod()

{

       System.out.println("Base.amethod()");

     }

     Base()

{

     amethod();

     }

}

public class Derived extends Base

{

int i = -1;

       

public static void main(String argv[])

{

     Base b = new Derived();

       System.out.println(b.i);

       b.amethod();

     }

     public void amethod()

{

       System.out.println("Derived.amethod()");

     }

}

Choices:

a. Derived.amethod()

-1

Derived.amethod()

b. Derived.amethod()

99

c.Derived.amethod()

99

d. Derived.amethod()

e.Compile time error

――――――――

B is correct. The reason is that this code creates an instance of the Derived class but assigns it to a reference of a the Base class. In this situation a reference to any of the fields such as i will refer to the value in the Base class, but a call to a method will refer to the method in the class type rather than its reference handle. But note that if the amethod() was not present in the base class then compilation error would be reported as at compile time, when compiler sees the statement like b.amethod(), it checks if the method is present in the base class or not. Only at the run time it decides to call the method from the derived class.

 

§1.1.7       七

Given the following code fragment:

 

　　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

 

　　解析

　　SL-275中指出：要为一个新对象分配空间必须执行new

Xxx()调用，new调用执行以下的操作：

 

　　1．为新对象分配空间并将其成员初始化为0或者null。

　

  　2．执行类体中的初始化。（例如在类中有一个成员声明int a=10;在第一步后a=0

，执行到第二步后a=10）

 

　　3．执行构造函数。

 

　　4．变量被分配为一个到内存堆中的新对象的引用。

§1.1.8       八

Which of the following statements about variables and their scopes

are true?

 

　　A. Instance variables are member variables of a class.

 

　　B. Instance variables are declared with the static keyword.

 

　　C. Local variables defined inside a method are created when the method

is executed.

 

　　D. Local variables must be initialized before they are used.

 

　　(acd)

 

　　题目：下面关于变量及其范围的陈述哪些是对的。

 

　　A. 实例变量是类的成员变量。

 

　　B. 实例变量用关键字static声明。

 

　　C. 在方法中定义的局部变量在该方法被执行时创建

 

　　D. 局部变量在使用前必须被初始化。

 

　　类中有几种变量，分别是：局部变量（英文可以为：local\automatic\temporary\stac

k

variable）是定义在方法里的变量；实例变量（英文为：instance

variable）是在方法外而在类声明内定义的变量，有时也叫成员变量；类变量（英文为：cl

ass

variable）是用关键字static声明的实例变量，他们的生存期分别是：局部变量在定义该变

量的方法被调用时被创建，而在该方法退出后被撤销；实例变量在使用new

Xxxx()创建该类的实例时被创建，而其生存期和该类的实例对象的生存期相同；类变量在该

类被加载时被创建，不一定要用new

Xxxx()创建，所有该类的实例对象共享该类变量，其生存期是类的生存期。任何变量在使用

前都必须初始化,但是需要指出的是局部变量必须显式初始化，而实例变量不必，原始类型的

实例变量在该类的构造方法被调用时为它分配的缺省的值，整型是0，布尔型是false，而浮点

型是0.0f，引用类型（类类型）的实例变量的缺省值是null（没有进行实际的初始化，对它的

使用将引起NullPointException），类变量的规则和实例变量一样，不同的是类变量的初始化

是在类被加载时。

§1.1.9       九

　　public class Parent {

　　int change() {…}

　　}

　　class Child extends Parent {

 

　　}

　　Which methods can be added into class Child?

　　A. public int change(){}

 

　　B. int chang(int i){}

 

　　C. private int change(){}

 

　　D. abstract int chang(){}

 

　　(ab)

 

　　题目：哪些方法可被加入类Child。

 

　　需要注意的是答案D的内容，子类可以重写父类的方法并将之声明为抽象方法，但是这引发的问题是类必须声明为抽象类，否则编译不能通过，而且抽象方法不能有方法体，也就是方法声明后面不能带上那两个大括号（{}），这些D都不能满足。

李云泽 2009-10-16 11:40 发表评论

李云泽 2009-10-16 11:39 发表评论

• 能够正确使用if,switch语句，并且能正确使用合法的参数类型。
• 能够正确使用所有带标签或不带标签的循环语句，能正确使用break,continue，能计算在循环中或循环后循环计数器的值。
• 能够正确使用异常和异常处理语句（try,catch,finally）。能正确声明抛出异常的方法，并知道怎样覆盖它。
• 了解代码段中的异常对程序跳转的影响。注意：异常可能是一个运行时异常（runtime exception）,一个已经定义的异常（checked exception），也可能是一个error。
• 能正确使用断言，并了解关于断言机制的正确说法。

 

 

第一节          断言 assert

§1.1.1                     assertion的语法和语义

J2SE 1.4在语言上提供了一个新特性，就是assertion(断言)功能，它是该版本在Java语言方面最大的革新。在软件开发中，assertion是一种经典的调试、测试方式，本文将深入解析assertion功能的使用以及其设计理念，并给出相关的例子。

assertion(断言)在软件开发中是一种常用的调试方式，很多开发语言中都支持这种机制，如C，C++和Eiffel等，但是支持的形式不尽相同，有的是通过语言本身、有的是通过库函数等。另外，从理论上来说，通过assertion方式可以证明程序的正确性，但是这是一项相当复杂的工作，目前还没有太多的实践意义。

在实现中，assertion就是在程序中的一条语句，它对一个boolean表达式进行检查，一个正确程序必须保证这个boolean表达式的值为true；如果该值为false，说明程序已经处于不正确的状态下，系统将给出警告或退出。一般来说，assertion用于保证程序最基本、关键的正确性。assertion检查通常在开发和测试时开启。为了提高性能，在软件发布后，assertion检查通常是关闭的。下面简单介绍一下Java中assertion的实现。

1．1) 语法表示

在语法上，为了支持assertion，Java增加了一个关键字assert。它包括两种表达式，分别如下：

1.       assert expression_r1;

2.       assert expression_r1: expression_r2;

在两种表达式中，expression_r1表示一个boolean表达式，expression_r2表示一个基本类型或者是一个对象(Object) ，基本类型包括boolean,char,double,float,int和long。由于所有类都为Object的子类，因此这个参数可以用于所有对象。

1．2) 语义含义

在运行时，如果关闭了assertion功能，这些语句将不起任何作用。如果打开了assertion功能，那么expression_r1的值将被计算，如果它的值为false，该语句强抛出一个AssertionError对象。如果assertion语句包括expression_r2参数，程序将计算出expression_r2的结果，然后将这个结果作为AssertionError的构造函数的参数，来创建AssertionError对象，并抛出该对象；如果expression_r1值为true，expression_r2将不被计算。

一种特殊情况是，如果在计算表达式时，表达式本身抛出Exception，那么assert将停止运行，而抛出这个Exception。

1．3) 一些assertion例子

下面是一些Assert的例子。

1.       assert　　0 < value;

2.       assert　　0 < value:"value="+value;

3.       assert　　ref != null:"ref doesn't equal null";

4.       assert　　isBalanced();

1．4) 编译

由于assert是一个新关键字，使用老版本的JDK是无法编译带有assert的源程序。因此，我们必须使用JDK1.4(或者更新)的Java编译器，在使用Javac命令时，我们必须加上-source 1.4作为参数。-source 1.4表示使用JDK 1.4版本的方式来编译源代码，否则编译就不能通过，因为缺省的Javac编译器使用JDK1.3的语法规则。

一个简单的例子如下：

javac      -source   1.4    test.java

1．5) 运行

由于带有assert语句的程序运行时，使用了新的ClassLoader和Class类，因此，这种程序必须在JDK1.4(或者更高版本)的JRE下运行，而不能在老版本的JRE下运行。

1.       由于我们可以选择开启assertion功能，或者不开启，另外我们还可以开启一部分类或包的assertion功能，所以运行选项变得有些复杂。通过这些选项，我们可以过滤所有我们不关心的类，只选择我们关心的类或包来观察。

§1.1.2                     assertion的设计问题

首先，我们认为assertion是必要的。因为，如果没有统一的assertion机制，Java程序通常使用if-then-else或者switch-case语句进行assertion检查，而且检查的数据类型也不完全相同。assertion机制让Java程序员用统一的方式处理assertion问题，而不是按自己的方式处理。另外，如果用户使用自己的方式进行检查，那么这些代码在发布以后仍然将起作用，这可能会影响程序的性能。而从语言言层次支持assertion功能，这将把assertion对性能带来的负面影响降到最小。

Java是通过增强一个关键字assert实现支持assertion，而不是使用一个库函数支持，这说明Java认为assertion对于语言本身来说是非常重要的。实际上，在Java的早期的规范中，Java是能够支持assert的，但是由于一些实现的限制，这些特性从规范中除去了。因此，assert的再次引入应该是恢复了Java对assert的支持。C语言就是通过Assert.h函数库实现断言的支持。

Java的assertion的开启也和C语言不太一样，我们都知道在C语言中，assertion的开启是在编译时候决定的。当我们使用debug方式编译程序时候，assertion被开启，而使用release方式编译时候，assertion自动被关闭。而Java的assertion却是在运行的时候进行决定的。其实，这两种方式是各有优缺点。如果采用编译时决定方式，开发人员将处理两种类型的目标码，debug版本和release版本，这加大了文档管理的难度，但是提高了代码的运行效率。Java采用运行时决定的方式，这样所有的assertion信息将置于目标代码中，同一目标代码可以选择不同方式运行，增强目标代码的灵活性，但是它将牺牲因为assertion而引起一部分性能损失。Java专家小组认为，所牺牲的性能相当小，因此java采用了运行时决定方式。

另外，我们注意到AssertionError作为Error的一个子类，而不是RuntimeException。关于这一点，专家组也进行了长期的讨论。Error代表一些异常的错误，通常是不可以恢复的，而RuntimeException强调该错误在运行时才发生的特点。AssertionError通常为非常关键的错误，这些错误往往是不容易恢复的，而且assertion机制也不鼓励程序员对这种错误进行恢复。因此，为了强调assertion的含义，Java专家小组选择了让AssertError为Error的子类。

§1.1.3                     assertion与继承

在本节，我们将考虑assertion与继承的关系，研究assert是如何定位的。如果开启一个子类的assertion，那么它的父类的assertion是否执行？

下面的例子将显示如果一个assert语句在父类，而当它的子类调用它时，该assert为false。我们看看在不同的情况下，该assertion是否被处理。

class Base

{

  public void baseMethod()

  { // 总是assertion失败

    assert      false : "Assertion failed:This is base ";

    System.out.println("Base Method");

  }

}

 

class Derived

  extends Base

{

  public void derivedMethod()

  { // 总是assertion失败

    assert false: "Assertion failed:This is derive";

    System.out.println( "Derived Method" );

  }

 

  public static void main( String[] args )

  {

    try

    {

      Derived derived = new Derived();

 

      derived.baseMethod(  );

 

      derived.derivedMethod();

    }

    catch( AssertionError ae )

    {

      System.out.println(ae);

    }

  }

}

运行命令	含义	结果
Java Derived	不启用assertion	Base Method Derived Method
Java -ea Derived	开启所有assertion	Java.lang.AssertionError:Assertion Failed:This is base
Java -da Derived	关闭所有assertion	Base Method Derived Method
Java -ea:Base Derived	仅打开Base的assertion	Java.lang.AssertionError:Assertion Failed:This is base
Java -ea:Derived Derived	仅打开Derived的assertion	Base Method Java.lang.AssertionError:Assertion Failed:This is derived

从这个例子我们可以看出，父类的assert语句将只有在父类的assert开启才起作用，如果仅仅开启子类的assert，父类的assert仍然不运行。例如，我们执行java -ea:Derived Derived的时候，Base类的assert语句并不执行。因此，我们可以认为，assert语句不具有继承功能。

§1.1.4                     assertion的使用

assertion的使用是一个复杂的问题，因为这将涉及到程序的风格，assertion运用的目标，程序的性质等问题。通常来说，assertion用于检查一些关键的值，并且这些值对整个程序，或者局部功能的完成有很大的影响，并且这种错误不容易恢复的。assertion表达式应该短小、易懂，如果需要评估复杂的表达式，应该使用函数计算。以下是一些使用assertion的情况的例子，这些方式可以让java程序的可靠性更高。

1.       检查控制流；在if-then-else和swith-case语句中，我们可以在不应该发生的控制支流上加上assert false语句。如果这种情况发生了，assert能够检查出来。
例如：x取值只能使1,2,3，我们的程序可以如下表示

2.                   switch (x)

3.                   { case 1: …;

4.                     case 2: …;

5.                     case 3: …

6.                     default: assert false:"x value is invalid: "+x;

7.           }

8.       在私有函数计算前，检查输入参数是否有效；对于一私有些函数，要求输入满足一些特定的条件，那么我们可以在函数开始处使用assert进行参数检查。对于公共函数，我们通常不使用assertion检查，因为一般来说，公共函数必须对无效的参数进行检查和处理。而私有函数往往是直接使用的。
例如：某函数可能要求输入的参数必须不为null。那么我们可以在函数的一开始加上 assert parameter1!=null : "paramerter is null in test method";

9.       在函数计算后，检查函数结果是否有效；对于一些计算函数，函数运行完成后，某些值需要保证一定的性质，因此我们可以通过assert检查该值。
例如，我们有一个计算绝对值的函数，那么我们就可以在函数的结果处，加上一个语句：

assert  value>=0:"Value should be bigger than 0:"+value;

通过这种方式，我们可以对函数计算完的结果进行检查。

10.   检查程序不变量；有些程序中，存在一些不变量，在程序的运行生命周期，这些不变量的值都是不变的。这些不变量可能是一个简单表达式，也可能是一个复杂的表达式。对于一些关键的不变量，我们可以通过assert进行检查。
例如，在一个财会系统中，公司的支出和收入必须保持一定的平衡关系，因此我们可以编写一个表达式检查这种平衡关系，如下表示。

11.                 private boolean isBalance() {

12.                  ……

13.                }

          

在这个系统中，在一些可能影响这种平衡关系的方法的前后，我们都可以加上assert验证：assert isBalance():"balance is destoried";

§1.1.5                     结论

assertion为开发人员提供了一种灵活地调试和测试机制，它的使用也非常简单、方便。但是，如何规范、系统地使用assertion(特别是在Java语言中)仍然是一个亟待研究的问题

李云泽 2009-10-16 11:38 发表评论

§1.1.1     一

In the following pieces of code, A and D will compile without any error. True/False?

A: StringBuffer sb1 = "abcd";

B: Boolean b = new Boolean("abcd");

C: byte b = 255;

D: int x = 0x1234;

E: float fl = 1.2;

 

Choices:

A. True

B. False

―――――――――――――――――――――――――――――――

答案 B. The code segments B and D will compile without any error. A is not a valid way to construct a StringBuffer, you need to creat a StringBuffer object using "new". B is a valid construction of a Boolean (any string other than "true" or "false" to the Boolean constructor will result in a Boolean with a value of "false"). C will fail to compile because the valid range for a byte is -128 to +127 (ie, 8 bits,signed). D is correct, 0x1234 is the hexadecimal representation in java. E fails to compile because the compiler interprets 1.2 as a double being assigned to a float (down-casting), which is not valid. You either need an explicit cast (as in "(float)1.2") or "1.2f", to indicate a float.

 

 

 

§1.1.2       二

What will be the result of executing the following code?

Given that Test1 is a class.

1. Test1[] t1 = new Test1[10];

2. Test1[][] t2 = new Test1[5][];

3. if (t1[0] == null)

4. {

5.t2[0] = new Test1[10]

6.t2[1] = new Test1[10]

7.t2[2] = new Test1[10]

8.t2[3] = new Test1[10]

9.t2[4] = new Test1[10]

10. }

11. System.out.println(t1[0]);

12. System.out.println(t2[1][0]);

Choices:

a. The code will not compile because the array t2 is not initialized in an unconditional statement before use.

b. The code will compile but a runtime exception will be thrown at line 12.

c. The code will compile but a runtime exception will be thrown at line 11.

d. None of these.

―――――――――――――――――――――

D is correct. Though we cannot use local variables without initializing them (compilation error), there is an exception to it. In case of arrays initialization is supposed to be complete when we specify the leftmost dimension of the array. The problem occurs at runtime if we try to access an element of the array which has not been initialized (specification of size). In the question above the array t2 is initialized before use, therefore there will be no problem at runtime also and the lines 11 and 12 will both print null.

 

§1.1.3       三

Which declarations of identifiers are legal?

　A. $persons

　　B. TwoUsers

　　C. *point

　　D. this

    E. _endline

　　

　　答案　A,B,E

　　

　　解析　Java的标识符可以以一个Unicode字符，下滑线（_），美元符（$）开始，后续字

符可以是前面的符号和数字，没有长度限制，大小写敏感，不能是保留字。

 

§1.1.4       四

Which of the following answer is correct to express the value 8 in octal number?

　　A. 010

　　B. 0x10

　　C. 08

　　D. 0x8

 

　　翻译

　　下面的哪些答案可以用以表示八进制值8。

　　答案　A

 

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

 

§1.1.5       五

Which are not Java keywords?

　　A. TRUE

　　B. sizeof

　　C. const

　　D. super

　　E. void

 

　　翻译

　　哪些不是Java关键字。

 

　　答案　A,B

 

　　解析

　  A：不是，Java中有true,但是这也不是关键字而是字面量（literal）。

　B：不是，Java中不需要这个操作符，所有的类型（原始类型）的大小都是固定的。

　C、D、E都是，需要说明的是const是java中未被使用的关键字。

 

§1.1.6       六

Which statements about Java code security are true?

　　A. The bytecode verifier loads all classes needed for the execution of a program.

　　B. Executing code is performed by the runtime interpreter.

　　C. At runtime the bytecodes are loaded, checked and run in an interpreter.

　　D. The class loader adds security by separating the namespaces for the

classes of the local file system from those imported from network sources.

 

――――――――――――――

答案 BCD

 

§1.1.7       七

　　题目：下面有关java代码安全性的叙述哪些是对的。

　　A. 字节码校验器加载查询执行需要的所有类。

 

　　B. 运行时解释器执行代码。

 

　　C. 在运行时，字节码被加载，验证然后在解释器里面运行。

 

　　D. 类加载器通过分离本机文件系统的类和从网络导入的类增加安全性。

 

　　SL275中描述的Java程序运行的过程是这样的：类加载器（class loader）加载程序运行所需要的所有类，它通过区分本机文件系统的类和网络系统导入的类增加安全性，这可以限制任何的特洛伊木马程序，因为本机类总是先被加载，一旦所有的类被加载完，执行文件的内存划分就固定了，在这个时候特定的内存地址被分配给对应的符号引用，查找表（lookuo table）也被建立，由于内存划分发生在运行时，解释器在受限制的代码区增加保护防止未授权的访问；然后字节码校验器（byte code verifier）进行校验，主要执行下面的检查：类符合JVM规范的类文件格式，没有违反访问限制，代码没有造成堆栈的上溢或者下溢，所有操作代码的参数类型都是正确的，没有非法的数据类型转换（例如将整型数转换成对象类型）发生；校验通过的字节码被解释器（interpreter）执行，解释器在必要时通过运行时系统执行对底层硬件的合适调用。后三个答案是SL275中的原话。

§1.1.8       八

Which fragments are correct in Java source file?

　　A. package testpackage;

　　public class Test{//do something...}

 

　　B. import java.io.*;

　　package testpackage;

　　public class Test{// do something...}

 

　　C. import java.io.*;

　　class Person{// do something...}

　　public class Test{// do something...}

 

　　D. import java.io.*;

　　import java.awt.*;

　　public class Test{// do something...}

 

------------------------

答案 ACD

　

§1.1.9       九

Which of the following statements are legal?

　　A. long l = 4990;

　　B. int i = 4L;

　　C. float f = 1.1;

　　D. double d = 34.4;

　　E. double t = 0.9F.

----------------------------

答案　ADE

 

李云泽 2009-10-16 11:37 发表评论