Here you have the best Oracle 1z0-809 practice exam 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?
The code will result in a compilation error at line n3. The method speed() is being called without an instance of the nested class Car. To call the speed() method correctly, you need to create an instance of the Car class and then call the method using that instance. Therefore, the correct code would be new Car().speed() at line n3. As it stands, the call to speed() at line n3 is incorrect and will cause a compilation error.
Given:
IntStream stream = IntStream.of (1,2,3);
IntFunction
IntStream newStream = stream.map(inFu.apply(10)); //line n2 newStream.forEach(System.output::print);
Which modification enables the code fragment to compile?
To ensure the code fragment compiles correctly, line n1 should be replaced with 'IntFunction<IntUnaryOperator> inFu = x -> y -> x * y;'. This defines 'inFu' as a function that takes an integer and returns an 'IntUnaryOperator'. The 'IntUnaryOperator' is a functional interface that takes an int and returns an int, which matches the expected behavior for the 'map' method in the IntStream class.
Given the code fragment:
List
values.stream ()
.map(n -> n*2) //line n1
.peek(System.out::print) //line n2
.count();
What is the result?
The code produces no output. The count() method is a terminal operation that returns the number of elements in the stream. The peek() method is meant to support debugging by performing the action provided on each element as elements are consumed from the resulting stream. However, in this case, since count() is used and it does not consume the stream elements in a way that executes peek(), the peek() operation does not produce any output.
Given the code fragment:
public class Foo {
public static void main (String [ ] args) {
Map
unsortMap.put (10, "z");
unsortMap.put (5, "b");
unsortMap.put (1, "d");
unsortMap.put (7, "e");
unsortMap.put (50, "j");
Map
Comparator
@Override public int compare (Integer o1, Integer o2) {return o2.compareTo
(o1); } } );
treeMap.putAll (unsortMap);
for (Map.Entry
System.out.print (entry.getValue () + " ");
}
}
}
What is the result?
The code defines a TreeMap with a custom Comparator that sorts the keys in descending order by returning o2.compareTo(o1) in the compare method. When the unsorted HashMap entries are inserted into the TreeMap, they are sorted in descending order based on their keys. The keys in descending order are 50, 10, 7, 5, and 1, corresponding to the values 'j', 'z', 'e', 'b', and 'd', respectively. Thus, the output will be 'j z e b d'.
Which two reasons should you use interfaces instead of abstract classes? (Choose two.)
When choosing between interfaces and abstract classes, it's important to understand their purposes. Interfaces are ideal when you expect that unrelated classes would implement the interfaces, as they provide a way to specify a set of methods that must be implemented without dictating how the methods should be used (Option B). Additionally, interfaces are suitable when you want to take advantage of multiple inheritance of type, since a class can implement multiple interfaces but can only extend one abstract class (Option E). These two scenarios highlight the flexibility and design patterns that interfaces offer over abstract classes.