Java Programming Fundamentals

Java's Vector class is dynamically resizable and automatically grows its capacity when needed. Unlike fixed-size arrays, Vector will successfully add elements beyond its initial capacity by internally allocating more space, so adding a 6th element to a Vector initialized with capacity 5 will succeed without throwing an exception.

TreeMap stores its elements in a red-black tree, which automatically keeps the keys sorted according to their natural ordering or a custom comparator. HashMap and HashSet use hashing and do not guarantee order, while Map is an interface that cannot be instantiated directly.

In this switch statement, x=2 matches case 2 which has no break statement, causing fall-through to case 3 which prints "3" followed by another fall-through to case 5 which prints "5". The output is therefore "3" and "5" printed on separate lines.

When overriding a method in Java, the argument list (method signature) must exactly match the original method. The return type can be the same or a covariant type (subtype), but the parameter types, order, and number must remain identical for proper override behavior.

Static methods belong to the class, not to instances. When you call a.message() on a null reference, Java doesn't throw a NullPointerException because the call is resolved at compile-time based on the declared type (TestStatic), not the runtime value of the reference.

Static initialization blocks execute first when the class loads, in the order they appear. Then the main method executes. When objects are created with 'new', instance initialization blocks execute before the constructor. Static blocks run only once per class load, not per object creation.

Static blocks execute when the class is loaded, even if no objects are created. Since main() is static, merely loading the class to execute main() triggers all static blocks in order. Instance initialization blocks and constructors only run when 'new' is used.

Static methods are resolved at compile‑time based on the reference type. The variable tsv is declared as TestStaticSub, so TestStaticSub.printP() is called, which prints the unchanged static field p (100). The subclass’s method is never invoked, making the stored answer correct.

You cannot use 'this' inside a static method because 'this' refers to the current instance, but static methods belong to the class not to any instance. The compiler will catch this error at compile-time. The static variable 'p' should be accessed directly or via the class name, not through 'this'.

Most programming languages do not allow comment nesting - once a comment delimiter starts, it cannot contain another comment delimiter of the same type. For example, /* /* */ */ would end at the first */ encountered. Only certain specialized formats support nesting. This question likely refers to Java/C/C++ style comments.

An empty file is syntactically valid as a source file in most programming contexts. While it may not be useful or contain any executable code, it still conforms to file format requirements and can be compiled or processed without errors. The compiler/parser simply finds no content to process.

In most programming languages, octal literals are denoted by a leading zero, not the letter 'O'. For example, 075 is octal, while O75 would typically be interpreted as a variable name. This question is likely about C/C++/Java syntax conventions.

The main method CAN be overloaded - you can have multiple methods named 'main' with different parameter lists. However, only the standard main(String[] args) serves as the JVM entry point. Other overloaded main methods must be called explicitly like any other method. This is a common confusion point.

Java allows the main method to be declared with any of the usual modifiers, including final. Declaring it final simply prevents the method from being overridden, which never happens for static methods anyway, so the statement is valid. The stored answer (True) is therefore correct.

The finalize() method is intended as a finalization hook for releasing system resources (file handles, network connections, native memory) before an object is garbage collected. However, it's deprecated since Java 9 due to unreliability - better to use explicit resource management or try-with-resources. The statement is technically true about its purpose.