Core Java Tricky Coding & Scenario-Based Interview Questions

Understand how string literals go to the string constant pool, how new creates heap objects, and how intern reuses the pooled reference, so s1 and s2 are equal.

Examine how string literals use the string constant pool, how new creates heap objects, and how == compares references, showing s1 and s2 not equal and s1 and s3 equal.

Explore autoboxing in Java and the integer cache (-128 to 127), showing how 100 uses the cached object while 200 creates objects, and how == differs from equals for wrappers.

Java strings are immutable; concat returns a new string and does not modify the original, so s remains hello and the program prints hello.

Java is passed by value, a copy of the reference points to the same object, so changing t.x inside a method updates obj.x and outputs 20.

See how java char values are stored as unicode numbers and how the plus operator performs numeric addition, producing 418 rather than the string 'java'; double quotes would trigger concatenation.

Explore a famous Java interview question that demonstrates how try, catch, and finally control returns. The program shows that a finally return overrides previous returns, yielding output 3.

Examine a Java program to master operator precedence, evaluation order and string concatenation; learn how left-to-right evaluation switches from numeric addition to concatenation, producing outputs 30 Java and Java 1020.

Explore a Java program that tests finally block behavior and System.exit termination. The code prints the try message and terminates the JVM, skipping catch and finally.

Explore how method overloading is resolved at compile time in Java using a null argument. The program selects the most specific overload (string) over object, printing string method.

Explore how Java evaluates expressions from left to right, applying operator precedence, switching to string concatenation when a string operand appears, producing 115110 and highlighting numeric addition versus concatenation.

Trace the Java object creation lifecycle by examining class loading, static blocks, instance initialization blocks, and constructors; see how 1 prints once, then 2 and 3 per object.

Explore how Java class loading and static initialization blocks determine execution order, revealing why the program prints StaticBlock before MainMethod.

Explore a Java program that demonstrates try, catch, finally flow, printing a and b, catching an illegal argument exception, then finally prints d and e, producing abcde.

Examine Java string immutability, how concat creates new strings, and why failing to reassign results leads to output 1, highlighting string pool and common interview pitfalls.

demonstrates how inheritance and instance initialization blocks determine the execution order when creating a subclass object, and shows output 1 2 3.

Explore Java method overloading resolution with exact matches, primitive widening, autoboxing, and varargs, and note that narrowing isn’t automatic in this context.

Explore why private methods aren’t inherited or overridden in Java, and see how compile-time binding makes the program print 'parent' despite the child class.

Explore Java method overriding and runtime polymorphism by examining a derived class that calls super.print then prints its own message, illustrating how overridden methods execute based on actual object type.

See how a java program prints 1 and 3 by throwing a number format exception; learn how try-catch skips remaining code, selects the most specific catch, and outputs 13.

Explore how a division by zero triggers an arithmetic exception and how catch and finally interact with returns. Observe the outputs exception caught by zero and result minus one.

Understand how Java's return statements interact with finally blocks through a concrete example, where the return value is determined before finally executes and changes in finally don't alter it.

Learn how constructor order and runtime polymorphism affect output in a Java inheritance scenario: parent constructor runs first, calls an overridden method, producing 'parent', 'child show: x=0', then 'child'.

Explore how string literals, the string constant pool, and heap memory interact with the intern method. Learn how the == operator compares references in Java.

Understand method overloading resolution: primitive widening beats autoboxing, and varargs have the lowest priority; the call with 10 binds to the long parameter, printing foo within brackets long.

Explains a tricky java interview scenario on inheritance and runtime polymorphism. Upcasting is safe; downcasting to a sibling class triggers a class cast exception; use instanceof before casting.

Demonstrate how Java threads handle run versus start and thread execution flow. Explain that calling run runs in the main thread, while start creates a new thread.

Reveal the trick: the color method is not a constructor; Java provides a default constructor. Instance variables default to zero, so the program prints red, zero, green, zero, blue, zero.

Explore how static methods behave in Java with a Dog and Animal example. Learn why static methods don't use runtime polymorphism, due to method hiding and reference type versus object.

Explain how Java caches small integers, showing a==b true and c==d false for 127 and 128, and why you should use dot equals instead of == for Integer objects.

Explore constructor chaining with the this keyword in Java, showing how NoR and int constructors interact, producing the output 'int constructor: 10' and 'NoR constructor'.

Trace a tricky java interview question that uses a postfix increment in the while condition to show why the output is 1, 2, 3, and contrast with prefix increment.

Static blocks run during class loading, before main. A division by zero inside a static block triggers an exception in initializer error, preventing the main method from executing.

Explore how Java's postfix increment works: i = 5; i = i++ yields 5 due to a temporary value, while prefix ++i yields 6; never assign postfix increments back.

Understand how null in a string switch triggers a null pointer exception due to hashcode lookup, and why pre-switch null checks are essential since default is not a null handler.

practice comparing two int arrays with Arrays.equals(a,b) instead of a.equals(b) or a==b, since arrays never override equals and compare by reference. For nested arrays, use Arrays.deepEquals to compare inner contents.

Examine how Java inheritance treats variables, showing that x prints 20, 10, 10 when accessed via child, super, and casting to parent, illustrating variable hiding and compile-time resolution.

Explore a Java for loop that uses a byte variable overflowing at 127, causing an infinite loop and illustrating why data type range matters.

Compare two string builders by reference to reveal that s1.equals(s2) is false while s1.toString().equals(s2.toString()) is true, and note the implications for using mutable objects in hash maps or hash sets.

Unboxing a nullable integer causes a null pointer exception at runtime. Compile-time unboxing hides null risks; always null-check or use a default with a ternary.

Explore a surprising Java constructor example showing runtime polymorphism calls Dog's makeSound during Animal's construction. Avoid this by not invoking overridable methods in constructors; prefer private, final, or static methods.

See how an abstract shape constructor calls the overridden draw method during subclass instantiation, and learn why invoking overridable methods via runtime polymorphism from constructors is dangerous.

Explore covariant return types and runtime polymorphism in a Java example where a Dog overrides getInstance to return Dog, while an Animal reference prints Dog through dynamic dispatch.

Discover how Java's string concatenation treats null as the literal 'null', yielding 'null world' and length 10, and learn to perform a null check before concatenation to avoid silent bugs.

Demonstrate Java string memory by using the string pool and intern, contrast new versus literals, and show how equals is preferred over == for string comparison.

Discover the difference between collectors.toList and stream.toList in Java 16, illustrating mutable versus unmodifiable lists and why choosing the right collection matters in interviews and production code.

Learn why java streams are one-time pipelines: after a terminal operation, a stream is consumed and closed. Create fresh streams each time or collect to a list for multiple iterations.