If package is used then it should be the first statement, but javadoc and developer comments are not considered as java statements so a class can have developer and javadoc comments before the package statement.
If import and package both are available, then correct order is package, import, class declaration.

If package is used then it should be the first statement, but javadoc and developer comments are not considered as java statements so a class can have developer and javadoc comments before the package statement.
If import and package both are available, then correct order is package, import, class declaration. Multiple package statements are not allowed.

Java is case sensitive language. File name should match with public class’s name, which is “HelloWorld”.
“helloworld” is different from “HelloWorld”.

In java, it is allowed to put multiple statements on one line. E.g. below code is legal:
public class Test {
public static void main(String [] args) {
String symbol = “!”;System.out.print(“Hello “);System.out.print(“World”);System.out.println(symbol);
}
}

Above code is similar to:
public class Test {
public static void main(String [] args) {
String symbol = “!”;
System.out.print(“Hello “);
System.out.print(“World”);
System.out.println(symbol);
}
}

Empty statements (just the semicolon) are also allowed in java, therefore below code is also legal:
public class Test {
public static void main(String [] args) {
System.out.println(“Hello”);
;
;
;
;
;
;
;
;
}
}

As shown above, java statements (including empty statements) can be placed on one line, therefore below code is legal:
public class Test {
public static void main(String [] args) {
System.out.println(“Hello”);;;;;;;;;
}
}

Special main method should have public access specifier and it takes argument of String [] type.
String [] argument can use any identifier name, even though in most of the cases you will see “args” is used.

Following import statements are correct: 
import com.masaimara.*; 
import com.masaimara.Animal; 
NOTE: all small case letters in import keyword.

To declare Test class in com.exam.oca package, use following declaration: 
package com.exam.oca; 
No wildcard (*) allowed in package declaration. Don’t include class name in package declaration. NOTE: all small case letters in package keyword.

Use -d option with javac command.
As you are typing javac command from within Sec07 directory, hence path of java file relative to Sec07 directory needs to be given.
So, correct command is: javac -d classes\ src\com\skillcertpro\test\Exam.java

To execute Exam class from WORK folder, you should specify the classpath (Quiz\Sec07\classes\) which contains whole path of the class(com\skillcertpro\test\Exam.class).
And you should also use fully qualified name of the class, which is com.skillcertpro.test.Exam.
Hence correct option is: java -cp Quiz\Sec07\classes\ com.skillcertpro.test.Exam

Top level class can have two access modifiers: public and default.
Over here Test class has private modifier and hence compilation error.

Class Guest has special main method but main method defined in Message class is not public and hence it can’t be called by JVM. But there is no issue with the syntax hence no compilation error.
java Guest Clare Waight Keller passes new String [] {“Clare”, “Waight”, “Keller”} to args of Guest.main method.
Guest.main method invokes Message.main method with the same argument: new String [] {“Clare”, “Waight”, “Keller”}. args[2] is “Keller” hence “Welcome Keller!” gets printed on to the console.

Both the classes contain special main method. No compilation error with the code: file is correctly names as Guest.java (name of public class).
java Guest James Gosling passes new String [] {“James”, “Gosling”} to args of Guest.main method. Apart from being special main method, Message.main is static method so Guest.main method invokes Message.main method with the same argument: new String [] {“James”, “Gosling”}.
args[0] is “James” hence “Welcome James!” gets printed on to the console.

As System.out.println needs to be executed on executing the Test class, this means special main method should replace /*INSERT*/.
Special main method’s name should be “main” (all characters in lower case), should be static, should have public access specifier and it accepts argument of String [] type.
String [] argument can use any identifier name, even though in most of the cases you will see “args” is used.
Position of static and public can be changed but return type must come just before the method name.

Command to compile a java file: javac .java [.java extension is compulsory]. 
Command to execute a java class: java [.class extension should not be used].

If you check the directory structure, you will find that directory “orders” contains “items”, but orders and orders.items are different packages.
import orders.*; will only import all the classes in orders package but not in orders.items package.

You need to import Order and Item classes.
To import Order class, use either import orders.Order; OR import orders.*; and to import Item class, use either import orders.items.Item; OR import orders.items.*;

class A is declared public and defined in com.skillcertpro.oca package, there is no problem in accessing class A outside com.skillcertpro.oca package.
class TestA is defined in com.skillcertpro.oca.test package, to use class A either use import statement “import com.skillcertpro.oca.A;” or fully qualified name of the class com.skillcertpro.oca.A. No issues at Line 3 and LIne 7.

As TestA is in different package so it can only access public members of class A using object reference. Line 8 compiles successfully.
protected, default and private members are not accessible outside com.skillcertpro.oca package using object reference.

NOTE: protected members can be accessed outside but only through inheritance and not object reference.

Like any other method, main method can also be overloaded. But main method called by JVM is always with String [] parameter.
Don’t get confused with 10 as it is passed as “10”. Run above class with any command line arguments or 0 command line argument, output will always be ONE.

Special main method (called by JVM on execution) should be static and should have public access modifier. It also takes argument of String [] type (Varargs syntax String… can also be used).
String [] or String… argument can use any identifier name, even though in most of the cases you will see “args” is used.
final modifier can be used with this special main method.
Hence, from the given five definitions of main method, below two definitions will print expected output on to the console.
public static final void main(String… a) {
    System.out.println(“Java Rocks!”);
}
and
public static void main(String [] args) {
    System.out.println(“Java Rocks!”);
}

As System.out.println needs to be executed on executing the Test class, this means special main method should replace /*INSERT*/.
Special main method’s name should be “main” (all characters in lower case), should be static, should have public access specifier and it accepts argument of String [] type (Varargs syntax String… can also be used). String [] argument can use any identifier name, even though in most of the cases you will see “args” is used. Position of static and public can be changed but return type ‘void’ must come just before the method name.

Let’s check all the given options one by one:
public void static main(String [] args): Compilation error as return type ‘void’ must come just before the method name ‘main’.
protected static void main(String [] args): Compiles successfully but as this method is not public, hence an Error regarding missing main method is thrown on execution.
public void main(String… args): Compiles successfully but as this method is not static, hence an Error regarding non-static main method is thrown on execution.
static public void Main(String [] args): Compiles successfully but as ‘M’ is capital in method ‘Main’, hence it is not special main method. An Error regarding missing main method is thrown on execution.
static public void main(String [] args): Valid definition, it compiles successfully and on execution prints “All is well” on to the console.
public static void main(String [] a): Valid definition, it compiles successfully and on execution prints “All is well” on to the console.
public static Void main(String [] args): Compilation error as Void is a final class in Java and in this case compiler expects main method to return a value of Void type. If you add `return null;` to the main method code will compile successfully but on execution an Error will be thrown mentioning that return type must be ‘void’ (‘v’ in lower-case).
public static void main(String… a): Valid definition, it compiles successfully and on execution prints “All is well” on to the console.

Though given code looks strange but it is possible in java to provide same name to package, class (and constructor), variable and method.
Above code compiles successfully and on execution prints ONE on to the console. Constructor is not invoked as ‘new’ keyword is not used and that is why TWO will not be printed to the console.
In real world coding, you would not see such code and that is why it is a good question for the certification exam.

Top-level class can use only two access modifiers [public and default(don’t specify anything)]. private and protected cannot be used.
As file name is M.java, hence class N cannot be public.
Top-level class can be final, hence it is a correct option.
Top-level class can be abstract and hence it is also a correct option.

Test.java is a valid java file. As none of the classes in Test.java file are public, hence file name can use any valid Java identifier.
As file name is Test.java, hence to compile the code below command is used:
javac Test.java

Execution of above command creates 4 class files: A.class, B.class, C.class & D.class.
To print C on to the console, class C must be executed. To execute C class, command is:
java C

public static void main(String[] args) method is invoked by JVM.
Variable args is initialized and assigned with Program arguments. For example,
java Test: args refers to String [] of size 0.
java Test Hello: args refers to String [] of size 1 and 1st array element refers to “Hello”
java Test 1 2 3: args refers to String [] of size 3 and 1st array element refers to “1”, 2nd array element refers to “2” and 3rd array element refers to “3”.

Command used in this question: java Test Good, so args refers to String[] of size 1 and element at 0th index is “Good”.
args[1] = “Day!”; is trying to access 2nd array element at index 1, which is not available and hence an exception is thrown at runtime.

Like any other method, main method can also be overloaded. But main method called by JVM is always with String [] parameter. Don’t get confused with 10 as it is passed as “10”.
Execute above class with any command line arguments or 0 command line argument, output will always be “String”.

Please note, if passed command line arguments contain space(s) in between, then it is a common practice to enclosed within double quotes. In this case “James Gosling” is passed as one String object and “Bill Joy” is also passed as one String object.
java Test “James Gosling” “Bill Joy” passes new String [] {“James Gosling”, “Bill Joy”} to args of main method. args[0] refers to “James Gosling” and args[1] refers to “Bill Joy”.
Hence, Welcome James Gosling! is printed on to the console. While printing the String object, enclosing quotes are not shown.

To use quotes as part of the String, you can escape those using backslash, such as:
java Test “\”James Gosling”\” “\”Bill Joy”\”
Above command will print Welcome “James Gosling”! on to the console.

Planet is defined in ‘com.skillcertprokhattry.galaxy’ package, Creator is defined in ‘com.skillcertprokhattry.oca’ package and TestCreator is defined in ‘com.skillcertprokhattry.oca.test’ package.
Planet class doesn’t mention ‘Creator’ or ‘TestCreator’ and hence no import statements are needed in Planet class.
Creator class uses the name ‘Planet’ in its code and hence Creator class needs to import Planet class using ‘import com.skillcertprokhattry.galaxy.Planet;’ statement or ‘import com.skillcertprokhattry.galaxy.*;’ statement.
TestCreator class uses the name ‘Creator’ in its code and hence TestCreator class needs to import Creator class using ‘import com.skillcertprokhattry.oca.Creator;’ statement or ‘import com.skillcertprokhattry.oca.*;’ statement.

Please note, even though in TestCreator class, `Creator.create()` returns an instance of Planet class but as name ‘Planet’ is not used, hence Planet class is not needed to be imported.

Planet class correctly overrides toString() method, hence when an instance of Planet class is passed to println(…) method, as in the below statement:
System.out.println(Creator.create());
toString() method defined in the Planet class is invoked, which print “Planet: Earth” on to the console.

127 + 21 = 148 = 00000000 00000000 00000000 10010100 
Above binary number is positive, as left most bit is 0. 
Same binary number after type-casting to byte: 10010100, negative number as left most bit is 1. 
10010100 = -108.

name, height, result and age are instance variables of Student class. And instance variables are initialized to their respective default values.
name is initialized to null, age to 0, result to false and height to 0.0.
Statement System.out.println(stud.name + stud.height + stud.result + stud.age); prints null0.0false0

Both Runtime.getRuntime().gc(); and System.gc(); do the same thing, these make a request to JVM to run Garbage Collector.
JVM makes the best effort to run Garbage Collector but nothing is guaranteed.

Setting the reference variable to null will make the object eligible for Garbage Collection, if there are no other references to this object. But this doesn’t force JVM to run the Garbage Collector. Garbage Collection cannot be forced.

At Line 3, p1 starts referring to the object referred by p2(Created at Line 2).
So, after Line 3, object created at Line 1 becomes unreachable and thus eligible for Garbage Collection.

Object created at Line 1 becomes eligible for Garbage collection after Line 1 only, as there are no references to it. So We have one object marked for GC. 
Object created at Line 6 becomes unreachable after change(Pen) method pops out of the STACK, and this happens after Line 3.
So at Line 4, we have two Pen objects eligible for Garbage collection: Created at Line 1 and Created at Line 6.

All the wrapper classes are defined in java.lang package.
String and StringBuilder are also defined in java.lang package and that is why import statement is not required to use these classes.

Primitive type instance variables are initialized to respective zeros (byte: 0, short: 0, int: 0, long: 0L, float: 0.0f, double: 0.0, boolean: false, char: \u0000).
When printed on the console; byte, short, int & long prints 0, float & double print 0.0, boolean prints false and char prints nothing or non-printable character (whitespace). 
Reference type instance variables are initialized to null.

HINT: First check if members are accessible or not. All the codes are in same file Test.java, and Point class & variable x, y are declared with default modifier hence these can be accessed within the same package.
Class Test belongs to same package so no issues in accessing Point class and instance variables of Point class. Make use of pen and paper to draw the memory diagrams (heap and stack). It will be pretty quick to reach the result.

Point p1 = new Point(); means p1.x = 0 and p1.y = 0 as instance variable are initialized to respective zeros. 
p1.x = 10; means replace 0 with 10 in p1.x, 
p1.y = 20; means replace 0 with 20 in p1.y, 

Point p2 = new Point(); means p2.x = 0 and p2.y = 0 as instance variable are initialized to respective zeros. 
p2.assign(p1.x, p1.y); invokes the assign method, parameter variable x = 10 and y = 20.
As assign is invoked on p2 reference variable hence this and p2 refers to same Point object.
x = this.x; means assign 0 to parameter variable x, no changes in this.y, which means p2.x is unchanged. 
this.y = y; means assign 20 to this.y, which means p2.y is now 20
So after assign method is invoked and control goes back to main method: p1.x = 10, p1.y = 20, p2.x = 0 and p2.y = 20. 
Output is: Point(10, 20);Point(0, 20)

new Counter(); is invoked only once, hence only one Counter object is created in the memory.
c1, c2, c3 and counter are reference variables of Counter type and not Counter objects.

Boolean class code uses equalsIgnoreCase method to validate the passed String, so if passed String is “true” (‘t’, ‘r’, ‘u’ and ‘e’ can be in any case), then boolean value stored in Boolean object is true otherwise false.
b1 stores true, b2 stores false, b3 stores false and as b4 is of reference type, hence it can store null as well.
Output is: true:false:false:null

add(10.0, null); => Compiler can’t convert null to double primitive type, so 2nd argument is tagged to Double reference type. So to match the method call, 10.0 is converted to Double object by auto-boxing and add(10.0, null); is tagged to add(Double, Double); method.
But at the time of execution, d2 is null so System.out.println(“Double version: ” + (d1 + d2)); throws NullPointerException.

Array elements are initialized to their default values.
arr is referring to an array of Boolean type, which is reference type and hence both the array elements are initialized to null and hence in the output null:null is printed.

Array elements are initialized to their default values.
arr is referring to an array of Double type, which is reference type and hence both the array elements are initialized to null.
To calculate arr[0] + arr[1], java runtime converts the expression to arr[0].doubleValue() + arr[1].doubleValue().
As arr[0] and arr[1] are null hence calling doubleValue() method throws NullPointerException.

All the array elements are initialized to their default values. arr is of Boolean type (reference type), so arr[0] is initialized to null.
if expression works with Boolean type variable, so “if(arr[0])” doesn’t cause compilation error but java runtime extracts the boolean value stored in arr[0] and it uses booleanValue() method.
arr[0].booleanValue() means booleanValue() method is invoked on null reference and hence NullPointerException is thrown at runtime.

switch can accept primitive types: byte, short, int, char; wrapper types: Byte, Short, Integer, Character; String and enums.
switch(b) causes compilation failure as b is of Boolean type.

For readability purpose underscore (_) is used to separate numeric values. This is very useful in representing big numbers such as credit card numbers (1234_7654_9876_0987). long data can be suffixed by l, float by f and double by d. So first 5 variable declaration and assignment statements inside main(String []) method don’t cause any compilation error.

Let’s check rest of the statements:
l = c + i; => Left side variable ‘l’ is of long type and right side expression evaluates to an int value, which can easily be assigned to long type. No compilation error here.
f = c * l * i * f; => Left side variable ‘f’ is of float type and right side expression evaluates to float value, which can easily be assigned to float type. Hence, it compiles successfully.
f = l + i + c; => Left side variable ‘f’ is of float type and right side expression evaluates to long value, which can easily be assigned to float type. Hence, no issues here.
i = (int)d; => double can’t be assigned to int without explicit casting, right side expression `(int)d;` is casting double to int, so no issues.
f = (long)d; => double can’t be assigned to float without explicit casting, right side expression `(long)d;` is casting double to long, which can easily be assigned to float type. It compiles successfully.

Boolean class code uses equalsIgnoreCase method to validate the passed String, so if passed String is “true” (‘t’, ‘r’, ‘u’ and ‘e’ can be in any case), then boolean value stored in Boolean object is true otherwise false. 
In this question passed String is “ture” and not “true” and that is why false is printed on to the console.

Boolean.valueOf(String s) returns true if passed String argument is not null and is equal, ignoring case, to the String “true”. In all other cases it returns false.
Boolean.valueOf(“abc”) => false. As “abc”.equalsIgnoreCase(“true”) is false.
Boolean.valueOf(“TrUe”) => true. As “TrUe”.equalsIgnoreCase(“true”) is true.
Boolean.valueOf(“false”) => false. As “false”.equalsIgnoreCase(“true”) is false.
Boolean.valueOf(null) => false. As passed argument is null.
Boolean.valueOf(“FALSE”) => false. As “FALSE”.equalsIgnoreCase(“true”) is false.

There are 3 overloaded methods m. Note all the numeric wrapper classes (Byte, Short, Integer, Long, Float and Double) extend from Number and Number extends from Object. 
Compiler either does implicit casting or Wrapping but not both. 1 is int literal, Java compiler can’t implicit cast it to double and then box it to Double rather it boxes i to Integer and as Number is the immediate super class of Integer so Number version refers to Integer object.
Number version is printed on to the console.

extractInt method accepts argument of Double type.
extractInt(2.7); => 2.7 is double literal, so Java compiler would box it into Double type. At runtime obj.intValue() would print int portion of the Double data, which is 2.
extractInt(2); => Java compiler either does implicit casting or Wrapping but not both. 2 is int literal, Java compiler can’t implicit cast it to double and then box it to Double. So this statement causes compilation failure.

Range of char data type is from 0 to 65535 and hence it can be easily assigned to int type. println() method is overloaded to accept char type and int type both. If char type value is passed, it prints char value and if int type value is passed, it prints int value.
As i1 is of int type, hence corresponding int value, which is 97, is printed on to the console.

For readability purpose underscore (_) is used to separate numeric values. This is very useful in representing big numbers such as credit card numbers (1234_7654_9876_0987). Multiple underscores are also allowed within the digits. Hence, `int x = 5____0;` compiles successfully and variable x stores 50.
`float f = 123.76_86f;` compiles successfully.
1_2_3_4 is int literal 1234 and int can easily be assigned to double, hence `double d = 1_2_3_4;` compiles successfully.

____50 is a valid variable name, and as this variable is not available hence, int y = ____50; causes compilation error.       

Underscores must be available within the digits. For the statement int z = 50____; as underscores are used after the digits, hence it causes compilation error.

Let us first check Line n1: byte b1 = 10;
Above statement compiles successfully, even though 10 is an int literal (32 bits) and b1 is of byte primitive type which can store only 8 bits of data.
Here java does some background task, if value of int literal can be easily fit to byte primitive type (-128 to 127), then int literal is implicitly casted to byte type.
So above statement is internally converted to:
byte b1 = (byte)10;

But if you specify any out of range value then it would not be allowed, e.g.
byte b = 128; // It would cause compilation failure as 128 is out of range value for byte type.

There is no issue with Line n2 as byte type (8 bits) can be easily assigned to int type (32 bits).

For line n3, `byte b2 = i1;`, expression on right hand side (i1) is neither a within range literal value nor constant expression, hence it causes compilation failure.
To compile successfully, this expression needs to be explicitly casted, such as: `byte b2 = (byte)i1;`

Let’s check all the statements one by one:

short s1 = 10;
Above statement compiles successfully, even though 10 is an int literal (32 bits) and s1 is of short primitive type which can store only 16 bits of data.
Here java does some background task, if value of int literal can be easily fit to short primitive type (-32768 to 32767), then int literal is implicitly casted to short type.
So above statement is internally converted to:
short s1 = (short)10;

short s2 = 32768;
It causes compilation failure as 32768 is out of range value.

final int i3 = 10;
short s3 = i3;
Above code compiles successfully. If you are working with final variable and the value is within the range, then final variable is implicitly casted to target type, as in this case i3 is implicitly casted to short.

final int i4 = 40000;
short s4 = i4;
It causes compilation failure as 40000 is out of range value.

final int i5 = 10;
short s5 = i5 + 100;
Above code compiles successfully. If you are working with constant expression and the resultant value of the constant expression is within the range, then resultant value is implicitly casted. In this case, resultant value 110 is implicitly casted.

final int m = 25000;
final int n = 25000;
short s6 = m + n;
m + n is a constant expression but resultant value 50000 is out of range for short type, hence it causes compilation failure.

int i7 = 10;
short s7 = i7;
Compilation error as i7 is non-final variable and hence cannot be implicitly casted to short type.

In Java language, boolean type can store only two values: true and false and these values are not compatible with int type.
Also + operator is not defined for boolean types. Hence, all the 3 statements inside main method causes compilation error.

As floating point numbers are used in the expression, hence result should be in floating point number.
Correct result is:
23 / 2.0 = 11.5 
23 % 2.0 = 1.0

As expression contains + operator only, which is left to right associative. Let us group the expression.
“Hello” + 1 + 2 + 3 + 4
#VALUE!
#VALUE!
#VALUE!
[Let us solve it now, + operator with String behaves as concatenation operator.]
#VALUE!
#VALUE!
#VALUE!
Hello1234

As expression contains + operator only, which is left to right associative. Let us group the expression.
1 + 2 + 3 + 4 + “Hello”
#VALUE!
#VALUE!
#VALUE!
[Let us solve it now,]
#VALUE!
#VALUE!
#VALUE!
[+ operator with String behaves as concatenation operator.]
= 10Hello

Binary plus (+) has got higher precedence than != operator. Let us group the expression. 
“Output is: ” + 10 != 5 
= (“Output is: ” + 10) != 5 
[!= is binary operator, so we have to evaluate the left side first. + operator behaves as concatenation operator.] 
= “Output is: 10” != 5 
Left side of above expression is String, and right side is int. But String can’t be compared to int hence compilation error. 

“Output is: ” + (10 != 5) [Nothing to evaluate at left side, so let’s evaluate the right side of +, 10 != 5 is true.] 
= “Output is: ” + true [+ operator behaves as concatenation operator] 
Output is: true

$ is valid identifier. $ = 80000 
This is an example of ternary operator. First operand ($ >= 50000) is a boolean expression which is true, as 80000 >= 50000 is true. 
msg will refer to “Good bonus”.

int var = –a * a++ + a– – –a;
int var = –a * (a++) + (a–) – –a;
int var = (–a) * (a++) + (a–) – (–a);
int var = ((–a) * (a++)) + (a–) – (–a);
int var = (((–a) * (a++)) + (a–)) – (–a);
int var = ((19 * (a++)) + (a–)) – (–a); //a = 19
int var = ((19 * 19) + (a–)) – (–a); //a = 20
int var = (361 + 20) – (–a); //a = 19
int var = 381 – (–a); //a = 19
int var = 381 – 18; //a = 18
int var = 363 // a = 18
So,
a = 18
var = 363

boolean res = a++ == 7 && ++a == 9 || a++ == 9;
= (a++) == 7 && ++a == 9 || (a++) == 9;
= (a++) == 7 && (++a) == 9 || (a++) == 9;
= ((a++) == 7) && ((++a) == 9) || ((a++) == 9);
= ((a++) == 7) && ((++a) == 9) || ((a++) == 9);
= (((a++) == 7) && ((++a) == 9)) || ((a++) == 9);
= ((7 == 7) && ((++a) == 9)) || ((a++) == 9); //a = 8
= (true && ((++a) == 9)) || ((a++) == 9); //a = 8
= (true && (9 == 9)) || ((a++) == 9); //a = 9
= (true && true) || ((a++) == 9); //a = 9
= true || ((a++) == 9); //a = 9
= true; //a = 9
So,
a = 9
res = true

As there is no brackets after if, hence only one statement is part of if block and other is outside.
Above code can be written as below:
if(grade > 60) {
System.out.println(“Congratulations”);
}
System.out.println(“You passed”);
else
System.out.println(“You failed”);
There should not be anything between if-else block but in this case, System.out.println(“You passed”); is between if-else and thus Compilation error.
As there is no brackets after if, hence only one statement is part of if block and other is outside.
Above code can be written as below:
if(grade > 60) {
System.out.println(“Congratulations”);
}
System.out.println(“You passed”);
else
System.out.println(“You failed”);
There should not be anything between if-else block but in this case, System.out.println(“You passed”); is between if-else and thus Compilation error.