Object-Oriented Programming

Native methods are defined to access hardware features that Java doesn't support directly (A), and to write performance-critical code in lower-level languages like C/C++ (C). They do not define new data types (B is wrong) and don't overcome private scope limitations (D is wrong).

TreeMap implements the SortedMap interface (now NavigableMap in newer Java versions). It maintains keys in sorted order. It does not implement Tree (not a standard interface), Set, or SortedSet.

The java.lang.String class is declared with the final modifier to prevent subclassing, ensuring string immutability and security.

Type erasure is a fundamental process in Java generics where the compiler removes all generic type information at compile time. Generic types like List are converted to their raw forms (List), and type parameters are replaced with their bounds or Object. This ensures backward compatibility with pre-generic Java code while maintaining type safety during compilation.

Java uses the 'extends' keyword to declare bounded type parameters in generics, regardless of whether you're bounding to a class or interface. This creates an upper bound - the type parameter must be the specified type or a subclass. 'implements' is used for class declarations, not type parameters. 'extend' is a common misspelling - the keyword is 'extends'.

The line A = B reassigns the class name A to point to class B. Therefore, A() creates an instance of class B, and calling a.foo() executes B's foo method, which prints 'Hi 3'.

Inversion of Control/Dependency Injection in Spring can be implemented through three main types: Interface Injection (where dependencies are injected through interfaces), Setter Injection (through setter methods), and Constructor Injection (through constructor parameters).

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.

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.

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.

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.