What I Wish Every Java Developer Candidate Knew Before Walking In

Q: What is polymorphism?

A: Polymorphism means one thing having many forms.
There are two types: compile-time and runtime.

(Correct, but every candidate says this.
The interviewer still does not know if you can use it.)

Q: What is polymorphism?

A: It lets one reference type call behaviour that
depends on the actual object. For example:

  List<Shape> shapes = List.of(new Circle(2), new Square(3));
  for (Shape s : shapes) {
      System.out.println(s.area());
  }

Each object runs its own area(). The loop never
checks the type. That is why adding a Triangle later
needs no change to this loop.

Overloading is the compile-time form; overriding,
like area() here, is the runtime form.

String a = "java";
String b = "java";
String c = new String("java");

System.out.println(a == b);       // true  - same pooled literal
System.out.println(a == c);       // false - c is a new object
System.out.println(a.equals(c));  // true  - same characters
System.out.println(a == c.intern()); // true - intern() returns the pooled one

// What to say:
// == compares references, equals compares content.
// Literals are pooled, so a and b point to the same object.
// Always use equals() for String content.

class Emp {
    final int id;
    Emp(int id) { this.id = id; }

    @Override
    public boolean equals(Object o) {
        return o instanceof Emp e && e.id == id;
    }
    // hashCode NOT overridden
}

Set<Emp> set = new HashSet<>();
set.add(new Emp(1));
System.out.println(set.contains(new Emp(1))); // usually false

// Why: the two objects are equal, but have different
// default hash codes, so HashSet looks in the wrong bucket.
// Fix:
// @Override public int hashCode() { return Integer.hashCode(id); }

// Problem: return the first non-repeating character
// in a string, or '_' if none exists.

import java.util.LinkedHashMap;
import java.util.Map;

public class FirstUnique {

    static char firstNonRepeating(String s) {
        Map<Character, Integer> counts = new LinkedHashMap<>();
        for (char ch : s.toCharArray()) {
            counts.merge(ch, 1, Integer::sum);
        }
        for (Map.Entry<Character, Integer> e : counts.entrySet()) {
            if (e.getValue() == 1) {
                return e.getKey();
            }
        }
        return '_';
    }

    public static void main(String[] args) {
        System.out.println(firstNonRepeating("swiss"));  // w
        System.out.println(firstNonRepeating("aabb"));   // _
        System.out.println(firstNonRepeating(""));       // _
    }
}

BEFORE CODING
"Is the input only lowercase letters? Can it be empty?
Should uppercase and lowercase count as different?"

APPROACH
"I will count characters in a LinkedHashMap, which keeps
insertion order, then return the first with count 1.
That is O(n) time and O(k) space for k distinct chars."

TESTING
"swiss -> s appears 3 times, w once, so w.
aabb -> nothing unique, so underscore.
Empty string -> loop never runs, so underscore."

IMPROVEMENT
"If input is only a-z, an int[26] array would avoid
boxing and be faster."

REVISE (say each answer aloud, 1 minute each)

[ ] OOP pillars with one code example each
[ ] String vs StringBuilder vs StringBuffer
[ ] equals / hashCode contract + failing example
[ ] HashMap get/put flow, collisions, Java 8 tree bins
[ ] ArrayList vs LinkedList: when each wins
[ ] Checked vs unchecked exceptions, with examples
[ ] final / finally / finalize differences
[ ] Streams: map, filter, collect, groupingBy
[ ] One multithreading basic: synchronized vs volatile
[ ] Your project: problem, decision, trade-off

SETUP

Online round:
[ ] Laptop charged, charger plugged in
[ ] JDK installed and on PATH: run java -version
[ ] Practise once in a plain online editor, no IDE
[ ] Camera, mic and stable internet tested
[ ] Project running locally, ready to share screen

In-person round:
[ ] Printed resume copies
[ ] Pen and a few sheets for planning code
[ ] Route and reporting time confirmed
[ ] Project screenshots or a short demo on phone

ANSWER PLAN

Intro (60 s):
  I am ______, I work with Java and Spring Boot.
  My strongest project is ______, where I solved ______.
  I am interested in this role because ______.

For any theory question:
  definition -> small example -> why it matters

For any coding question:
  clarify -> approach + complexity -> code
  -> dry run with an edge case -> possible improvement

For 'I don't know':
  "I haven't used that, but here is what I know
   that is closest, and how I would find out."