Core Java Mock Test-3

The correct answer is Class: Chocolate and Objects: Fruit Chocolates, Rum Chocolates, Milk Chocolates. This is because the question states that Real Chocos Private Limited manufactures three varieties of chocolates, namely Fruit Chocolates, Rum Chocolates, and Milk Chocolates. Therefore, the class would be Chocolate, which represents the general category of chocolates, and the objects would be the specific varieties of chocolates that the organization manufactures.

The code defines three classes: One, Two, and Three. Each class has a constructor that prints a number. Class Three extends class Two, which extends class One. The main method creates an instance of class Three. When the instance is created, the constructors of all three classes are called in order. Therefore, the output will be 123.

The code will compile and run correctly without the need to comment any line. All the methods called in the main method (m1, m2, m3, m4) are accessible within the class A. The access modifiers (public, protected, private) do not affect the ability to call these methods within the same class. Therefore, no lines need to be removed for the code to compile and run correctly.

The method call charAt(15) refers to the letter "b" in the string "Did Deepak see bees? Deepak did.". The index of the character "b" in the string is 15, as indexing starts from 0. Therefore, calling the charAt(15) method will return the character "b".

In this code, a double variable "d" is initialized with the value 12.3. Then, an object of the class "Dec" is created and its method "dec" is called, passing the value of "d" as an argument. Inside the "dec" method, the argument "d" is subtracted by 2.0 and assigned back to "d". However, this does not affect the value of the original "d" variable outside the method. Therefore, when the value of "d" is printed at line 6, it still remains 12.3.

The code will result in a compile-time error because the return type of the method m1() is declared as byte, but it is trying to return a char value. The char value 'u0001' cannot be implicitly converted to a byte, hence the code will not compile.

In the given code, class Gamma extends class Alpha, which means Gamma is a type of Alpha. Therefore, the statement "Gamma is-a Alpha" is true. Additionally, the code also declares a protected variable of type Beta in class Alpha, which means Gamma has a Beta. Therefore, the statement "Gamma has-a Beta" is also true.

The correct answer is "if (!x.equals(y[0])) {". This code snippet uses the "equals" method to compare the value of x and y[0]. The "!" operator negates the result of the comparison, so if x and y[0] are not equal, the condition will be true and "no match" will be printed.

The correct answer is that the == operator compares the memory address of objects, while the equals() method compares the character sequence of objects.

Association is a relationship between two classes where one class is connected to another class, but there is no ownership or dependency between them. In the given question, the relationship between a Pilot class and Plane class can be an association, as pilots can be associated with planes without any ownership or dependency.

The code will result in a compilation error because the method `method(A a)` in the `Code2` class does not have an overload that accepts an `Object` parameter. Therefore, the compiler cannot find the symbol `method(Object)`.

The code is written to accept command line arguments and print them as comma separated values. It then prints the length of the arguments-list. Since the code is using the enhanced for-loop to iterate over the arguments array, it will compile successfully and produce the expected output.

The code will result in a compile-time error because the variable "rslt" is not initialized before it is returned in the method "testAns".

The correct answer is "Compilation Error: Non-static method methodB() cannot be referenced from static context methodA()". This is because the method methodB() is not declared as static, so it can only be accessed through an instance of the class. However, methodA() is a static method and does not have an instance of the class, so it cannot access the non-static method methodB(). This results in a compilation error.

Delimiters themselves cannot be considered as tokens. Delimiters are characters used to separate or mark the boundaries of different tokens in a given text. Tokens, on the other hand, are meaningful units of information, such as words or symbols, that are extracted from the text. Delimiters serve as separators between tokens, but they are not considered tokens themselves. Therefore, the statement is false.

The code contains a nested loop. The outer loop runs twice and the inner loop runs 10 times. Inside the inner loop, there is a condition that checks if the value of i is equal to 5. If it is, then the loop labeled "loop" is broken, causing the program to exit the inner loop and continue with the next iteration of the outer loop. Therefore, the output will be 0 1 2 3 4, as the inner loop is terminated before reaching the value 5.

The code snippet creates two string objects, s1 and s2, with values "Test1" and "Test2" respectively. The concat() method is called on s1 and s2, but the result is not assigned to any variable. Therefore, the original values of s1 and s2 remain unchanged. The println() method is then called, concatenating the character at index (length - 3) of s1 with the index of s2 in s1. Since s1.concat(s2) does not modify s1, the index of s2 in s1 is -1. Therefore, the output will be "s-1".

The code first calculates the remainder of y divided by x using the modulus operator (%), which is 5 % 3 = 2. It then prints this value, followed by a comma.

Next, it checks if y is equal to the result of ((y/x) * x + (y%x)). Since y is 5, and ((y/x) * x + (y%x)) simplifies to ((5/3) * 3 + (5%3)) = (1 * 3 + 2) = 5, the condition y == ((y/x) * x + (y%x)) evaluates to true.

Therefore, the code prints "2, true".

The output of the above program will be "Welcome!" because the object "planet" is an instance of the subclass Earth, which means it is also an instance of the superclass Planet. Therefore, the condition "planet instanceof Earth" will evaluate to true and the corresponding message "Welcome!" will be printed.

The code will output "Welcome 5". This is because the constructor with the int parameter is called when creating a new instance of the Welcome class. Inside this constructor, the value variable is assigned the value 5 and the title variable is assigned the value "Welcome". Then, the Welcome() method is called, which prints out the value of the title and value variables. Since the title variable was previously assigned the value "Welcome" in the constructor, the output will be "Welcome 5".

The program will output 'Before start method' only. This is because the stop() method is called immediately after the start() method, which causes the thread to stop before it has a chance to execute the rest of the code in the run() method. Therefore, the "After stop method" print statement is never reached.

The ownerName variable breaks encapsulation because it is declared as public, which means it can be accessed and modified directly from outside the class. Encapsulation is a principle of object-oriented programming that aims to hide the internal details of an object and only expose necessary information through methods. By declaring ownerName as public, it violates this principle and allows external code to directly manipulate the variable.

The code snippet "if(h==3) break rg; if(g==0) break dg;" will make the program generate the given output because it breaks out of the inner loop when h is equal to 3 and breaks out of the outer loop when g is equal to 0. This ensures that the inner loop iterates until h reaches 3 and the outer loop iterates until g reaches 0, allowing all the elements of the array to be printed before "The end." is printed.

The correct answer is "return this.name.equalsIgnoreCase(a.name);" because it compares the names of the two Animal objects, ignoring the case sensitivity. This will return true if the names are equal, regardless of whether they are in uppercase or lowercase.

The output of the code snippet will be "true false". This is because the string objects s1 and s2 both have the same value "java", so when comparing them using the "==" operator, it will return true. However, the string object s3 has a different value "JAVA" which is in uppercase. When calling the toUpperCase() method on s3, it does not change the original string object, so s3 still remains "JAVA". Therefore, when comparing s1 and s3 using the "==" operator, it will return false.

The code will compile successfully because there are no syntax errors. The program will print "5" as the output because the value of x is initially set to 1 and the switch statement will execute the case 1 and case 2 statements, adding the value of y to x twice. Therefore, x will be equal to 5 when it is returned.

Java supports the flow control features of labeled continue and labeled break. Labeled continue is used to skip the current iteration of a loop and move to the next iteration, while labeled break is used to exit a loop or switch statement. Labeled goto, labeled throw, and labeled catch are not supported by Java.

Aggregation is the correct answer because it represents a relationship between objects where one object is composed of or contains other objects. In the context of a spreadsheet, a Spreadsheet Object can be composed of or contain multiple Cell Objects. This relationship allows for the organization and manipulation of data within the spreadsheet.

The correct answer is public class Test2 { static public void main(String[] in) { System.out.println("Test2"); } } because it follows the correct syntax for the main method in Java. The main method must be declared as public, static, and void, and it must accept an array of strings as a parameter. Additionally, the class name must match the file name, and the code inside the main method will be executed when the program is run.

The code is trying to assign the value of the variable "first" to the variable "second" before "first" is actually declared. This is known as forward referencing, and it is not allowed in Java. Therefore, the compiler will complain about this error.

The code initializes a final int variable i with a value of 22. It then tries to assign the value of i to a byte variable b. Since byte is a smaller data type than int, there is a potential loss of precision. However, in this case, the value of i (22) can be safely represented as a byte, so no compilation error occurs. Therefore, the code will print "22, 22" as the output.

Inheritance allows a subclass to inherit the properties and methods of its superclass, which means that a subclass can also act as a superclass in an inheritance hierarchy. This allows for code reuse and promotes modularity. Additionally, inheritance enables adding new features and functionality to an existing class without modifying the existing class, which helps to maintain the integrity of the original class and simplifies the process of extending its capabilities.

A class can have more than one static block: This statement is correct because a class can have multiple static blocks, which are used to initialize static variables or perform other tasks before the class is used.

Static blocks are executed only once: This statement is correct because static blocks are executed only once when the class is loaded into memory. They are not executed again even if the class is instantiated multiple times.

Static blocks are executed before the main() method: This statement is correct because static blocks are executed in the order they appear in the code, before the main() method is executed. This allows any necessary initialization to be performed before the main() method starts executing.

Therefore, the correct statements regarding static blocks are that a class can have more than one static block, static blocks are executed only once, and static blocks are executed before the main() method.

JAR Files, Java Class Files, and Java Source Files are all platform independent. JAR files are archives that contain compiled Java classes and resources, which can be executed on any platform that supports Java. Java Class Files are the compiled bytecode version of Java source code, which can also be executed on any platform with a Java Virtual Machine (JVM). Java Source Files are the human-readable version of Java code, which can be compiled into Java Class Files and executed on any platform with a JVM. The JVM is not platform independent itself, but it allows Java code to run on different platforms.

The output for the above program will be 10. This is because the value of x is 10, which matches the case 10 in the switch statement. Therefore, the code inside the case 10 block will be executed, which includes the statement System.out.println(x). This will print the value of x, which is 10, as the output.

The class "java.io.Console" is new to JDK 1.6. This class provides a way to interact with the user through the command line, allowing input and output operations. It was introduced in JDK 1.6 to enhance the capabilities of command line applications in Java.

The methods toString(), hashCode(), and equals(Object) are defined in the Object class. The toString() method returns a string representation of an object, the hashCode() method returns the hash code value for an object, and the equals(Object) method checks if two objects are equal. These methods are inherited by all classes in Java as the Object class is the root class for all classes in Java. The run() and compareTo(Object) methods are not defined in the Object class.

Line a prints the corresponding classname with Object's hashcode in Hexadecimal because when we print an object without explicitly calling the toString() method, it automatically calls the toString() method of the Object class. The default implementation of toString() in the Object class returns the classname followed by the hashcode of the object in hexadecimal format. Therefore, Line a prints the classname "Train" along with the hashcode of the object in hexadecimal.

Both Line a and Line b will print the corresponding classname with Object's hashcode in Hexa Decimal because the toString() method is explicitly called in Line b. The toString() method in the Train class is not overridden, so it calls the toString() method of the Object class, which returns the classname followed by the hashcode of the object in hexadecimal format.

The output of Line a and Line b will be the same because both statements print the classname followed by the hashcode of the object. Since the object is the same in both cases, the hashcode will be the same, resulting in the same output.

The variable at line 4 should be declared as final because it is being accessed by the inner class Circle2. In order for the inner class to access the variable, it needs to be declared as final to ensure that its value does not change.

The code snippet tries to cast an instance of the Dog class to the Cat class. However, since a Dog is not a subclass of Cat, a ClassCastException will be thrown at runtime.

The correct answer is "(new Bar() {}).go();". This code creates a new instance of the Bar class using an anonymous inner class and then calls the go() method on that instance. The output will be "barsweet".

The first statement, "All exceptions are thrown programmatically from the code or API," is false. Exceptions can be thrown programmatically, but they can also be thrown automatically by the JVM or other system components.

The second statement, "All exceptions are thrown by JVM," is false. While the JVM does throw some exceptions, not all exceptions are thrown by the JVM. Exceptions can also be thrown programmatically by the code or API.

The third statement, "JVM cannot throw user-defined exceptions," is true. User-defined exceptions are exceptions that are created by the programmer, and the JVM does not throw these types of exceptions.

The fourth statement, "JVM thrown exceptions can be thrown programmatically," is true. The JVM can throw exceptions, and these exceptions can also be thrown programmatically by the code or API.

The fifth statement, "All RuntimeException are thrown by JVM," is false. While the JVM does throw some RuntimeExceptions, not all RuntimeExceptions are thrown by the JVM. RuntimeExceptions can also be thrown programmatically by the code or API.

The first statement "grts = new float[1][4];" creates a 2-dimensional float array with 1 row and 4 columns and assigns it to the variable "grts". This statement is valid and does not cause any compilation errors.

The second statement "invt = grts;" assigns the value of "grts" to the variable "invt". Since both variables are of the same type (2-dimensional float array), this assignment is valid and does not cause any compilation errors.

The third statement "invt = new float[4][2];" creates a new 2-dimensional float array with 4 rows and 2 columns and assigns it to the variable "invt". This statement is also valid and does not cause any compilation errors.

Therefore, the three listed statements can be inserted at the commented lines to make the program compile without errors.

A class can have more than one instance block: This statement is correct because a class can have multiple instance blocks, which are used to initialize instance variables or perform other actions before the object is created.

Instance blocks are executed before constructors: This statement is correct because instance blocks are executed before constructors during the object creation process. Instance blocks are used to initialize instance variables, and they are executed before any constructor code is executed.

Instance blocks are executed for every created instance: This statement is correct because instance blocks are executed every time a new instance of the class is created. This ensures that the necessary initialization or actions are performed for each individual instance.

The code snippet "Color treeColor = Color.GREEN;" allows the Garment class to compile because it creates a new variable "treeColor" of type Color and assigns it the value of Color.GREEN, which is one of the enum constants defined in the Color enum.

The code snippet "if( Color.RED.ordinal()