Object-Oriented Programming

In Java, a top-level class with no access modifier (default/package-private) is accessible only within its own package. Private cannot be used for top-level classes, final prevents inheritance but doesn't control access, and protected allows broader access.

Abstract classes cannot be instantiated directly (true). Constructors cannot be abstract (true). Subclasses must implement abstract methods only if they are concrete - abstract subclasses can leave them undefined (false). Static methods cannot be abstract (false).

Protected members are visible within the same package (like default) AND to subclasses in other packages. This combines package-level access with inheritance access. Private is class-only, default is package-only.

The Java compiler only inserts a default, no-argument constructor if the class does not define any constructors. If any constructor is explicitly defined, the compiler does not insert one.

In Java, object references are passed by value - meaning a copy of the reference is passed to the method, not the original reference itself or the object. The called method receives its own copy of the reference, which points to the same object. If the method reassigns the reference parameter, it doesn't affect the caller's reference - but modifications to the object's state are visible since both references point to the same object. Option B correctly captures this 'copy of reference' behavior.

Constructors cannot be abstract because they're meant to be called when creating an instance of a class. An abstract class cannot be instantiated directly, so having an abstract constructor would be contradictory. When you inherit from an abstract class, you must call a concrete constructor from the base class. If constructors could be abstract, there would be no guaranteed way to initialize the base class. This is a fundamental rule in object-oriented programming.

In Java, if a class contains one or more abstract methods, the class itself must be declared abstract. A non-abstract (concrete) class cannot have abstract methods because it cannot be instantiated - abstract methods have no implementation and must be implemented by concrete subclasses. This is a fundamental rule of Java's object-oriented design.

According to the Java Language Specification, a source file is officially termed a 'compilation unit'. This is the formal terminology used throughout Java's documentation and specifications. Each compilation unit typically contains at most one public class or interface declaration and can include package and import statements.

In Java, functions are called 'methods' because they must belong to a class. C/C++ has standalone functions that exist independently of classes, while Java requires all code to be within classes. This terminology reflects Java's object-oriented design where everything exists within a class context.

Java source files must use the .java extension as required by the Java compiler (javac). The .h extension is for C/C++ header files, and .class is the extension for compiled bytecode files produced by the compiler, not source files. Option C '>java' appears to be a typo or formatting error.

When Java source code is compiled, each class is converted to bytecode and stored in a separate file with the .class extension. This bytecode file contains instructions that the JVM can execute. The filename matches the class name (case-sensitive).

Java is Architectural Neutral because the compiled bytecode can run on any processor architecture. The JVM abstracts the underlying hardware, allowing the same bytecode to execute on different platforms without recompilation. This is a key feature that enables Java's 'write once, run anywhere' capability.