Ocjp Mock Jgi - II

The capability that exists only in java.io.FileWriter is writing a line separator to an open stream. This means that FileWriter has a specific method or functionality that allows the user to write a line separator, which is a special character or sequence of characters used to indicate the end of a line, to an open stream. The other options mentioned, such as closing an open stream, flushing an open stream, and writing to an open stream, are capabilities that are generally available in various input/output classes in Java.

The code fragment "System.out.printf("|%7.3f| ", d);" produces the output "| 12.345|" because the "%7.3f" format specifier is used to format the double value "d" with a width of 7 characters, including the decimal point and any leading spaces. The ".3" specifies that the output should have 3 decimal places. The output is enclosed in "|" to match the desired format.

When line 14 is reached, there are 4 objects eligible for the garbage collector. The objects i2 and i3 are set to null, meaning they no longer have any references pointing to them. Additionally, i1 is reassigned to i2, and i3 is reassigned to i1, meaning the original object that i3 was referencing is also eligible for garbage collection. Therefore, a total of 4 objects are eligible for garbage collection.

The variable "base" is a public variable in the InnerTriangle class, which is a member of the geometry package. Therefore, any class that wants to access the variable "base" must also belong to the geometry package.

The code will iterate over the TreeSet and print the name of each Drink object. Since the compareTo method in the Drink class returns 0, the TreeSet will consider both Drink objects as equal and will only store one of them. When iterating over the TreeSet, it will only print the name of the Drink object that was stored, which is "Coffee". Therefore, the result will be "Coffee".

The code will output "three". This is because on line 12, the code is creating two Integer objects, adding them together using the "+" operator, and assigning the result to the variable "i". This is possible because of autoboxing, which automatically converts the primitive int values to Integer objects. The value of "i" is then used in the switch statement on line 13. Since the value of "i" is 3, the case 3 is matched and the code prints "three".

Two of the given method names follow JavaBean Listener naming rules. The naming convention for JavaBean Listener methods is to start with "add" followed by the event type, and end with "Listener". In this case, the method names "addListener" and "addMouseListener" follow this convention. The other method names do not follow the convention as they either have incorrect prefixes or do not end with "Listener".

The compilation of class C will fail because the method "execute()" in class C has a different return type (Object) than the method it is overriding in class B (String). The return type of an overridden method must be the same or a subtype of the return type in the superclass.

The output of the program is 9.


- The main method creates an instance of the Starter class and calls the makeItSo() method.
- In the constructor of the Starter class, the value of x is set to 5 and the start() method is called, which will eventually execute the run() method.
- The run() method multiplies the value of x by 2, resulting in x being 10.
- The makeItSo() method then calls the join() method, which waits for the thread to complete before continuing.
- After the join() method, the value of x is decremented by 1, resulting in x being 9.
- Finally, the value of x (which is 9) is printed to the console.

The code declares and initializes a two-dimensional array `x` with three rows and varying number of columns. Then, it assigns `x` to another two-dimensional array `y`. Finally, it prints the value at index `[2][1]` of `y`, which is `7`.

The correct answer is "foobarfoobarfoo".


In this code, the class "Base" has a public static final String variable "FOO" with the value "foo". The class "Sub" extends "Base" and also has a public static final String variable "FOO" with the value "bar".

In the main method, the code creates an instance of "Base" and an instance of "Sub".

When printing the value of "FOO" for each object, the output is as follows:
- Base.FOO: "foo"
- Sub.FOO: "bar"
- b.FOO: "foo" (since it is referencing the "FOO" variable of the "Base" class)
- s.FOO: "bar" (since it is referencing the "FOO" variable of the "Sub" class)
- ((Base)s).FOO: "foo" (since it is casting "s" to the "Base" class and referencing the "FOO" variable of the "Base" class)

Therefore, the final output is "foobarfoobarfoo".

The program is iterating over the command line arguments starting from index 1 (args[1]). Since the first command line invocation "java Yippee" does not have any arguments, the loop is not executed and no output is produced. However, in the second command line invocation "java Yippee 1 2 3 4", the loop is executed and the program prints the arguments starting from index 1, which are "2 3 4". Therefore, the correct answer is "No output is produced. 2 3 4".

The result of this code is "f-p w-f".


- In line 9, a Walleye object is created and assigned to a Fish reference variable. Since Walleye is a subclass of Perch, which implements the Fish interface, this assignment is valid.
- In line 12, the instanceof operator is used to check if the object referred to by 'f' is an instance of the Perch class. Since 'f' is actually referring to a Walleye object, which is a subclass of Perch, this condition is true and "f-p" is printed.
- In line 13, the instanceof operator is used to check if the object referred to by 'w' is an instance of the Fish interface. Since 'w' is a Walleye object, which implements the Fish interface, this condition is true and "w-f" is printed.
- In line 14, the instanceof operator is used to check if the object referred to by 'b' is an instance of the Fish interface. Since 'b' is a Bluegill object, which does not implement the Fish interface, this condition is false and nothing is printed.

The program creates two instances of the Foo class, foo and fooFoo, with initial values of 300 and 100 respectively.

In the main method, the value of foo.getX() is printed, which is 300. Then, the value of fooFoo.getX() is printed, which is 100.

Next, the fooBar method is called with fooFoo as an argument. Inside the fooBar method, a new instance of Foo is created with a value of 100 and assigned to the local variable foo. The method returns foo.

Back in the main method, the value of foo.getX() is printed again, which is now 100. Finally, the value of fooFoo.getX() is printed, which is still 100.

Therefore, the output of the program is 300-100-100-100-100.

If a ResourceException is thrown on line 86, it means that there was an error while querying the resource. In this case, the code in the catch block on line 90 will be executed, which writes the error message to the error log. However, since the exception occurred before reaching line 88, the resource connection will not be closed. Therefore, the statement "The resource connection will not be closed on line 88" is true.

The first command "java com.company.application.MainClass if run from the /apps directory" will run MainClass because it specifies the full package name and class name, and it is run from the correct directory where the MainClass file is located.

The second command "java -classpath /apps com.company.application.MainClass if run from any directory" will also run MainClass because it specifies the classpath to the directory where the MainClass file is located, allowing the JVM to find and run the class from any directory.

The output could be 8-1 7-1 7-2 8-2 because the hit() method is synchronized, which means only one thread can access it at a time. The two threads created in the main method start simultaneously and call the hit() method. However, only one thread can enter the hit() method at a time, so one thread will complete its execution before the other can enter. This leads to the possibility of the output being in any order depending on which thread enters the hit() method first.

The correct answer is "Set set = new TreeSet();". This code guarantees that the program will output [1, 2] because TreeSet is an implementation of the Set interface that stores elements in sorted order. When elements are added to a TreeSet, they are automatically sorted in ascending order. Therefore, when the integers 2 and 1 are added to the TreeSet, they will be stored in sorted order, resulting in the output [1, 2].

The code in class A fails to compile because the variable "counter" is declared as a non-static variable, but it is accessed in a static method "getInstanceCount()". To fix this error, the variable "counter" should be declared as static.

The given code first creates an ArrayList named 'a' and adds integers 1, 5, and 3 to it. Then, it sorts the ArrayList using the Collections.sort() method, resulting in [1, 3, 5]. After that, it adds the integer 2 to the ArrayList using the add() method, resulting in [1, 3, 5, 2]. Finally, it reverses the order of the elements in the ArrayList using the Collections.reverse() method, resulting in [2, 5, 3, 1]. Therefore, the correct answer is [2, 5, 3, 1].

The NumberFormatException can be thrown by a programmer using Java SE technology to create a desktop application when there is an attempt to convert a string into a numeric type, but the string does not have the appropriate format. This exception is usually thrown when using methods like parseInt() or parseDouble() to convert strings into integers or doubles, respectively. If the string cannot be parsed into a valid number format, the NumberFormatException is thrown.

The given answer is correct because in a HashMap, the time to find the value associated with a specific key depends on the size of the map. As the size of the map increases, the time to find the value also increases because the HashMap uses the hash code of the key to determine the bucket where the value is stored. If the number of elements in the map increases, the number of buckets also increases, which can lead to more collisions and slower lookup time. Therefore, the time complexity for finding a value in a HashMap is O(1) on average, but it can be O(n) in the worst case scenario.

The regular expression "\\.\\s*" correctly splits the string "test" into "Test A", "Test B", and "Test C". This regular expression matches a period followed by zero or more whitespace characters, which is the pattern used to separate the different parts of the string.

The code will fail to compile because the variable "i" is declared within the for loop and cannot be accessed outside of it. Therefore, the statement on line 15, which tries to print the value of "i", will result in a compilation error.

The result when method testIfA is invoked is "True". This is because the testIfB method is called with the argument "True", which returns a Boolean value of true. Since the if statement evaluates this Boolean value as true, the code block in line 13 is executed, which prints "True" to the console.

The two classes that do not compile are class D and class G. Class D does not compile because it implements the interface A but does not provide an implementation for the method m1() without any parameters, as required by the interface. Class G does not compile for the same reason, as it also does not provide an implementation for the method m1() without any parameters. The other classes either implement the method m1() as required by the interface or are abstract classes that are not required to provide an implementation.

The given code is a class named "Hi" with two methods, "m1()" and "m2()", both without any return type. The class "Lois" extends the "Hi" class.

To compile the code at line 7, we need to insert code that is valid and does not cause any compilation errors.

The four code fragments that can be inserted at line 7 and will compile are:
- public void m1() { }
- protected void m1() { }
- public void m2() { }
- protected void m2() { }

The correct answer is "1 2 3" because the code creates an array of integers on line 12 and assigns it to an Object reference. On line 13, the code casts the Object reference back to an int array. Then, on line 14, a for-each loop is used to iterate over the elements of the int array and print them out. Since the int array contains the values 1, 2, and 3, the output will be "1 2 3".

The code fails to compile because the constructor on line 19 is calling the constructor on line 13 using the syntax "Hello();". However, this syntax is not valid for calling a constructor within another constructor. The correct syntax would be "this();" to call the default constructor.

The most reliable way to ensure that foo will stop executing wait() is by calling bar.notifyAll(). This is because bar is the object on which the wait() method is being called, so calling notifyAll() on bar will notify all threads waiting on that object, including foo. This will allow foo to resume execution and continue its task.

The correct answer is "public Two foo() { return this; }" and "public One foo() { return this; }". These two methods correctly complete the Three class because they override the foo() method from the parent class, Two, and return the appropriate type of object. The first method returns an object of type Two, which is the class that directly extends One. The second method returns an object of type One, which is the class that the Three class ultimately extends.

The code creates an array of Computation objects and starts each thread. Each thread calculates the result by multiplying the given number by 2 and sets the isComplete flag to true. The main thread then waits for each computation to complete and prints the result. Since the computations are running concurrently, the order in which they complete is not guaranteed. Therefore, the output can be "0 2 4 6" or any other possible permutation of these numbers.

The code fails to compile because the method "y()" is not defined in the interface A. Since the variable "a" is of type A, it does not have access to the method "y()" defined in class B. Therefore, calling "a.y()" on line 25 would result in a compilation error.

The code creates a TreeSet named "s" and adds even numbers between 606 and 612 to it. Then, it creates a subset of "s" called "subs" using the subSet() method, with the range [608, 611] inclusive. After that, it adds the number 629 to "s". The output will be [606, 608, 610, 612, 629] for "s" and [608, 610] for "subs".

The correct implementation of the MinMax class is the first one provided. This is because it correctly declares the type parameter E and ensures that it implements the Comparable interface. The put() method allows for storing either the minimum or maximum value based on the implementation.

The correct answer is "Only the assert statements on lines 15 and 18 are used appropriately." This is because in line 15, the assert statement is used to ensure that the default case in the switch statement is never reached. In line 18, the assert statement is used to check that the value of x is less than 0. Both of these assert statements are used correctly to enforce certain conditions in the code.

The correct answer is "Line.Point p = (new Line()).getPoint();". This code correctly retrieves a local instance of a Point object by creating a new instance of the Line class using the "new Line()" syntax and then calling the "getPoint()" method on that instance. The "Line.Point" syntax is used to specify that the Point class is a nested class within the Line class.

The correct answer is X, followed by an Exception. This is because the foo() method in the SubB class overrides the foo() method in the X class. In the overridden method, it first calls the foo() method of the superclass using super.foo(). Then, it throws a RuntimeException. Since there is no try-catch block to handle the exception, it is propagated up the call stack and the program terminates after printing "X".

The code creates two threads that both execute the same Runnable object. The Runnable object has a for loop that runs four times. In each iteration, the current value of x is printed followed by a comma. Then, the value of x is updated by adding 2 to the current value. Since both threads are executing the same Runnable object, they will share the same value of x. Therefore, the possible results will be a combination of the printed values of x from both threads. In this case, the two possible results are 0, 2, 4, 4, 6, 8, 10, 6 and 0, 2, 4, 6, 8, 10, 12, 14.

The two code fragments that will execute the method doStuff() in a separate thread are:

1. new Thread() {
public void run() { doStuff(); }
}.start();

This code creates a new thread using the Thread class and overrides the run() method to call the doStuff() method. The start() method is then called to start the thread and execute the doStuff() method in a separate thread.

2. new Thread(new Runnable() {
public void run() { doStuff(); }
}).start();

This code creates a new thread using the Thread class and passes a Runnable object as a parameter. The run() method of the Runnable object is overridden to call the doStuff() method. The start() method is then called to start the thread and execute the doStuff() method in a separate thread.

The value of b is 2.00 because the format method of NumberFormat class formats the given number according to the formatting rules set by setMaximumFractionDigits and setMinimumFractionDigits methods. In this case, the number 2 is formatted with a minimum of 2 fraction digits, so it becomes "2.00". The value of a is 3.1416 because the number 3.1415926 is formatted with a maximum of 4 fraction digits and a minimum of 2 fraction digits, so it becomes "3.1416".

When line 11 is reached, there are no objects eligible for garbage collection. This is because all the objects created in the code are still referenced by variables. The variable t2 is set to null, but it does not affect the eligibility for garbage collection as it was not the only reference to any object. Therefore, all the objects created in the code are still reachable and not eligible for garbage collection.

The code fails to compile due to an error on line 8 because the Console class is not imported properly. The correct import statement should be "import java.io.Console;" instead of "import java.io.*;". Therefore, the code cannot create an instance of the Console class and the compilation fails.

The correct answer is "Value is: 8" because the code creates an instance of the MultiCalc class and calls the calculate() method with an argument of 2. Inside the calculate() method, the calculate() method is called again without any arguments, which adds 7 to the value. Then, the super.calculate() method is called, which adds another 7 to the value. Finally, the value is multiplied by the multiplier, which is 2. Therefore, the final value is 8.

The correct answer is "public class Employee extends Info implements Data { public void load() { /*do something*/ } }". This is the correct class because it correctly implements the Data interface and extends the Info class. The load() method in this class satisfies the requirements of both the Data interface and the Info class.

The code defines an abstract class C1 with a constructor that prints 1. Class C2 extends C1 and has a constructor that prints 2. Class C3 extends C2 and has a constructor that prints 3. In the main method of the Ctest class, a new object of C3 is created. When this object is created, the constructors of C1, C2, and C3 are called in order, resulting in the output 123.

The code creates a class TestA with a method start() that prints "TestA". Then, a class TestB is created that extends TestA and overrides the start() method to print "TestB". In the main method, an instance of TestB is created and casted to TestA. The start() method is then called on this instance, which results in "TestB" being printed. Therefore, the result is "TestB".

The correct answer is that a HashSet could contain multiple Person objects with the same name. This is because the equals() method in the Person class is overridden to compare the names of two Person objects. However, the hashCode() method is not overridden, which means that the default implementation from the Object class is used. This default implementation generates a unique hash code for each object, regardless of the values of their fields. Therefore, multiple Person objects with the same name will have different hash codes and can be stored in a HashSet.

The correct answer is System.getProperty("prop.custom") and System.getProperties().getProperty("prop.custom"). These two options will retrieve the value of the system property "prop.custom" that was passed through the command line using the -D flag. The first option, System.getProperty("prop.custom"), directly retrieves the value of the specified system property. The second option, System.getProperties().getProperty("prop.custom"), first retrieves all system properties using System.getProperties() and then specifically retrieves the value of the "prop.custom" property. Both options will return the value "gobstopper" in this case.

The given code does not contain any code to create a file or a directory on the file system. The variable "dir" is assigned a new File object with the name "dir", but it does not create a directory with that name. Similarly, the variable "f" is assigned a new File object with the name "f", but it does not create a file with that name. Therefore, nothing is added to the file system.