Object-Oriented Programming

You can declare a reference variable of an abstract class type. While you cannot instantiate an abstract class directly using new, the reference can point to instances of any concrete subclasses.

In Java, every class implicitly extends java.lang.Object. Therefore, the superclass of Class is Object. The option text 'Class object' refers to the Object class, which is the root of the class hierarchy.

Default (package-private) access is the most restrictive that allows classes in the same package to access members. Public allows access from anywhere, private restricts access to the same class only, and protected allows access to subclasses (even in different packages).

In Java, interfaces CAN have variables, but they must be public, static, and final constants (implicitly all three). The statement 'An Interface can have a variable' is correct if referring to constant fields. Interfaces cannot have instance variables or mutable fields. Options B, C, and D describe what interface members CAN be (public, static, final), so they are not incorrect statements.

In .NET, classes declared at the namespace level can only use public or internal access modifiers. The Protected modifier is only valid for class members (nested classes, methods, properties), not for top-level class declarations.

Classes declared directly within a namespace cannot be declared as private in .NET. Namespace-level classes can only be public or internal. The Private modifier is only valid for nested class declarations inside another class.

All three statements describe why Java avoids global variables: they break referential transparency, reduce cohesion, and limit reusability by tying code to a single instance. Since each individual reason is valid, the combined choice “All of above” correctly captures the rationale.

Class.forName is used to load classes dynamically at runtime by passing their fully qualified name as a string. It is a fundamental mechanism for dynamic class loading in Java.

An abstract method cannot be declared as final in Java because abstract methods are meant to be overridden in subclasses, whereas final methods cannot be overridden. Thus, this combination causes a compilation error.

In Java, the String class is declared as final, which prevents any class from extending it. Therefore, you cannot inherit from or extend the String class.

In Java, this() is a special syntax used inside a constructor to invoke another overloaded constructor within the same class (constructor chaining). It must be the first statement in the constructor. It does not instantiate new objects directly or call subclass constructors.

The Factory Pattern is classified as a creational design pattern because it provides an interface for creating objects without specifying their exact classes. It delegates object instantiation to subclasses or factory methods, promoting loose coupling by letting code depend on abstractions rather than concrete implementations. This is in contrast to structural patterns like composite or behavioral patterns like command.

The singleton pattern requires a private constructor to prevent external instantiation. This ensures only one instance can exist. Making constructors public would allow multiple instances, violating the singleton principle.

In standard object-oriented theory and subtyping relationships, subclassing is reflexive: every class is considered a subclass of itself (a non-strict subclass). However, in languages like Java, a class is not a strict subclass of itself. Given standard OOP type theory, the statement is accepted as True.