What is the result?

A. yo ey

B. hey oh hi

C. hey oh hi ey

D. oh hi hey

E. hey oh hi yo ey

F. yo hey oh hi ey

G. Compilation fails.

H. An exception is thrown at runtime.

Answer (for Objective 1.3):

Image E is correct. The final contents of sb is "yo ey". Remember that the static initializer runs before any instances are created.

Image A, B, C, D, F, G, and H are incorrect based on the above.

36. Given:

         1. class Hotel {
         2.   static void doStuff(int x) {
         3.     assert (x < 0) : "hotel";
         4.   }
         5. }
         6. public class Motel13 extends Hotel {
         7.   public static void main(String[] args) {
         8.     doStuff(-5);
         9.     int y = 0;
        10.     assert (y < 0) : "motel";
        11. } }

Which of the following invocations will run without exception? (Choose all that apply.)

A. java Motel13

B. java -ea Motel13

C. java -da:Hotel Motel13

D. java -da:Motel13 Motel13

E. java -ea -da:Hotel Motel13

F. java -ea -da:Motel13 Motel13

Answer (for Objective 2.3):

Image A, C, D, and F are correct. When assertions are enabled, the Motel13 class will throw an AssertionError, the Hotel class will not. Invocations A, C, and D do not enable assertions for Motel13. F is correct because although assertions were enabled, the "–da" switch selectively disabled assertions for the Motel13 class.

Image B and E are incorrect because assertions are enabled for Motel13.

37. Given:

         3. class One {
         4.   void go1() { System.out.print("1 ");  }
         5.   final void go2() { System.out.print("2 "); }
         6.   private void go3() { System.out.print("3 "); }
         7. }
         8. public class OneB extends One {
         9.   void go1() { System.out.print("1b "); }
        10.   void go3() { System.out.print("3b "); }
        11.
        12.  public static void main(String[] args) {
        13.    new OneB().go1();
        14.    new One().go1();
        15.    new OneB().go2();
        16.    new OneB().go3();
        17.    new One().go3();
        18. } }

What is the result?

A. 1 1 2 3 3

B. 1b 1 2 3b 3

C. 1b 1b 2 3b 3b

D. Compilation fails due to a single error.

E. Compilation fails due to errors on more than one line.

Answer (for Objective 1.4):

Image D is correct. The only error is on line 17: Class OneB cannot find class One’s private go3() method. Note that on line 10 we’re NOT overriding class One’s go3() method.

Image A, B, C, and E are incorrect based on the above.

38. Given:

         3. public class Gauntlet {
         4.   public static void main(String[] args) {
         5.     String r = "0";
         6.     int x = 3, y = 4;
         7.     boolean test = false;
         8.     if((x > 2) || (test = true))
         9.     if((y > 5) || (++x == 4))
        10.     if((test == true) || (++y == 4))
        11.     r += "1";
        12.     else if(y == 5) r += "2";
        13.     else r += "3";
        14.     else r += "4";
        15.     // else r += "5";
        16.     System.out.println(r);
        17. } }

And given that, if necessary you can add line 15 to make the code compile, what is the result? (Choose all that apply.)

A. At line 10, test will equal true

B. At line 10, test will equal false

C. The output will be 02

D. The output will be 03

E. The output will be 023

F. The code will compile as is.

G. The code will only compile if line 15 is added.

Answer (for Objective 2.1):

Image B, C, and F are correct. Line 8 doesn’t change the value of test because of the short circuit operator. The first two ifs are true, but the third is false (although "y" is incremented), so the "else if" is executed. The code compiles as is because not all if statements need to have matching else statements.

Image A, D, E, and G are incorrect based on the above.

39. Given:

         2. import rt.utils.Remote;
         3. public class Controller{
         4.   public static void main(String[] args){
         5.   Remote remote = new Remote();
         6. } }

And rt.utils.Remote class is properly bundled into a JAR file called rtutils.jar.

And given the following steps:

P. Place rtutils.jar in the $ROOT directory.

Q. Extract rtutils.jar and put rt directory with its subdirectories in the $ROOT directory.

R. Extract rtutils.jar and place Remote.class in the $ROOT directory.

S. Place rtutils.jar in the $JAVA_HOME/jre/lib/ext directory.

X. Compile using: javac -cp rtutils.jar Controller.java

Y. Compile using: javac Controller.java

Z. Compile using: javac -cp . Controller.java

If Controller.java resides in the $ROOT directory, which set(s) of steps will compile the Controller class? (Choose all that apply.)

A. P -> X

B. Q -> Y

C. R -> Z

D. P -> Z

E. R -> Y

F. S -> X

G. S -> Z

Answer (for Objective 7.5):

Image A, B, F and G are correct. When the JAR is placed in any directory other than $JAVA_HOME/jre/lib/ext directory, it should be included in the classpath. If the JAR file is in the $JAVA_HOME/jre/lib/ext directory, it’s NOT necessary to include the JAR in the classpath. If the JAR file is extracted, the complete directory structure should exist on the classpath.

Image C, D, and E are incorrect based on the above.

40. Given:

         2. public class Boot {
         3.   static String s;
         4.   static { s = ""; }
         5.   { System.out.print("shinier "); }

         6.   static { System.out.print(s.concat("better ")); }
         7.   Boot() { System.out.print(s.concat("bigger ")); }
         8.   public static void main(String[] args) {
         9.     new Boot();
        10.     System.out.println("boot");
        11. } }

What is the result?

A. better bigger boot

B. better bigger shinier boot

C. better shinier bigger boot

D. bigger shinier better boot

E. shinier better bigger boot

F. A NullPointerException is thrown at runtime.

G. An ExceptionInInitializationError is thrown at runtime.

Answer (for Objective 2.6):

Image C is correct. static init blocks run before instance init blocks (in the order in which they appear, respectively), and init blocks run hard on the heels of a constructor’s call to super().

Image A, B, D, E, F, and G are incorrect based on the above.

41. Fill in the blanks using the following fragments, so the code compiles and produces the output: "0 4 "

Note: You might not need to fill in all of the blanks, you won’t use all of the fragments, and each fragment can be used only once.

Code:

          import __________________
          public class Latte {   public static void main(String[] args) {
            Pattern p = ________________
            Matcher m = p.matcher(__________________);
            while(_____________)
              System.out.print(______________ + " ");
         } }

Fragments:

Image

Answer (for Objective 3.4):

        import java.util.regex.*; public class Latte {
        public static void main(String[] args) {
          Pattern p = Pattern.compile("aba");
          Matcher m = p.matcher("abababa");
          while(m.find())
            System.out.print(m.start() + " ");
          }
        }

42. Given:

         3. public static void main(String[] args) {
         4.   try {
         5.     throw new Error();
         6.   }
         7.   catch (Error e) {
         8.     try { throw new RuntimeException(); }
         9.     catch (Throwable t) { }
        10.  }
        11.  System.out.println("phew");
        12. }

Which are true? (Choose all that apply.)

A. The output is phew

B. The code runs without output.

C. Compilation fails due to an error on line 5.

D. Compilation fails due to an error on line 7.

E. Compilation fails due to an error on line 8.

F. Compilation fails due to an error on line 9.

Answer (for Objective 2.4):

Image A is correct. It’s legal to throw and handle errors and runtime exceptions. RuntimeException is a sub-subclass of Throwable.

Image B is incorrect because the code produces "phew". C, D, E, and F are incorrect based on the above.

43. Given:

         1. import java.util.*;
         2. public class Analyzer {
         3.   static List<Exception> me;
         4.   Exception myEx;
         5.   public static void main(String[] args) {
         6.     Analyzer[] aa = {new Analyzer(), new Analyzer()};
         7.     me = new ArrayList<Exception>();
         8.     for(int i = 0; i < 2; i++) {
         9.       try {
        10.         if(i == 0) throw new Exception();
        11.         if(i == 1) throw new MyException();
        12.      }
        13.       catch(Exception e) {
        14.         me.add(e);
        15.         aa[i].myEx = e;
        16.      }
        17.   }
        18.   System.out.println(aa.length + " " + me.size());
        19.   aa = null; me = null;
        20.   // do more stuff
        21. } }
        22. class MyException extends Exception { }

When line 20 is reached, how many objects are eligible for garbage collection?

A. 2

B. 4

C. 5

D. 6

E. 7

F. 8

Answer (for Objective 7.4):

Image D is correct. Line 6 creates three objects: an array and two Analyzer objects. Line 7 creates an ArrayList object. Line 10 and 11 each create some sort of Exception object. While it’s true that each Analyzer also has a reference to an Exception object, those references are referring to the same exceptions that are in the array.

Image A, B, C, E, and F are incorrect based on the above.

44. Given the following from the java.io.File API:

Field Summary: static String separator

Method Summary: static File[] listRoots()

And given:

         2. // insert code here
         3. // insert code here
         4. public class Eieio {
         5.   public static void main(String[] args) {
         6.     try {
         7.       String s = "subdir" + separator + "myFile.txt";
         8.       java.io.File f = new java.io.File(s);
         9.       java.io.FileReader fr = new java.io.FileReader(f);
        10.       java.io.File[] r = listRoots();
        11.       fr.close();
        12.     }
        13.     catch(Exception e) { }
        14. } }

And the following four fragments:

I. import java.io.*;

II. import static java.io.File.*;

III. import static java.io.File.separator;

IV. import static java.io.File.listRoots;

Which set(s) of fragments, inserted independently on lines 2 and/or 3, will compile? (Choose all that apply.)

A. Fragment I

B. Fragment II

C. Fragments I and III

D. Fragments I and IV

E. Fragments II and IV

F. Fragments III and IV

Answer (for Objective 7.1):

Image B, E, and F are correct. The code provides some fully qualified names from the java.io package, but the names for the "separator" field and the listRoots() method are not fully qualified. Fragment II alone is the correct “static import” syntax, and therefore B and E are correct. Fragment III provides the name for separator, and fragment IV provides the name for listRoots(), so taken together III and IV will compile.

Image A, C, and D are incorrect based on the above.

45. Given:

         1. import java.util.*;
         2. public class Bucket {
         3.   public static void main(String[] args) {
         4.     Set<String> hs = new HashSet<String>();
         5.     Set<String> lh = new LinkedHashSet<String>();
         6.     Set<String> ts = new TreeSet<String>();
         7.     List<String> al = new ArrayList<String>();
         8.     String[] v = {"1", "3", "1", "2"};
         9.     for(int i=0; i< v.length; i++) {
        10.       hs.add(v[i]);  lh.add(v[i]);  ts.add(v[i]);  al.add(v[i]);
        11.    }
        12.    Iterator it = hs.iterator();
        13.    while(it.hasNext()) System.out.print(it.next() + " ");
        14.    Iterator it2 = lh.iterator();
        15.    while(it2.hasNext()) System.out.print(it2.next() + " ");
        16.    Iterator it3 = ts.iterator();
        17.    while(it3.hasNext()) System.out.print(it3.next() + " ");
        18.    Iterator it5 = al.iterator();
        19.    while(it5.hasNext()) System.out.print(it5.next() + " ");
        20. } }

Which statements are true? (Choose all that apply.)

A. An exception is thrown at runtime.

B. Compilation fails due to an error on line 18.

C. "1 3 2" is only guaranteed to be in the output once.

D. "1 2 3" is only guaranteed to be in the output once.

E. "1 3 2" is guaranteed to be in the output more than once.

F. "1 2 3" is guaranteed to be in the output more than once.

G. "1 3 1 2" is guaranteed to be in the output at least once.

H. Compilation fails due to error(s) on lines other than line 18.

Answer (for Objective 6.1):

Image C, D, and G are correct. The code is all legal and runs without exception. For HashSets, iteration order is not guaranteed. For LinkedHashSets, iteration order equals insertion order. For TreeSets, the default iteration order is ascending. For ArrayLists, iteration order is by index, and when using add(), index “kind of” equals insertion order. Of course, Sets don’t allow duplicates.

Image A, B, E, F, and H are incorrect based on the above.

46. Given:

         2. public class Maize {
         3.   public static void main(String[] args) {
         4.     String s = "12";
         5.     s.concat("ab");
         6.     s = go(s);
         7.     System.out.println(s);
         8.   }
         9.   static String go(String s) {
        10.     s.concat("56");
        11.     return s;
        12. } }

What is the result?

A. ab

B. 12

C. ab56

D. 12ab

E. 1256

F. 12ab56

G. Compilation fails.

Answer (for Objective 3.1):

Image B is correct. Strings are immutable. If we captured the result of line 5, we would have "12ab", but we didn’t capture that, so that String is lost. Similarly, the result of line 10 is lost.

Image A, C, D, E, F, and G are incorrect based on the above.

47. Given:

         4. class MySuper { protected MySuper() { System.out.print("ms "); } }
         5. public class MyTester extends MySuper {
         6.   private MyTester() { System.out.print("mt "); }
         7.   public static void main(String[] args) {
         8.     new MySuper();
         9.     class MyInner {
        10.       private MyInner() { System.out.print("mi "); }
        11.       { new MyTester(); }
        12.       { new MySuper(); }
        13.     }
        14.     new MyInner();
        15. } }

What is the result?

A. ms mi mt ms

B. ms mt ms mi

C. ms mi ms mt ms

D. ms ms mt ms mi

E. Compilation fails.

F. An exception is thrown at runtime.

Answer (for Objective 5.3):

Image D is correct. MyTester can access MySuper’s protected constructor, and MyInner can access MyTester’s private constructor. As far as the order goes, the MyInner code is invoked after it’s declared. When the MyInner code does run, the instance init blocks run after MyInner’s constructor’s call to super(), and before the rest of the constructor runs. Remember that a new instance of MyTester calls MySuper’s constructor.

Image A, B, C, E and F are incorrect based on the above.

48. Given:

         2. public class Tshirt extends Thread {
         3.   public static void main(String[] args) {
         4.     System.out.print(Thread.currentThread().getId() + " ");
         5.     Thread t1 = new Thread(new Tshirt());
         6.     Thread t2 = new Thread(new Tshirt());
         7.     t1.start();
         8.     t2.run();
         9.  }

        10.  public void run() {
        11.    for(int i = 0; i < 2; i++)
        12.      System.out.print(Thread.currentThread().getId() + " ");
        13. } }

Which are true? (Choose all that apply.)

A. No output is produced.

B. The output could be 1 1 9 9 1

C. The output could be 1 2 9 9 2

D. The output could be 1 9 9 9 9

E. An exception is thrown at runtime.

F. Compilation fails due to an error on line 4.

G. Compilation fails due to an error on line 8.

Answer (for Objective 4.1):

Image B is correct. It’s legal to get the ID of the "main" thread. It’s also legal to call run() directly, but it won’t start a new thread. In this case, it’s just invoking run() on main’s call stack. In this code, t2 is never started, so there are only two threads (main and t1), therefore only two IDs are in the output. D is incorrect because no thread’s getId() method is called more than three times.

Image A, C, E, F, and G are incorrect based on the above.

49. Given:

        14.  FileWriter fw1 =
               new FileWriter(new File("f1.txt"));
        15.  FileWriter fw2 =
               new FileWriter(new BufferedWriter(new PrintWriter("f2.txt")));
        16.  PrintWriter pw1 =
               new PrintWriter(new BufferedWriter(new FileWriter("f3.txt")));
        17.  PrintWriter pw2 =
               new PrintWriter(new FileWriter(new File("f4.txt")));

And given the proper imports and error handling, what is the result?

A. Compilation succeeds.

B. Compilation fails due to multiple errors.

C. Compilation fails due only to an error on line 14.

D. Compilation fails due only to an error on line 15.

E. Compilation fails due only to an error on line 16.

F. Compilation fails due only to an error on line 17.

Answer (for Objective 3.2):

Image D is correct. The code is using so-called “chained-methods” (or constructors) syntax. The *objects* fw1, pw1, and pw2 are created correctly. The *object* fw2 cannot be created because a FileWriter cannot be constructed using a BufferedWriter object.

Image A, B, C, E, and F are incorrect based on the above.

50. Given:

         2. import java.util.*;
         3. public class GIS {
         4.   public static void main(String[] args) {
         5.   TreeMap<String, String> m1 = new TreeMap<String, String>();
         6.   m1.put("a", "amy"); m1.put("f", "frank");
         7.   NavigableMap<String, String> m2 = m1.descendingMap();
         8.   try {
         9.     m1.put("j", "john");
        10.     m2.put("m", "mary");
        11.   }
        12.   catch (Exception e) { System.out.print("ex "); }
        13.   m1.pollFirstEntry();
        14.   System.out.println(m1 + " " + m2);
        15. } }

What is the result?

A. {f=frank, j=john} {f=frank}

B. {f=frank, j=john} {m=mary, f=frank}

C. ex {f=frank, j=john} {f=frank}

D. {f=frank, j=john, m=mary} {m=mary, j=john, f=frank}

E. ex {f=frank, j=john, m=mary} {f=frank}

F. ex {f=frank, j=john, m=mary} {f=frank, a=amy}

G. {a=amy, f=frank, j=john, m=mary} {f=frank, a=amy}

H. Compilation fails due to error(s) in the code.

Answer (for Objective 6.3):

Image D is correct. The descendingMap() method creates a NavigableMap in reverse order, which is “backed” to the map it was created from. It is NOT a subMap, so there is no worry about being outside of its range. The pollFirstEntry() method returns AND removes the “first” entry in the Map.

Image A, B, C, E, F, G, and H are incorrect based on the above.

51. Given:

         2. public class Clover extends Harrier {
         3.   String bark() { return "feed me "; }
         4.   public static void main(String[] args) {
         5.     Dog[] dogs = new Dog[3];
         6.     dogs[0] = new Harrier();
         7.     dogs[1] = (Dog)new Clover();
         8.     dogs[2] = (Dog)new Harrier();
         9.     for(Dog d: dogs)  System.out.print(d.bark());
        10. } }
        11. class Dog { String bark() { return "bark "; } }
        12. class Harrier extends Dog { String bark() { return "woof "; } }

What is the result? (Choose all that apply.)

A. bark bark bark

B. woof bark bark

C. woof feed me woof

D. Compilation fails due to an error on line 6.

E. Compilation fails due to an error on line 7.

F. Compilation fails due to an error on line 8.

G. Compilation fails due to an error on line 9.

Answer (for Objective 5.2):

Image C is correct. All the code is legal, and line 9 is using a for-each loop. The polymorphic invocations of bark() use the version of bark() that corresponds with the object’s type, not the reference variable’s type.

Image A, B, D, E, F, and G are incorrect based on the above.

52. Given:

         1. public class Egg<E extends Object> {
         2.   E egg;
         3.   public Egg(E egg) {
         4.     this.egg=egg;
         5.  }
         6.  public E getEgg() {
         7.    return egg;
         8.  }
         9.  public static void main(String[] args) {
        10.    Egg<Egg> egg1 = new Egg(42);
        11.    Egg egg2 = new Egg<Egg>(egg1.getEgg());
        12.    Egg egg3 = egg1.getEgg();
        13. } }

Which are true? (Choose all that apply).

A. Compilation fails.

B. An exception is thrown at runtime.

C. Line 10 compiles with a warning.

D. Line 10 compiles without warnings.

E. Line 11 compiles with a warning.

F. Line 11 compiles without warnings.

Answer (for Objective 6.4):

Image B, C, and F are correct. Compiler warnings are given when assigning a non-generic object to a reference with generic type. F is correct and E is incorrect, because the reference type of egg2 doesn’t have any generic type specification. Line 12 assigns the return value of egg1.getEgg() to egg3. It compiles because the compiler assumes that the return value of egg1.getEgg() will be an Egg. B is correct because at runtime, the actual return type will be an Integer, which causes a ClassCastException to be thrown.

Image A, D, and E are incorrect based on the above.

53. Given:

         2. public class Tolt {
         3.   public static void checkIt(int a) {
         4.     if(a == 1)  throw new IllegalArgumentException();
         5.  }

         6.  public static void main(String[] args) {
         7.    for(int x=0; x<2; x++)
         8.      try {
         9.        System.out.print("t ");
        10.        checkIt(x);
        11.        System.out.print("t2 ");
        12.     }
        13.     finally { System.out.print("f "); }
        14. } }

What is the result?

A. "t t2 f t "

B. "t t2 f t f "

C. "t t2 f t t2 f "

D. "t t2 f t ", followed by an exception.

E. "t t2 f t f ", followed by an exception.

F. "t t2 f t t2 f ", followed by an exception.

G. Compilation fails.

Answer (for Objective 2.5):

Image E is correct. As far as the exception goes, it’s thrown during the second iteration of the for loop, and it’s uncaught and undeclared (which is legal since it’s a runtime exception). Remember, finally (almost) ALWAYS runs. In main(), the code is legal: the entire try-finally code is considered a single statement from the for loop’s perspective, and of course the idea of a try-finally is legal; a catch statement is not required.

Image A, B, C, D, F, and G are incorrect based on the above.

54. Given:

         2. class Noodle {
         3.   String name;
         4.   Noodle(String n) { name = n; }
         5. }
         6. class AsianNoodle extends Noodle {
         7.   public boolean equals(Object o) {
         8.     AsianNoodle n = (AsianNoodle)o;
         9.     if(name.equals(n.name))  return true;
        10.     return false;
        11.  }

        12.  public int hashCode() { return name.length(); }
        13.    AsianNoodle(String s) { super(s); }
        14. }
        15. public class Soba extends AsianNoodle {
        16.   public static void main(String[] args) {
        17.     Noodle n1 = new Noodle("bob");  Noodle n2 = new Noodle("bob");
        18.     AsianNoodle a1 = new AsianNoodle("fred");
        19.     AsianNoodle a2 = new AsianNoodle("fred");
        20.     Soba s1 = new Soba("jill");  Soba s2 = new Soba("jill");
        21.     System.out.print(n1.equals(n2) + " " + (n1 == n2) + " | ");
        22.     System.out.print(a1.equals(a2) + " " + (a1 == a2) + "| ");
        23.     System.out.println(s1.equals(s2) + " " + (s1 == s2));
        24.  }
        25.     Soba(String s) { super(s); }
        26. }

What is the result?

A. Compilation fails.

B. true true | true true | true true

C. true false | true false | true false

D. false false | true false | true false

E. false false | true false |false

F. false false | false false |false false

Answer (for Objective 6.2):

Image D is correct. Noodle uses the default equals() method that returns true only when comparing two references to the same object. AsianNoodle overrides equals() (and Soba inherits the overridden method) and uses the name variable to determine equality. The == operator ALWAYS compares to see whether two reference variables refer to the same object.

Image A, B, C, E, and F are incorrect based on the above.

55. Given:

         2. public class Checkout2 implements Runnable {
         3.   void doStuff() { }
         4.   synchronized void doSynch() {
         5.      try { Thread.sleep(1000); }
         6.      catch (Exception e) { System.out.print("e "); }

         7.  }
         8.  public static void main(String[] args) {
         9.    long start = System.currentTimeMillis();
        10.    new Thread(new Checkout2()).start();
        11.      Thread t1 = new Thread(new Checkout2());
        12.      t1.start();
        13.      try { t1.join(); }
        14.      catch (Exception e) { System.out.print("e "); }
        15.      System.out.println("elapsed: " + (System.currentTimeMillis() - start));
        16.   }
        17.   public void run() {
        18.     for(int j = 0; j < 4; j++) {
        19.       doStuff();
        20.       try { Thread.sleep(1000); }
        21.         catch (Exception e) { System.out.print("e "); }
        22.         doSynch();
        23. } } }

Which are true? (Choose all that apply.)

A. Compilation fails.

B. Elapsed time will be about eight seconds.

C. Elapsed time will be about nine seconds.

D. Elapsed time will be about 12 seconds.

E. Changing doSynch() to be unsynchronized will change elapsed by only a few milliseconds.

F. Changing doSynch() to be unsynchronized will change elapsed by 450 or more milliseconds.

Answer (for Objective 4.3):

Image B and E are correct. Even when doSynch() is synchronized, the two run() invocations aren’t running against the same Checkout2 object. This code creates two distinct Checkout2 objects, so there is no synchronization.

Image A, C, D, and F are incorrect based on the above.

56. Your virtual-world simulator is designed such that Grobnets can have several Ooflas, and Yazells support the contract implied by Whompers. Grobnets are a type of Yazell, and can also act as Floordums or Whompers. Which of the following code fragments legally represent this design? (Choose all that apply.)

A. import java.util.*;

interface Floordum { }

interface Whomper { }

class Grobnet extends Yazell implements Floordum { List<Oofla> o; }

class Oofla { }

class Yazell implements Whomper { }

B. import java.util.*;

class Oofla { }

class Yazell implements Whomper { }

class Floordum { }

interface Whomper { }

class Grobnet extends Yazell, Floordum { List<Oofla> o; }

C. import java.util.*;

interface Floordum { }

interface Whomper { }

class Grobnet extends Yazell implements Floordum, Oofla { }

class Oofla { }

interface Yazell implements Whomper { }

D. import java.util.*;

interface Floordum { }

interface Whomper { }

class Grobnet extends Yazell implements Floordum { Set<Oofla> o; }

class Oofla { }

class Yazell { Whomper w; }

Answer (for Objective 5.5):

Image A is correct. The phrase translations are “can have” usually means a class has an instance variable, or set of variables; “support the contract implied” should be taken to mean implementing an interface; “type of” typically means subclass; “can act as” is often another way to say implement an interface. Notice in answer A that Grobnet indirectly implements Whompers by extending Yazells.

Image B, C, and D are incorrect. B is incorrect because a class can’t extend more than one class. C is incorrect because implementing an interface is not the same as having an instance variable of the interface’s type. In addition, interfaces can’t implement interfaces. D is incorrect because Yazell has-a Whomper and the design calls for Yazell to implement Whompers.

57. Given:

         1. import java.util.*;
         2. public class Ps {
         3.   public static void main(String[] args) {
         4.     PriorityQueue<String> pq = new PriorityQueue<String>();
         5.     pq.add("4");
         6.     pq.add("7");
         7.     pq.add("2");
         8.     // insert code here
         9. } }

Which code fragment(s), inserted independently at line 8, produce the output "2-4-7-"? (Choose all that apply.)

A. Iterator it2 = pq.iterator();

while(it2.hasNext()) System.out.print(it2.next() + "-");

System.out.println();

B. Arrays.sort(pq.toArray());

Iterator it3 = pq.iterator();

while(it3.hasNext()) System.out.print(it3.next() + "-");

System.out.println();

C. Object[] pqa = pq.toArray();

Arrays.sort(pqa);

for(Object o: pqa) System.out.print(o + "-");

System.out.println();

D. String s = pq.poll();

while (s != null) {

System.out.print(s + "-");

s = pq.poll();

}

E. String s = pq.peek();

while (s != null) {

System.out.print(s + "-");

s = pq.peek();

}

Answer (for Objective 6.1):

Image C and D are correct ways to determine how elements in the PriorityQueue would be prioritized, although D consumes the queue in the process.

Image A is incorrect because the Iterator for PriorityQueue does NOT guarantee a sorted result. B is incorrect because the toArray() method creates a new array, it doesn’t change the existing array. E is incorrect because peek() only looks at a queue’s “first” element, it doesn’t consume it, so an infinite loop is created. Note: If you didn’t get answer A that’s okay. Answer A might be a little bit on the trivia end of the spectrum. So if you got this question correct except for answer A, give yourself full credit.

58. Given that the current directory is bigApp, and the following directory structure:

Image

And the code:

       package com.wickedlysmart;
       public class BigAppClass1 {
         int doStuff() { return 42; }
       }

And the following command-line invocations:

I. javac -d source/com/wickedlysmart/BigAppClass1.java

II. javac -d classes source/com/wickedlysmart/BigAppClass1.java

III. javac -d classes/com/wickedlysmart source/com/wickedlysmart/BigAppClass1.java

Which are true? (Choose all that apply.)

A. Invocation I will compile the file and place the .class file in the bigApp directory.

B. Invocation II will compile the file and place the .class file in the classes directory.

C. Invocation I will compile the file and place the .class file in the wickedlysmart directory.

D. Under the bigApp/classes directory, invocation II will build com/wickedlysmart subdirectories, and place the .class file in wickedlysmart.

E. Under the bigApp/classes directory, invocation III will build com/wickedlysmart subdirectories, and place the .class file in wickedlysmart.

Answer (for Objective 7.2):

Image D correctly describes the results that the "-d" option will produce.

Image A and C will not compile. E inaccurately describes the directories that will be built. B is incorrect based on the above.

59. Given:

         2. class Jog implements Runnable {
         3.   public void run() {
         4.     for(int i = 0; i < 8; i++) {
         5.       try { Thread.sleep(200); }
         6.       catch (Exception e) { System.out.print("exc "); }
         7.       System.out.print(i + " ");
         8. } } }
         9. public class Marathon {
        10.   public static void main(String[] args) throws Exception {
        11.     Jog j1 = new Jog();
        12.     Thread t1 = new Thread(j1);
        13.     t1.start();
        14.     t1.sleep(500);
        15.     System.out.print("pre ");
        16.     t1.interrupt();
        17.     t1.sleep(500);
        18.     System.out.print("post ");
        19. } }

Assuming that sleep() sleeps for about the amount of time specified in its argument, and that all other code runs almost instantly, which output is likely? (Choose all that apply.)

A. exc

B. 0 1 pre exc post

C. exc 0 1 2 3 4 5 6 7

D. pre post 0 1 2 3 4 5 6 7

E. pre exc 0 1 post 2 3 4 5 6 7

F. 0 1 pre exc 2 3 4 post 5 6 7

Answer (for Objective 4.2):

Image F is correct. Remember that sleep() is static and that when a sleeping thread is interrupted, an InterruptedException is thrown. In this code, the t1 thread is started, and then the main thread sleeps for 500 milliseconds. While the main thread is sleeping, t1 sleeps and then iterates a couple of times. When main wakes up, it interrupts t1 (which is almost certainly sleeping), causing the exception, which is handled. Then, main goes back to sleep for a while, t1 iterates a few more times, and main reawakens and completes, and finally t1 completes.

Image A, B, C, D, and E are incorrect based on the above.

60. Given:

         2. class Explode {
         3.   static String s = "";
         4.   static { s += "sb1 "; }
         5.   Explode() { s += "e "; }
         6. }
         7. public class C4 extends Explode {
         8.   C4() {
         9.     s += "c4 ";
        10.    new Explode();
        11.  }
        12.  static {
        13.    new C4();
        14.    System.out.print(s);
        15.  }
        16.  { s += "i "; }
        17.  public static void main(String[] args) { }
        18. }

And given the command-line invocation "java C4", what is the result?

A. e c4 i

B. e i c4

C. e sb1 i c4

D. sb1 e i c4 e

E. sb1 e c4 i e

F. Compilation fails.

G. A StackOverflowError is thrown.

H. An exception other than StackOverflowError is thrown.

Answer (for Objective 5.4):

Image D is correct. Static init blocks run once, when a class is first loaded. Instance init blocks run after a constructor’s call to super(), but before the rest of the constructor runs. It’s legal to invoke new() from within a constructor, and when a subclass invokes new() on a superclass no recursive calls are implied.

Image A, B, C, E, F, G, and H are incorrect based on the above.

Analyzing Your Results

First, we have to come clean. We tried to make this last exam the toughest one in the book.

Table 7-1 is based partly on the assumption that this last exam is a bit tougher than the real thing. We hear from a lot of candidates, and we understand that everyone has different goals. If your goal is to score over 90 percent on the real exam, then you have to analyze your results differently than if your goal is to pass comfortably. The following table is based on a couple of assumptions:

Image This last exam is a bit tougher than the real thing.

Image Your goal is to pass comfortably. By that, we mean that when you take the real exam you don’t just barely squeak (squeal?) by with a passing score, but that you’re also pleased even if you don’t get 90 percent.

As we’ve said several times, as of this writing, a passing score on the OCP Java SE Programmer exam is 58.33 percent (35 out of 60 questions).

Image

TABLE 7-1 What Your Score Means If You Want to Pass Comfortably

..................Content has been hidden....................

You can't read the all page of ebook, please click here login for view all page.
Reset