Java Programming Fundamentals: OOP, Inheritance, and Language Features

The getInitParameter(String name) method of a Servlet returns a String containing the value of the named initialization parameter, or null if the parameter does not exist. Other methods like getServletContext() do not return null.

In Java, ArrayList operations are generally faster than Vector because ArrayList is unsynchronized (not thread-safe) while Vector is synchronized. The synchronization overhead in Vector makes it slower for single-threaded operations. This is a key reason ArrayList was introduced in Java 1.2 as a modern alternative to the legacy Vector class.

The java.io.File class represents file and directory paths abstractly but does NOT provide methods to read or write file content. For reading/writing content, you need separate classes like FileReader, FileWriter, BufferedReader, BufferedWriter, FileInputStream, FileOutputStream, etc. File class only handles file metadata operations like exists(), createNewFile(), delete(), etc.

Final variables must be initialized exactly once. Static final variables get their value from static initializers (or the declaration), while instance final variables can be initialized in constructors (or instance initializers). This is a fundamental Java rule.

Java allows numeric comparison between char (16-bit unsigned) and double. The char 'd' has Unicode value 100, so the comparison ch < 32.00 evaluates to false, but the syntax is valid. Java promotes char to int then to double for the comparison.

Static methods are bound at compile time based on reference type, not actual object type. Parent p = new Child(); p.staticMethod() calls Parent's version. This is because static methods belong to the class, not instances.

Java allows declaring a derived class before its base class in source code. The compiler reads the entire file, so order doesn't matter. However, this is poor practice for readability. The statement is technically True.

Since 'a' is a compile-time constant (final int), 'x' is also a compile-time constant with a value of 10. The compiler allows assigning 'x' directly to byte 'b' without an explicit cast because its value fits within the range of a byte.

Static methods CANNOT be overridden - they can only be hidden. Overriding requires dynamic dispatch based on actual object type, but static methods are bound at compile time. If you define the same static method in a child class, it hides, not overrides.

The main() method can be overloaded (different signatures) but the standard String[] variant from Object cannot be overridden because it's static. Static methods belong to the class definition, not instances - no virtual method table lookup.

Comparing with Float.NaN using == always returns false (even Float.NaN == Float.NaN is false by IEEE 754). Float.isNaN(x) is the correct way to check. The claimed answer B is correct.

Method overloading requires different parameter lists (type, count, or order). Return type, access specifier, and exception throws alone don't distinguish overloaded methods - the compiler would see them as duplicate methods.

In Java, an overriding method in a subclass cannot throw broader or more generic checked exceptions than the overridden method in the superclass. Doing so violates the Liskov Substitution Principle and causes a compilation error.

The println method in Java exhibits overloading because there are multiple versions of println that accept different parameter types (int, String, boolean, etc.), all sharing the same name but different signatures. Overriding requires inheritance and redefining a method in a subclass, which is not what println demonstrates.

When -1 is assigned to an unsigned int, it wraps around to the maximum value (all bits set to 1). The bitwise NOT of 0 (~0) also produces all bits set to 1. Therefore, both x and y hold the same bit pattern and the comparison 'x == y' evaluates to true, printing 'same'.

The post-increment operator (a++) passes the current value of 'a' to the function, then increments it afterward. Since 'a' is initialized to 1, the value 1 is passed to f1() and printed. The increment happens after the function call completes.

Pointer arithmetic advances by the size of the pointed-to type. char* increments by 1 byte, int* by sizeof(int) (2 bytes on typical 16-bit systems), and long* by sizeof(long) (4 bytes on typical 32-bit systems). Starting from 0, the pointers become 1, 2, and 4 respectively.