Object-Oriented Programming

Reflection is possible in Java because of late binding - method and field references are resolved at runtime rather than compile time. This allows programs to inspect and modify their own structure and behavior dynamically.

Because Java is a strongly (or tightly) typed language, methods cannot accept arbitrary types without explicit definitions. To allow assertions on different data types (like integers, booleans, floats, and objects), the Assert class must provide multiple overloaded implementations of its assertion methods.

In Java, Throwable is the ultimate superclass of all errors and exceptions. While Exception is the superclass of all checked and unchecked exceptions, it inherits from Throwable. Therefore, saying Exception is the absolute superclass of all exceptional events is technically false because Throwable sits at the top of the hierarchy.

Exception handling in Java follows polymorphism. A catch block designed to handle a superclass exception type will also successfully catch any exception object that inherits from that superclass.

The code is illegal because ExceptionA is a checked exception thrown by thrower(). The try block only catches ExceptionB, which is a subclass of ExceptionA. Since the superclass exception ExceptionA is neither caught nor declared in the main method's signature, the code fails to compile.

In Java applets, painting requires a proper class structure extending Applet or JApplet to provide the drawing surface. Import statements are needed for graphics classes like Graphics. The drawString method must be called within a method like paint() that belongs to a properly defined applet class. All three reasons explain why a single painting line is insufficient.

Javadoc automatically inherits documentation when a method overrides a superclass method, overrides a superinterface method, or implements an interface method. This prevents redundant documentation. However, constructors cannot be overridden in Java, meaning they cannot inherit comments, making that option incorrect.

Access modifiers (public, private, protected) can be applied to both data fields and methods. They precede the member declaration and can appear in any order relative to other modifiers like static or final. The statement that they can follow data variables is incorrect.

Local inner classes are declared inside method blocks and are not associated with any outer class instance. They can only access final or effectively final local variables and parameters from their enclosing scope. They cannot have access modifiers (public, protected, private) and can implement interfaces.

Inheritance models an is‑a relationship (a subclass is‑a type of its superclass). A has‑a relationship is expressed by including instance variables that reference other objects. Therefore the true statements are the inheritance one and the instance‑variable one; the others mischaracterize the relationships.

In Pega's class hierarchy, @baseclass is the ultimate root class from which all classes inherit. Top-level classes directly inherit from @baseclass, while Work- and other pattern classes are specialized subclasses. Business logic resides in lower-level implementation classes, not top-level structural ones.

The java.lang package provides classes fundamental to the Java programming language itself, including Object, String, wrapper classes, and basic math operations. This package is automatically imported into all Java programs. Java.nio handles I/O, Java.rmi handles remote method invocation, and Java.basic is not a standard package.

During serialization, the parent class constructor is called when creating c1, printing 'p', then child constructor prints 'c'. During deserialization, constructors are not called for the object itself, but the parent class constructor runs again, printing another 'p'. The output is 'pcp'. Option C is correct.

When overriding a protected method in Java, the subclass method must have the same or wider access modifier. Protected is the baseline, so valid options are Protected (same) or Public (wider). Private is narrower and thus invalid. Option E correctly identifies Protected and Public as valid.

During Java serialization, fields marked with the 'transient' keyword are explicitly ignored and not written to the serialization stream. This allows developers to exclude sensitive or non-serializable data. Static fields are also not serialized, but 'transient' is the specific mechanism for ignoring instance fields.