Java Programmer Certification Exam

interface Searchable {
    Searchable getSearchbale();
}

public class Sample {
    public Sample() {
        Sample s = new Sample(); // Circular execution or compile time error?
    }
}

public class Mod {
    public static void main(String argv[]) {
    }
 
    public static native void amethod();
}

public class A {
    public A() {
        this("dummy"); // Compile-time error: recursive constructor invocation
    }
 
    public A(int i) {
        this(99); // Compile-time error: recursive constructor invocation
    }
 
    public A(String s) {
        this(); // Compile-time error: recursive constructor invocation
    }
 
    public static final void main(String[]) {
        A o1 = new A();
        A o2 = new A(5);
    }
}

1: public enum ImageFormat {
2:     TIFF, JPEG;
3:
4:     private static final void main(String[] args) {
5:     }
6: }

1. declares this method as private → attempt to narrow the visibility → error (early problem detection)
2. declares this methods as protected → the method is overridden → pitfall.
   Mark the method in parent class as “final” (maybe temporary) when doing this refactoring.

1. chopWoodAndCarryWater() is an example of appropriate cohesion.
2. chopWoodAndCarryWater() is an example of inappropriate cohesion.
3. chopWoodAndCarryWater() is an example of appropriate coupling.
4. chopWoodAndCarryWater() is an example of inappropriate coupling.

 1: public abstract class A<T>
 2: {
 3:     abstract T a(int i) {}
 4:     public native b(String s);
 5:     static abstract void c();
 6:     static protected char d() {}
 7:     T protected e() { return null; }
 8:     static T x() {}
 9:     public void y() {}
10: }
11:
12: class B extends A<Object>
13: {
14:     Object a(int i) { return i; }
15:     private char d() {}
16:     private void y() {}
17: }

1: String s = "xyz";
2: Integer i = (Integer) s;

How to cast from String to Integer?

 1: interface Writeable {
 2:     long write(int i);
 3: }
 4:
 5: class Basic {
 6:     protected long write(int n) {
 7:         System.out.println("A: " + n);
 8:         return n;
 9:     }
10: }
11:
12: abstract class AbstractWriteable extends Basic implements Writeable {
13:     public long write(String s) {
14:         System.out.println("B: " + s);
15:         return s.length();
16:     }
17: }
18:
19: class WriteableImpl extends AbstractWriteable {
20:     public int write(int m) {
21:         System.out.println("C: " + m);
22:         return Character.forDigit(m, 10); // returns char
23:     }
24:
25:     public static void main(String[] args) {
26:         WriteableImpl impl = new WriteableImpl();
27:         impl.write(5);
28:
29:         AbstractWriteable a = impl;
30:         a.write(4);
31:         a.write("4");
32:
33:         Basic b = a;
34:         b.write(3);
35:         b.write("3");
36:
37:         Writeable w = b;
38:         w.write('2');
39:     }
40: }

1. The code does not compile, because abstract class AbstractWriteable goes not implement Writeable interface.
2. The code does not compile, because abstract class AbstractWriteable tries to reduce the visibility of write(int i) method.
3. The code does not compile, because class WriteableImpl goes not implement Writeable interface correctly.
4. The code does not compile in line 38 with message The function Writeable.write(char) is not defined.
5. The code compiles OK, what is the output in this case?
6. What can you say about the type casting in lines 15, 22 and 38?

 1: class Animal {
 2:     public Animal() {
 3:         callMe();
 4:     }
 5:
 6:     public void callMe() {
 7:     }
 8: }
 9:
10: class Monkey extends Animal {
11:     int a = 5;
12:
13:     public Monkey() {
14:         // callMe(); // we want to do it, but it's not allowed
15:         super();
16:     }
17:
18:     public void callMe() {
19:         System.out.println("I am called before super class initialization has completed");
20:         System.out.println("a=" + a);
21:     }
22: }

Examine the following:

byte b = 0; // OK, implicit cast
int i = new Integer(200); // OK, unboxing
 
b = b + 5; // compilation error: cannot convert from int to byte
b += 5; // OK: implicit cast
b *= i; // OK: implicit cast, although looks like the result of multiplication is "int"

byte b = 10b; // Compilation error: "b" datatype suffix is incorrect
byte b1 = 20; // OK, casting is not necessary
char c = 19c; // Compilation error: "c" datatype suffix is incorrect; char c = 19 is fine (does not need casting)
char c1 = 0x1234; // OK
char c2 = \u1234; // Compilation error: the value should be enclosed into single quotes '\u1234'.
double d = 1.2d; // OK
double f = 3.2f; // OK, automatic widening from float to double
int i = 019; // Compilation error: "019" is out-of-range octal number
Short s = 1; // OK, narrowing primitive from int to short
Long l = 10; // Compilation error (which is not logical) as widening from "int" to "long" does not happen, see [1]. Correct is "Long l = 10L".
Object i = 2; // OK, auto-boxing to Integer
i = i + '2'; // OK
c = c + i; // Compilation error: right-side expression has "int" type and should be explicitly casted to "char"
c += 100L; // OK

[1] See Narrowing of primitive followed by boxing.

System.out.println(010|4);
int i = 10, j = 4;
System.out.println(i|j);
System.out.println(i||j);

byte x = 127;
x += 2;
System.out.println("x: " + x);

 1: public static void main(String[] args) {
 2:     System.out.println(Integer.MAX_VALUE - 255 == (int) (Integer.MAX_VALUE - 255f));
 3:     System.out.println(Integer.MAX_VALUE - 5 == (int) (Integer.MAX_VALUE - 5f));
 4:
 5:     doIntToFloatConversion(Integer.MAX_VALUE - 0xFF); // equals to 2^31 - 256
 6:     doIntToFloatConversion(Integer.MAX_VALUE - 5); // equals to 2^31 - 6
 7:
 8:     System.out.println("b: " + String.format("%.2f", Float.valueOf(33554432e10f))); // can you write this number?
 9: }
10:
11: static void doIntToFloatConversion(int i) {
12:     float f = i;
13:
14:     System.out.println("i: " + i + " (0x" + Integer.toString(i, 16) + ")");
15:     System.out.println("f: " + String.format("%.2f", Float.valueOf(f)));
16:     System.out.println("i: " + (int) f + " (0x" + Integer.toString((int) f, 16) + ")");
17:     System.out.println("l: " + (long) f + " (0x" + Long.toString((long) f, 16) + ")");
18: }

1. byte, short, int, long, float, double
2. short, int, long, float, double
3. int, long, float, double

byte b = 11;
short s = 13;
result = b * ++s;

float tmp = (float) num1 * num2;
int result = (int) tmp;
 
if (result != tmp) {
    // ops, overflow
    throw new OverflowException();
}

int[] a = new int[3];
long[] b = new long[4];
long[] c = new long[10];
 
b[0] = a[0]; // OK
b = a; // Type mismatch: cannot convert from int[] to long[]
b = c; // OK, size does not matter

int[] a = new int[3];
a[1L] = 4; // Compilation error: index should be "int" value
a[2.0] = 2; // Compilation error: index should be "int" value

int[][] a = new int[][];
int[][] b = new int[3][2];
int[][] c = new int[3][];
int[][] d = new int[][3];
int e[] = [10, 11, 12, 13];
Byte[] a = new Byte[] {100, 200, 300};

String[] arr = new String[2];
arr[0] = "text";
Object[] brr = arr;
brr[1] = Boolean.TRUE;

1: Integer a = 1000, b = 1000;
2: System.out.println(a == b);
3:
4: Integer c = 100, d = 100;
5: System.out.println(c == d);

 1: import java.io.File;
 2: import java.net.MalformedURLException;
 3: import java.net.URL;
 4:
 5: public class Test {
 6:
 7:     static final URL url;
 8:
 9:     static {
10:         try {
11:             url = new URL("http://www.google.com"); // 1: Is called first, because it is static class initializer
12:         }
13:         catch (MalformedURLException e) {}
14:     }
15:
16:     {
17:         final File file = new File("input.txt"); // 2: Is called first, because it is shared instance initialization block
18:         count++; // count is 1 after this line is executed
19:         message = "Test";
20:     }
21:
22:     int count = 5; // 3: Is called first, because it is instance variable initializer
23:
24:     {
25:         count++; // 4:
26:     }
27:
28:     final String message;
29:
30:     public Test() {
31:         super(); // 5: Is called first, because super class needs to be initialized first
32:         message = "Hello, user "; // 6:
33:     }
34:
35:     public static void main(String[] args) {
36:         Test t = new Test(); // 7: Is called first to invoke the constructor
37:         System.out.println(t.message + t.count);
38:     }
39: }

 1: public class Test {
 2:     private static final byte MAX = getMax();
 3:
 4:     private static final byte getMax() {
 5:         return Byte.MAX_VALUE;
 6:     }
 7:
 8:     public boolean hasMax(byte[] bytes) {
 9:         for (int i = 0; i < bytes.length; i++) {
10:             switch (bytes[i]) {
11:                 case MAX:
12:                     return true;
13:             }
14:         }
15:
16:         return false;
17:     }
18: }

1. Class does not compile because of error in line 17.
2. Program executes OK. What is the output? How to modify the code that another overloaded function is invoked in line 16?

 1: class Test {
 2:
 3:     public void print(int a) {
 4:         System.out.println("I " + a);
 5:     }
 6:
 7:     public void print(int... a) {
 8:         System.out.println("A " + Arrays.toString(a));
 9:     }
10:
11:     public void print(Object a) {
12:         System.out.println("O " + a);
13:     }
14:
15:     public void test() {
16:         print(1);
17:         print();
18:         print(null);
19:         print(1.2f);
20:     }
21: }

1. Class does not compile because of ambiguous overload in line 7.
2. Program executes OK. What is the output? How to modify the code that another overloaded function is invoked instead?

 1: class Test1 {
 2:
 3:     public void print(byte n1, byte n2) {
 4:         System.out.println("X " + n1 + n2);
 5:     }
 6:
 7:     public void print(int n1, int n2) {
 8:         System.out.println("Y " + n1 + n2);
 9:     }
10:
11:     public void test() {
12:         print(1, 2);
13:     }
14: }

 1: class Test2 {
 2:
 3:     public void print(float n1, float n2) {
 4:         System.out.println("X " + n1 + n2);
 5:     }
 6:
 7:     public void print(double n1, double n2) {
 8:         System.out.println("Y " + n1 + n2);
 9:     }
10:
11:     public void test() {
12:         print(1, 2);
13:         print(1.0, 2);
14:     }
15: }

 1: class Test3 {
 2:
 3:     public void print(int n1, int n2) {
 4:         System.out.println("X " + n1 + n2);
 5:     }
 6:
 7:     public void print(float n1, float n2) {
 8:         System.out.println("Y " + n1 + n2);
 9:     }
10:
11:     public void print(double n1, double n2) {
12:         System.out.println("Z " + n1 + n2);
13:     }
14:
15:     public void test() {
16:         print(1l, 2);
17:     }
18: }

public void power(Object n) {
    Integer b = (Integer) n;
    for (int i = 0; i < 5; i++)
        b *= b; // auto-unboxing, incrementing and auto-boxing (page 245)
    System.out.println("b=" + b); // What is the output? It will be 2^(2*2*2*2*2) = 2^32 = 0
}
 
public void test() {
    power(2); // auto-boxing to Integer and widening to Object (page 252)
}

1. System.gc();
2. System.free();
3. Set the value of each variable to null
4. None of the above

public void amethod() {
    Integer i = new Integer(1);
    Integer j = new Integer(2);
    Integer k = new Integer(3);
 
    // insert here
}

1. Enclose the offending code in a try block, with a catch block for ArrayIndexOutOfBoundsException that prints out a descriptive message.
2. Declare that the method that contains the offending code throws ArrayIndexOutOfBoundsException.
3. None of the above.

Object n = null;
 
if (!(n instanceof Integer)) // it is known that instanceof returns false when the left operand is null
{
    Integer i = (Integer) n; // OK, but may look like NullPointerException or ClassCastException at runtime
}

int m = 1, n = 2;
String s = null;
System.out.println(m + n + s); // OK or NullPointerException?
System.out.println(s + m + n); // OK or NullPointerException?

 1: public class Test {
 2:
 3:     public static Integer callMe() {
 4:         int a = 0;
 5:         return(++(a++)); // Compilation error: Invalid argument to operation ++/--
 6:     }
 7:
 8:     public static int runMe() {
 9:         int b = 0;
10:         return(++b + b++);
11:     }
12:
13:     public static void main(String[] args) {
14:         callMe() + 1; // Compilation error: The left-hand side of an assignment must be a variable
15:         runMe()++; // Compilation error: Invalid argument to operation ++/--
16:     }
17: }

System.out.println(+~5);

int a[] = { 4, 5 };
int b = 1;
a[b] = b = 0;

public class Test {
    enum Format {
        JPEG, PNG, GIF // (1) Compilation error: ";" is missing at the end of enumeration list
    }
 
    public void process(Format format) {
        int i;
 
        if (format != null) {
            switch (format) {
                default: // (2) Compilation error: "default" statement should go last after all "case" statements
                    i = 0;
                case Format.JPEG: // (3) Compilation error: The qualified case label Format.JPEG must be replaced with the unqualified enum constant JPEG
                    i = 1;
                    break;
                case Format.PNG:
                    i = 2;
                    break;
            }
        }
 
        System.out.println("i=" + i); // (4) Compile error: The local variable may not have been initialized
    }
}

 1: public class Test {
 2:     public void test(int i) {
 3:         outer : i++;
 4:
 5:         if (i > 2) break outer;
 6:
 7:         System.out.print(i + " ");
 8:
 9:         test(i);
10:     }
11:
12:     public static void main(String[] args) {
13:         new Test().test(0);
14:     }
15: }

1: for (int i = 7, long j = 0; i < 10; j++) { }
2: for (int i = 7, j = 0;; j++) { }
3: int j; for (int k = 0; j + k != 10; j++, k++) { }
4: int i; for (i++, int j = 0; i < 10; j++) { }
5: for (String s = ""; s.length() < 10; s += '!') { }
6: for (final String s : new String[]{"test"}) { }
7: int k; for (k: new int[]{1, 2, 3}) { }

Let's assume that you have programmed the interface for your library:

import java.io.IOException;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.TransformerException;
import org.xml.sax.SAXException;
 
public interface XMLConfigurator {
    String getXMLConfigurationValue(String configurationName) throws ParserConfigurationException, SAXException, TransformerException, IOException;
}

and some implementation:

import ...;
 
public class XMLConfiguratorImpl implements XMLConfigurator {
 
    String getXMLConfigurationValue(String configurationName) throws ParserConfigurationException, SAXException,
                TransformerException, IOException {
        return ""; // in practise should do something sensible
    }
}

but when somebody was using your library for example like below:

import ...;
 
public class MainModule {
 
    XMLConfigurator xmlConfigurator = new XMLConfiguratorImpl();
 
    public void readConfiguration() {
        String value;
 
        try {
            value = xmlConfigurator.getXMLConfigurationValue("color");
        }
        catch (ParserConfigurationException e) {
            e.printStackTrace();
        }
        catch (SAXException e) {
            e.printStackTrace();
        }
        catch (TransformerException e) {
            e.printStackTrace();
        }
        catch (IOException e) {
            e.printStackTrace();
        }
    }
}

he found out that exception handling was complicated to handle (a lot of catch clauses). So you decided to change API to following:

import ...;
 
public interface XMLConfigurator {
    String getXMLConfigurationValue(String configurationName) throws Exception;
}

so now the exception handling looks much easier:

try {
    value = xmlConfigurator.getXMLConfigurationValue("color");
}
catch (Exception e) {
    e.printStackTrace();
}

Questions:

1. Does interface implementation XMLConfiguratorImpl need any changes to confirm a new API?
2. What is the pitfall of new exception handling approach? What is the better solution?

public void amethod() {
    outer : for (int i = 0; i < 2; i++) {
        for (int j = 0; j < 2; j++) {
            System.out.println("i=" + i + " j= " + j);
            if (i > 0) break outer;
        }
    }
    System.out.println("Continuing with i set to =" + i);
}

1. Compile time error

2. i=0 j= 0
   i=0 j= 1
   i=1 j= 0

3. i=0 j= 0
   i=0 j= 1
   i=1 j= 0
   i=2 j= 0

4. i=0 j= 0
   i=0 j= 1

char[] numbers = new char[] { '1', '2', '3' };
System.out.println(numbers + "");
System.out.println(numbers);
System.out.println((Object) numbers);

 1: import java.io.ByteArrayInputStream;
 2: import java.io.ByteArrayOutputStream;
 3: import java.io.IOException;
 4: import java.io.ObjectInputStream;
 5: import java.io.ObjectOutputStream;
 6: import java.io.Serializable;
 7:
 8: public class Test {
 9:
10:     enum Type {
11:         FATHER, MOTHER
12:     }
13:
14:     public static class Parent implements Serializable {
15:         Parent parent;
16:         Type   type;
17:
18:         public Parent(Type type) {
19:             parent = this;
20:             this.type = type;
21:         }
22:     }
23:
24:     public static void main(String[] args) throws IOException, ClassNotFoundException {
25:         Parent parent = new Parent(Type.MOTHER);
26:         Parent parentClone;
27:
28:         assert parent == parent.parent; // true or false?
29:
30:         ByteArrayOutputStream bos = new ByteArrayOutputStream();
31:
32:         ObjectOutputStream os = new ObjectOutputStream(bos);
33:         os.writeObject(parent);
34:         os.close();
35:
36:         ObjectInputStream is = new ObjectInputStream(new ByteArrayInputStream(bos.toByteArray()));
37:         parentClone = (Parent) is.readObject();
38:         is.close();
39:
40:         assert parent == parentClone; // true or false?
41:         assert parent.parent == parentClone.parent; // true or false?
42:         assert parentClone == parentClone.parent; // true or false?
43:         assert parentClone.type == parent.type; // true or false?
44:     }
45: }

final Path path = Paths.get(...);
 
Files.lines(path).forEach(System.out::println);

NumberFormat nf = NumberFormat.getInstance();
nf.setMaximumFractionDigits(3);
System.out.println(nf.parse("222.5678"));
System.out.println(nf.format(123.4687));

 1: import java.util.HashMap;
 2: import java.util.Map;
 3:
 4: public class Test {
 5:
 6:     public static void main(String[] args) {
 7:         Map<Number, String> m = new HashMap();
 8:
 9:         m.put(13, "super");
10:
11:         String s1 = "super";
12:
13:         m.put(13L, s1);
14:
15:         String s2 = new String("super");
16:
17:         m.put((short) 13, s2);
18:
19:         String s3 = new StringBuffer().append("super").toString();
20:
21:         m.put((byte) 13, s3);
22:
23:         String t = m.get(13);
24:
25:         assert m.size() == 4; // true or false?
26:         assert "super" == t; // true or false?
27:         assert m.get(13L) == t; // true or false?
28:         assert m.get((short) 13) == t; // true or false?
29:         assert m.get((byte) 13) == t; // true or false?
30:     }
31: }

1: public final int hashCode() { // note that the method is final and you can't override it
2:     return super.hashCode();
3: }

is replaced by the following:

1: public final int hashCode() {
2:     return ordinal();
3: }

Is it still a valid hashCode() implementation? Is it better or worse hashCode() implementation in comparison to original?

 1: public class Class<Class extends Serializable> {
 2:     Class Class; // Here "Class" is "this" Class or parametrization type or java.lang.Class?
 3:
 4:     public Class(Class Class) {
 5:         this.Class = Class;
 6:     }
 7:
 8:     java.lang.Class<?> getClass(Class Class) {
 9:         return Class.getClass();
10:     }
11: }
12:
13: class SuperClass extends Class<Number> {
14:
15:     @Override
16:     java.lang.Class<?> getClass(Integer Class) {
17:         return super.getClass(Class);
18:     }
19: }

 1: public static <A extends Number> List<A> process1(List<A> nums) {
 2:     return nums;
 3: }
 4:
 5: public static <A extends Number, B extends Number> List<A> process2(List<B> nums) {
 6:     return nums; // The return type does not match the passed parameter, as A is not the same as B.
 7: }
 8:
 9: public static void test() {
10:     List<Number> listN = null;
11:     List<Integer> listI = null;
12:
13:     listN = process1(listN);
14:     listI = process1(listI);
15:
16:     listI = process1(listN); // In this line and the next line there is an error, because List<Number> and List<Integer> are different collections,
17:     listN = process1(listI); // which cannot be casted to each other, even though Integer is a Number.
18:
19:     listN = process2(listN);
20:     listI = process2(listI);
21:
22:     listI = process2(listN);
23:     listN = process2(listI);
24: }

Collection<? extends Number> c = new ArrayList<Long>();
ArrayList<Number> list = new ArrayList<Number>();
list.addAll(c);

public int compareTo(Object o) {
   Employee emp = (Employee) o;
   return this.id - emp.id;
}

where id is an integer number.

 1: public class Test {
 2:
 3:     public class Inner {
 4:         String caption;
 5:
 6:         public Inner(String caption) {
 7:             this.caption = caption;
 8:         }
 9:
10:         public String toString() {
11:             return "Caption: " + caption;
12:         }
13:     }
14:
15:     public Inner test(String title) {
16:         return new Inner("Main dialog") {
17:             public String toString() {
18:                 return "Title: " + title;
19:             }
20:         };
21:     }
22:
23:     public static void main(String[] args) {
24:         System.out.println("Result: " + Test().test("Popup"));
25:     }
26: }

 1: public class Test {
 2:
 3:     static class Parent {
 4:         private final String name;
 5:
 6:         public Parent(String name) {
 7:             this.name = name;
 8:         }
 9:
10:         public String getName() {
11:             return name;
12:         }
13:     }
14:
15:     public static void main(String[] args) {
16:         Test test = new Test();
17:
18:         test.print(test.new Parent("John") {
19:             public String getName() {
20:                 return "Actual: " + super.getName();
21:             }
22:         });
23:     }
24:
25:     void print(Parent parent) {
26:         System.out.println(parent.getName());
27:     }
28: }

 1: public class Outer {
 2:     private int i;
 3:
 4:     static class Inner<T extends Child> {
 5:         public void test(T o) {
 6:             Outer outer = o;
 7:             outer.i = 1; // Can "i" be accessed here?
 8:             outer.j = 2; // Can "j" be accessed here?
 9:
10:             Child child = o;
11:             child.i = 3; // Can "i" be accessed here?
12:             child.j = 4; // Can "j" be accessed here?
13:         }
14:     }
15:
16:     public static void main(String[] args) {
17:         new Outer.Inner().test(new Child());
18:     }
19: }
20:
21: class Child extends Outer {
22:     private int j;
23:
24:     public Child() {
25:         super.i = 5; // Can "i" be accessed here?
26:     }
27: }

1. Compilation and sample output 0 1 2 3
2. Compilation and sample output 1 2 2 2
3. Compilation and sample output 3 3 3 3
4. Compilation and no output
5. Compile time error: class Sample is an abstract class. It can't be instantiated.

public class Sample extends Thread {
    public static void main(String argv[]) {
        System.out.print(Thread.currentThread().getId() + " ");
        Sample r = new Sample();
        r.run();
    }
 
    public void run() {
        for (int i = 0; i < 3; i++)
            System.out.print(Thread.currentThread().getId() + " ");
    }
}

1. When the application is run, thread hp1 will execute; threads hp2 and hp3 will never get the CPU.
2. When the application is run, thread hp1 will execute to completion, thread hp2 will execute to completion, then thread hp3 will execute to completion.
3. When the application is run, all three threads (hp1, hp2, and hp3) will execute concurrently, taking time-sliced turns in the CPU.
4. None of the above scenarios can be guaranteed to happen in all cases.

class HiPri extends Thread {
    HiPri() {
        setPriority(10);
    }
 
    public void run() {
        System.out.println("Another thread starting up.");
        while (true) { }
    }
 
    public static void main(String args[]) {
        HiPri hp1 = new HiPri();
        HiPri hp2 = new HiPri();
        HiPri hp3 = new HiPri();
        hp1.start();
        hp2.start();
        hp3.start();
    }
}

1. The code will not compile, because InterruptedException is not thrown by Thread.sleep().
2. At line 2, the thread will stop running. Execution will resume in at most 100 milliseconds.
3. At line 2, the thread will stop running. It will resume running in exactly 100 milliseconds.
4. At line 2, the thread will stop running. It will resume running some time after 100 milliseconds have elapsed.

1: try {
2:     Thread.sleep(100);
3: } catch (InterruptedException e) { }

1. aThread.notify();
2. aThread.notifyAll();
3. aThread.interrupt();
4. sharedOb.notify();
5. sharedOb.notifyAll();

int x = 0;
boolean bExit = false;

Thread 1 (not synchronized):

x = 1;
bExit = true;

Thread 2 (not synchronized):

if (bExit == true)
    System.out.println("x=" + x);