(1), (2) and (6) are valid array declarations.

Option (3) is not a correct array declaration. The compiler complains with: illegal 

start of type. The brackets are in the wrong place. The following would work: public

 int[ ] a

Option (4) is not a correct array declaration. The compiler complains with: ']' 

expected. A closing bracket is expected in place of the 3. The following works: 

private int a []

Option (5) is not a correct array declaration. The compiler complains with 2 errors:

']' expected. A closing bracket is expected in place of the 3 and

<identifier> expected A variable name is expected after a[ ] .

(3) is correct because an abstract class doesn't have to implement any or all of its 

interface's methods. (4) is correct because the method is correctly implemented 

((7 > 4) is a boolean).

(1) is incorrect because interfaces don't implement anything. (2) is incorrect because 

classes don't extend interfaces. (5) is incorrect because interface methods are implicitly

 public, so the methods being implemented must be public.

None.

None.

When we pass an argument by call-by-value a copy of argument is made into the formal parameter 

of the subroutine and changes made on parameters of subroutine have no effect on original argument,

 they remain the same.

continue and break are jump statements, and for is an looping statement.

Option A compiles without problem.

Option B gives error - non-static variable cannot be referenced from a 

static context.

Option C package ot does not exist.

Option D gives error - non-static variable cannot be referenced from a 

static context.

Access modifiers dictate which classes, not which instances, may access features.

Methods and variables are collectively known as members. Method and variable 

members are given access control in exactly the same way.

private makes a member accessible only from within its own class

protected makes a member accessible only to classes in the same package or 

subclass of the class

default access is very similar to protected (make sure you spot the difference) 

default access makes a member accessible only to classes in the same package.

public means that all other classes regardless of the package that they belong to, 

can access the member (assuming the class itself is visible)

final makes it impossible to extend a class, when applied to a method it prevents a 

method from being overridden in a subclass, when applied to a variable it makes it 

impossible to reinitialise a variable once it has been initialised

abstract declares a method that has not been implemented.

transient indicates that a variable is not part of the persistent state of an object.

volatile indicates that a thread must reconcile its working copy of the field with the 

master copy every time it accesses the variable.

After examining the above it should be obvious that the access modifier that provides 

the most restrictions for methods to be accessed from the subclasses of the class 

from another package is C - protected. A is also a contender but C is more restrictive, 

B would be the answer if the constraint was the "same package" instead of "any package" 

in other words the subclasses clause in the question eliminates default.

switch statements checks for equality between the controlling variable and its constant cases.

None.