Java SE 8 Programmer II (OCP) Free Sample Questions

Given the definition of the Vehicle class:

Class Vehicle {

int distance;

Vehicle (int x) {

this distance = x;

}

public void increSpeed(int time) {

int timeTravel = time; //line n1

//line n3

class Car {

int value = 0;

public void speed () {

value = distance /timeTravel;//line n2

System.out.println (“Velocity with new speed'+value+'kmph');

}

}

speed();//line n3

}

}

and this code fragment:

Vehicle v = new Vehicle (100);

v.increSpeed(60);

What is the result?

Given:

IntStream stream = IntStream.of (1,2,3);

IntFunction(Integer) inFu= x -) y -) x*y;//line n1

IntStream newStream = stream.map(inFu.apply(10));//line n2 newStream.forEach(System.out::print);

Which modification enables the code fragment to compile?

Given the code fragment:

List(Integer) values = Arrays.asList (1, 2, 3);

values.stream ()

.map(n -) n*2)//line n1

.peek(System.out::print)//line n2

.count();

What is the result?

Given the code fragment:

public class Foo {

public static void main (String [ ] args) {

Map(Integer, String) unsortMap = new HashMap( ) ( );

unsortMap.put (10, “z');

unsortMap.put (5, “b');

unsortMap.put (1, “d');

unsortMap.put (7, “e');

unsortMap.put (50, “j');

Map(Integer, String) treeMap = new TreeMap (Integer, String) (new

Comparator(Integer) ( ) {

@Override public int compare (Integer o1, Integer o2) {return o2.compareTo

(o1); } } );

treeMap.putAll (unsortMap);

for (Map.

Entry(Integer, String) entry : treeMap.entrySet () ) {

System.out.print (entry.getValue () + “ “);

}

}

}

What is the result?

Which two reasons should you use interfaces instead of abstract classes? (Choose two.)

Given:

public class Counter {

public static void main (String[ ] args) {

int a = 10;

int b = -1;

assert (b )=1) : “Invalid Denominator';

int = a / b;

System.out.println (c);

}

}

What is the result of running the code with the -ea option?

Given:

class Bird {

public void fly () { System.out.print(“Can fly'); }

}

class Penguin extends Bird {

public void fly () { System.out.print(“Cannot fly'); }

}

and the code fragment:

class Birdie {

public static void main (String [ ] args) {

fly( ( ) -) new Bird ( ));

fly (Penguin : : new);

}

/* line n1 */

}

Which code fragment, when inserted at line n1, enables the Birdie class to compile?

Given:

1. abstract class Shape {

2. Shape ( ) { System.out.println (“Shape'); }

3. protected void area ( ) { System.out.println (“Shape'); }

4. }

6. class Square extends Shape {

7. int side;

8. Square int side {

9. /* insert code here */

10. this.side = side;

11. }

12. public void area ( ) { System.out.println (“Square'); }

13. }

14. class Rectangle extends Square {

15. int len, br;

16. Rectangle (int x, int y) {

17. /* insert code here */

18. len = x, br = y;

19. }

20. void area ( ) { System.out.println (“Rectangle'); }

21. }

Which two modifications enable the code to compile? (Choose two.)

Given:

class Sum extends RecursiveAction { //line n1 static final int THRESHOLD_SIZE = 3;

int stIndex, lstIndex;

int [ ] data;

public Sum (int [ ]data, int start, int end) {

this.data = data;

this stIndex = start;

this. lstIndex = end;

}

protected void compute ( ) {

int sum = 0;

if (IstIndex - stIndex (= THRESHOLD_SIZE) {

for (int i = stIndex; i ( lstIndex; i++) {

sum += data [i];

}

System.out.println(sum);

} else {

new Sum (data, stIndex + THRESHOLD_SIZE, lstIndex).fork( );

new Sum (data, stIndex,

Math.min (lstIndex, stIndex + THRESHOLD_SIZE)

).compute ();

}

}

}

and the code fragment:

ForkJoinPool fjPool = new ForkJoinPool ( );

int data [ ] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

fjPool.invoke (new Sum (data, 0, data.length));

and given that the sum of all integers from 1 to 10 is 55.
Which statement is true?

Given the content of Operator.java, EngineOperator.java, and Engine.java files:

What is the result?