Java Basics — Part 2: Methods, Memory & Strings

Continuation from Part 1: Language Fundamentals — Platform, Types, Variables, Operators, Control Flow, Arrays.

7. Methods

Method Signature and Overloading

public class MethodDemo {
    // Method signature = name + parameter types (NOT return type)

    // Overloading: same name, different parameters
    public int add(int a, int b) { return a + b; }
    public double add(double a, double b) { return a + b; }
    public int add(int a, int b, int c) { return a + b + c; }

    // THIS IS NOT OVERLOADING (compile error):
    // public long add(int a, int b) { return a + b; } // same params, different return

    // Varargs (must be last parameter, treated as array)
    public int sum(int... numbers) {
        int total = 0;
        for (int n : numbers) total += n;
        return total;
    }
    // sum(), sum(1), sum(1,2,3) — all valid
}

Overloading Resolution Rules

public void test(int x) { }       // (1)
public void test(long x) { }      // (2)
public void test(Integer x) { }   // (3)
public void test(int... x) { }    // (4)

test(5);  // Calls (1) — exact match
// Resolution priority: exact match → widening → boxing → varargs
// If (1) removed: calls (2) — widening int→long
// If (1)&(2) removed: calls (3) — autoboxing int→Integer
// If (1)&(2)&(3) removed: calls (4) — varargs (last resort)

Method Call Stack

%%{init: {'theme': 'base', 'themeVariables': {'fontSize': '13px', 'fontFamily': 'Inter, -apple-system, sans-serif'}, 'flowchart': {'nodeSpacing': 30, 'rankSpacing': 50, 'padding': 12, 'curve': 'basis'}, 'sequence': {'actorMargin': 60, 'messageMargin': 40}, 'class': {'padding': 12}}}%%
flowchart LR
    subgraph STACK["Thread Stack"]
        direction LR
        M1["main()<br/>args, localVars"]
        M2["calculate()<br/>x=5, y=10"]
        M3["helper()<br/>temp=15"]
    end

    M1 ==> M2 ==> M3
    M3 -.->|"returns"| M2
    M2 -.->|"returns"| M1

    style M1 fill:#DBEAFE,stroke:#93C5FD,color:#1E40AF
    style M2 fill:#D1FAE5,stroke:#6EE7B7,color:#065F46
    style M3 fill:#FEF3C7,stroke:#FCD34D,color:#92400E

Each method call creates a stack frame containing: local variables, parameters, return address, and operand stack. Frames are pushed on call and popped on return. StackOverflowError = too many frames (infinite recursion).

8. Memory Basics — Stack vs Heap

%%{init: {'theme': 'base', 'themeVariables': {'fontSize': '13px', 'fontFamily': 'Inter, -apple-system, sans-serif'}, 'flowchart': {'nodeSpacing': 30, 'rankSpacing': 50, 'padding': 12, 'curve': 'basis'}, 'sequence': {'actorMargin': 60, 'messageMargin': 40}, 'class': {'padding': 12}}}%%
flowchart LR
    subgraph STACK["Stack (per thread)"]
        direction LR
        S1["Primitives<br/>int x = 42"]
        S2["References<br/>Employee ref"]
        S3["Method frames"]
    end

    subgraph HEAP["Heap (shared)"]
        direction LR
        H1["Objects<br/>new Employee()"]
        H2["Arrays<br/>new int[100]"]
        H3["String Pool<br/>literal strings"]
    end

    S2 ==>|"points to"| H1

    style S1 fill:#DBEAFE,stroke:#93C5FD,color:#1E40AF
    style S2 fill:#DBEAFE,stroke:#93C5FD,color:#1E40AF
    style S3 fill:#DBEAFE,stroke:#93C5FD,color:#1E40AF
    style H1 fill:#D1FAE5,stroke:#6EE7B7,color:#065F46
    style H2 fill:#D1FAE5,stroke:#6EE7B7,color:#065F46
    style H3 fill:#FEF3C7,stroke:#FCD34D,color:#92400E

Pass-by-Value (Java is ALWAYS pass-by-value)

Java does not have pass-by-reference. It passes the value of the reference (for objects) or the value itself (for primitives).

Primitives — value is copied:

public class PassByValueDemo {

    static void change(int x) {
        x = 100;  // modifies local copy only
    }

    public static void main(String[] args) {
        int num = 42;
        change(num);
        System.out.println(num);  // 42 (unchanged)
    }
}

Objects — reference value is copied (not the object):

public class ReferenceDemo {

    static void changeName(Employee e) {
        e.setName("Krishna");  // modifies SAME object via shared reference
    }

    static void reassign(Employee e) {
        e = new Employee("Ravi");  // new LOCAL reference — caller unaffected
    }

    public static void main(String[] args) {
        Employee emp = new Employee("Vamsi");

        changeName(emp);
        System.out.println(emp.getName());  // "Krishna" — object was modified

        reassign(emp);
        System.out.println(emp.getName());  // "Krishna" — reassign had no effect
    }
}

%%{init: {'theme': 'base', 'themeVariables': {'fontSize': '13px', 'fontFamily': 'Inter, -apple-system, sans-serif'}, 'flowchart': {'nodeSpacing': 30, 'rankSpacing': 50, 'padding': 12, 'curve': 'basis'}, 'sequence': {'actorMargin': 60, 'messageMargin': 40}, 'class': {'padding': 12}}}%%
flowchart LR
    subgraph BEFORE["Before reassign()"]
        direction LR
        REF1["caller emp"] ==> OBJ1["Employee<br/>name=Krishna"]
        REF2["param e"] ==> OBJ1
    end

    subgraph AFTER["After e = new Employee()"]
        direction LR
        REF3["caller emp"] ==> OBJ2["Employee<br/>name=Krishna"]
        REF4["param e"] ==> OBJ3["Employee<br/>name=Ravi"]
    end

    style REF1 fill:#DBEAFE,stroke:#93C5FD,color:#1E40AF
    style REF2 fill:#DBEAFE,stroke:#93C5FD,color:#1E40AF
    style OBJ1 fill:#D1FAE5,stroke:#6EE7B7,color:#065F46
    style REF3 fill:#DBEAFE,stroke:#93C5FD,color:#1E40AF
    style REF4 fill:#FEE2E2,stroke:#FCA5A5,color:#991B1B
    style OBJ2 fill:#D1FAE5,stroke:#6EE7B7,color:#065F46
    style OBJ3 fill:#FEE2E2,stroke:#FCA5A5,color:#991B1B

9. String Basics

Immutability and the String Pool

%%{init: {'theme': 'base', 'themeVariables': {'fontSize': '13px', 'fontFamily': 'Inter, -apple-system, sans-serif'}, 'flowchart': {'nodeSpacing': 30, 'rankSpacing': 50, 'padding': 12, 'curve': 'basis'}, 'sequence': {'actorMargin': 60, 'messageMargin': 40}, 'class': {'padding': 12}}}%%
flowchart LR
    subgraph POOL["String Pool (Heap)"]
        direction LR
        P1["'Hello'"]
        P2["'World'"]
    end

    subgraph HEAP["Regular Heap"]
        direction LR
        H1["new String('Hello')"]
    end

    S1["String s1 = 'Hello'"] ==> P1
    S2["String s2 = 'Hello'"] ==> P1
    S3["String s3 = new String('Hello')"] ==> H1

    style P1 fill:#D1FAE5,stroke:#6EE7B7,color:#065F46
    style P2 fill:#D1FAE5,stroke:#6EE7B7,color:#065F46
    style H1 fill:#FEF3C7,stroke:#FCD34D,color:#92400E
    style S1 fill:#DBEAFE,stroke:#93C5FD,color:#1E40AF
    style S2 fill:#DBEAFE,stroke:#93C5FD,color:#1E40AF
    style S3 fill:#FEE2E2,stroke:#FCA5A5,color:#991B1B

String s1 = "Hello";              // from pool
String s2 = "Hello";              // same pool reference
String s3 = new String("Hello");  // new object on heap (bypasses pool)

s1 == s2;          // true (same pool reference)
s1 == s3;          // FALSE (different objects)
s1.equals(s3);     // true (same content)
s3.intern() == s1; // true (intern() returns pool reference)

Why Strings Are Immutable

1. String Pool works — if Strings were mutable, changing one would corrupt all references
2. Thread-safe — no synchronization needed for shared Strings
3. Security — class names, URLs, passwords can't be modified after creation
4. hashCode caching — computed once, used forever (crucial for HashMap keys)

Concatenation Performance

// BAD: O(n^2) — creates new String each iteration
String result = "";
for (int i = 0; i < 10000; i++) {
    result += i;  // new StringBuilder + toString() each time
}

// GOOD: O(n) — single StringBuilder
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 10000; i++) {
    sb.append(i);
}
String result = sb.toString();

10. Common Pitfalls — Production Bugs

Integer Overflow (Silent Killer)

int a = Integer.MAX_VALUE;  // 2,147,483,647
int b = a + 1;              // -2,147,483,648 (wraps around silently!)

// Production bug: array size calculation
int size = numRows * numCols;  // can overflow for large matrices!
// Fix: use Math.multiplyExact() (throws ArithmeticException on overflow)
int size = Math.multiplyExact(numRows, numCols);

Floating Point Comparison

double result = 0.1 + 0.2;
System.out.println(result == 0.3);  // FALSE! result = 0.30000000000000004

// Fix: use threshold comparison or BigDecimal
System.out.println(Math.abs(result - 0.3) < 1e-9);  // true

// For financial calculations: ALWAYS use BigDecimal
BigDecimal price = new BigDecimal("0.1");
BigDecimal tax = new BigDecimal("0.2");
BigDecimal total = price.add(tax);  // exactly 0.3

Autoboxing/Unboxing Traps

// Integer cache: -128 to 127 are cached
Integer a = 127;
Integer b = 127;
System.out.println(a == b);  // TRUE (same cached object)

Integer c = 128;
Integer d = 128;
System.out.println(c == d);  // FALSE (different objects!)
System.out.println(c.equals(d));  // true

// NullPointerException from unboxing
Integer x = null;
int y = x;  // NPE! unboxing null throws NullPointerException

// Performance trap: unintentional boxing in loops
Long sum = 0L;  // Long (wrapper) not long (primitive)
for (long i = 0; i < 1_000_000; i++) {
    sum += i;  // creates a new Long object every iteration!
}

== vs equals() on Strings

String s1 = "hello";
String s2 = "hello";
String s3 = new String("hello");
String s4 = "hel" + "lo";          // compile-time constant → pool
String prefix = "hel";
String s5 = prefix + "lo";         // runtime concatenation → new object

s1 == s2;   // true  (pool)
s1 == s3;   // false (new object)
s1 == s4;   // true  (compile-time constant folding)
s1 == s5;   // FALSE (runtime concat, new object!)

Null Handling

// NullPointerException is Java's #1 runtime exception
String name = null;
name.length();  // NPE

// Safe patterns:
// 1. Null check
if (name != null && name.length() > 0) { }

// 2. Objects.requireNonNull (fail-fast in constructor/method entry)
public void setName(String name) {
    this.name = Objects.requireNonNull(name, "name cannot be null");
}

// 3. Optional (Java 8+)
Optional<String> opt = Optional.ofNullable(name);
opt.ifPresent(n -> System.out.println(n.length()));
String result = opt.orElse("default");

11. Interview Questions — FAANG Level

Integer a = 100, b = 100;
Integer c = 200, d = 200;
System.out.println(a == b);
System.out.println(c == d);

String s1 = "Hello";
String s2 = "Hel" + "lo";
String s3 = "Hel";
String s4 = s3 + "lo";
System.out.println(s1 == s2);
System.out.println(s1 == s4);

int x = 5;
int y = x++ + ++x;
System.out.println("x=" + x + " y=" + y);

int[] arr = {1, 2, 3};
modify(arr);
System.out.println(Arrays.toString(arr));

void modify(int[] a) {
    a[0] = 99;
    a = new int[]{4, 5, 6};
}

Object obj = true ? new Integer(1) : new Double(2.0);
System.out.println(obj);

public static int getValue() {
    try { return 1; }
    finally { return 2; }
}
System.out.println(getValue());

String s = new String("Hello");

int x = 0;
boolean result = (x != 0) && (10 / x > 1);
System.out.println(result);

int x = 1;
switch(x) {
    case 1: System.out.print("A");
    case 2: System.out.print("B");
    case 3: System.out.print("C");
    default: System.out.print("D");
}

12. Quick Recall

Interview Answer Template