Java Programming Fundamentals

Constructors are used to initialize new object instances and cannot be declared static. Making a constructor static would prevent it from accessing instance variables and instance methods, which contradicts its purpose. Therefore, constructors can never be static, and the stored answer 'False' is correct.

Static methods belong to the class rather than any specific object instance. Consequently, they do not have access to an instance context and cannot use the this keyword. Attempting to use this inside a static method results in a compile-time error, making 'No' the only correct option.

In Java, local variables inside methods cannot have access modifiers (private, protected, public). These modifiers only apply to class members (fields and methods). Lines 2, 3, and 4 attempt to declare local variables with access modifiers, which is a compile error. Line 5 uses these variables, adding to the errors. The class-level 'int i' is valid shadowed by the local 'int i' at line 1.

This switch statement lacks 'break' statements, causing fall-through execution. When i1 equals 1, case 1 matches and 'one' is printed, but execution continues through case 2 (printing 'two') and case 3 (printing 'three'). This is the default switch behavior in Java - without explicit breaks, all cases after the matching case execute sequentially.

Java has 50 reserved keywords including 'new' (instantiation), 'break' (loop exit), and 'default' (switch/annotation default). 'goto' is a reserved keyword but not used in Java - it's reserved for potential future use but has no functionality. Option D is incorrect because goto is indeed a reserved keyword in Java.

Java primitive types have fixed sizes: int is 32-bit signed integer, float is 32-bit IEEE 754 floating-point, long is 64-bit signed integer. Option D is incorrect because short is 16-bit signed, not 18-bit. These sizes are guaranteed across all JVM implementations for consistency.

Top-level classes (not nested inside another class) can only be marked 'public' or have default (package) access. Synchronized, private, and transient modifiers are not allowed at the top level - synchronized is used for methods, and private/transient are for class members. Options B, C, D are incorrect modifiers for top-level classes.

The '?:' operator in Java is the ternary conditional operator (also called the conditional operator). It evaluates a boolean expression and returns one of two values based on whether the expression is true or false. It's not an assignment operator, bitwise operator, or any other type - it's specifically for conditional expressions.

Java bitwise operators include ~ (bitwise NOT/complement), << (left shift), >> (right shift), and >>> (unsigned right shift). Option D '&&' is the logical AND operator, not bitwise - it operates on boolean values, not individual bits. Options A, B, C are all valid bitwise operators in Java.

Java switch expressions can only be of types byte, short, char, int, and their wrapper classes, plus enums and Strings (Java 7+). Float and double are not allowed because they require comparison with == which is unreliable for floating-point. Options A, B, C list valid integral types. Option D (float) is invalid.

In Java, all classes implicitly extend from java.lang.Object, which is the root of the class hierarchy. The package name is java.lang, but the actual class name is Object (capitalized). Options B and D are incorrect - java.lang is a package, java.lang.String is a specific class. Option A has the class name capitalized correctly.

The abstract keyword in Java serves two main purposes: preventing class instantiation and declaring methods without implementation. Option A is correct because abstract classes cannot be instantiated directly - they must be extended by concrete subclasses. Option B is correct because abstract methods declare the method signature without providing a body, leaving the implementation to concrete subclasses. Options C and D are incorrect - abstract can be used with fields in certain contexts (though not abstract fields themselves), and abstract is a valid part of Java.

In Java, 'final' is a keyword for variables/methods/classes that cannot be changed/extended. 'finally' is a keyword used in try-catch blocks for code that always executes. 'finalize()' is a method name (deprecated) for garbage collection cleanup. However, 'finalised' is NOT part of the Java language - it's a common misspelling. The correct answer is D because it's the only option that is not a valid Java keyword or method.

The 'super' keyword in Java specifically refers to the immediate parent class of the current subclass. It allows you to access parent class methods, constructors, and fields, but only ONE level up in the inheritance hierarchy. You cannot use 'super' to access a grandparent class directly - you would need to chain through the parent class. Option A is correct.

This line compiles successfully assuming the variables i and j are declared as compatible numeric types. The initialization, condition, and update expressions within the for-loop header follow standard Java syntax. The distractor options incorrectly claim compilation failure or suggest unnecessary changes to the loop structure.

The 'super' keyword in Java provides access to the immediate parent class (one level up in the inheritance hierarchy). It can be used to call parent class constructors, access hidden fields, or invoke overridden methods. This statement is True - super only goes one level up to the direct parent.

The ?: operator is Java's ternary operator, which evaluates a boolean expression and returns one of two values based on the result. It is classified as a conditional operator because it conditionally executes expressions. The alternative option 'False' is incorrect because it contradicts this standard definition.

Final methods in Java CANNOT be overridden by subclasses. The final keyword specifically prevents modification - it's the entire purpose. When a method is declared final, subclasses must use it as-is and cannot provide their own implementation. Therefore the answer 'False' to 'Can final method be overridden?' is correct.

Java does not perform automatic narrowing conversions from a larger primitive type like long to a smaller primitive type like int, even if the specific value fits. An explicit cast is required to convert a long to an int.