Java Programming Fundamentals

In Java, the switch expression must evaluate to a compatible type (such as int, char, String, or enum). Using a long variable (i) in a switch statement is illegal and causes a compiler error.

The Java compiler only inserts a default, no-argument constructor if the class does not define any constructors. If any constructor is explicitly defined, the compiler does not insert one.

In Java, object references are passed by value - meaning a copy of the reference is passed to the method, not the original reference itself or the object. The called method receives its own copy of the reference, which points to the same object. If the method reassigns the reference parameter, it doesn't affect the caller's reference - but modifications to the object's state are visible since both references point to the same object. Option B correctly captures this 'copy of reference' behavior.

The statement is false. Java's arithmetic type promotion rules are more nuanced than simply taking the 'widest' type. For binary operations, Java uses 'widening primitive conversion' which promotes smaller types to int or long specifically, not just to the widest operand. For example, byte + byte produces int, not byte. char + byte produces int. Only if both operands are at least int does the result type become the wider of the two. The rule is: if either operand is double, result is double; else if float, result is float; else if long, result is long; otherwise, result is int.

In Java, an if statement condition must evaluate to a boolean value. Passing an integer variable i directly into the condition is illegal and causes a compilation error.

Constructors cannot be abstract because they're meant to be called when creating an instance of a class. An abstract class cannot be instantiated directly, so having an abstract constructor would be contradictory. When you inherit from an abstract class, you must call a concrete constructor from the base class. If constructors could be abstract, there would be no guaranteed way to initialize the base class. This is a fundamental rule in object-oriented programming.

In Java, the boolean primitive type has exactly two literal values: true and false, both strictly in lowercase. Java is case-sensitive, so TRUE and FALSE are not valid boolean literals (they are not defined keywords). Option C incorrectly includes uppercase variants, while Option A suggests numeric values which are completely invalid for boolean types.

In Java, if a class contains one or more abstract methods, the class itself must be declared abstract. A non-abstract (concrete) class cannot have abstract methods because it cannot be instantiated - abstract methods have no implementation and must be implemented by concrete subclasses. This is a fundamental rule of Java's object-oriented design.

In C, the malloc() function allocates memory dynamically on the heap. The statement 'char *ptr = malloc(10);' allocates 10 bytes on the heap and stores the address in pointer ptr (which itself is on the stack). The stack is used for local variables, code segment for instructions, and data segment for static/global variables.

Static variables in C are stored in the data segment (specifically, the .data or .bss section depending on initialization). Unlike local variables which are on the stack, static variables retain their value across function calls and are allocated when the program starts, persisting for the entire program duration. Heap is for dynamic allocation (malloc/free) and code segment stores executable instructions.

The variable test1 is a local non-static variable declared inside the func() function, so it is allocated on the stack. Local variables (automatic storage duration) are created on the stack when the function is called and destroyed when the function returns. Heap is for dynamic allocation (malloc), code segment for instructions, and data segment for static/global variables.

The code segment (also called the text segment) stores the program's compiled machine instructions and is read-only to prevent self-modification. Heap and stack are dynamic memory areas used for read-write operations during program execution, while the data segment contains initialized and uninitialized global/static variables that can be modified.

String literals are stored in read-only memory and attempting to modify them results in undefined behavior (typically a segmentation fault). They should be treated as immutable constants. To modify strings, use character arrays or string manipulation functions that create new string objects.

A constructor can be declared as private. This is a common design pattern in Java, frequently used to prevent instantiation or to implement the Singleton pattern.

Overloaded methods are completely independent methods that share the same name but have different parameter lists. They are free to have different access modifiers.

In Java, dividing a floating-point number (double) by zero does not throw an ArithmeticException. Instead, it evaluates to Double.POSITIVE_INFINITY and compiles and runs without errors.

In Java, the finally block is guaranteed to execute even if there is a return statement in the try or catch block, ensuring clean-up code is always run.

Overloaded methods are distinct methods and can throw any checked exceptions. However, overridden methods in subclasses cannot throw new or broader checked exceptions than the original method. Thus, the statement is false.

In Java and other programming languages, the logical AND operator (&&) evaluates to false if at least one of the operands is false. Since A is false, A && B evaluates to false.

The code compiles successfully because k is initialized to 0 by default. The loop condition k<10 is true initially, so the loop body runs. After that, k remains 0 while i increments, so this becomes an infinite loop (until integer overflow). The issue is a logical error, not a compilation error.