Java Basics — Part 1: Language Fundamentals

String name = "Vamsi";           // reference → String object in pool/heap
int[] numbers = {1, 2, 3};      // reference → array object on heap
Employee emp = new Employee();   // reference → Employee object on heap
List<String> list = null;        // reference → nothing (null)

byte b = 10;
int i = b;          // OK: widening (automatic)
byte x = i;         // COMPILE ERROR: narrowing requires cast
byte y = (byte) i;  // OK: explicit cast (may lose data)

// TRAP: byte + byte = int (promotion to int for arithmetic)
byte a = 10, c = 20;
byte result = a + c;        // COMPILE ERROR! a + c is int
byte result = (byte)(a + c); // OK

public class VariableDemo {
    static int classCount = 0;       // static: one per class, lives in Metaspace
    private String name;             // instance: one per object, lives on heap
    private final int id;            // instance + final: must be set in constructor

    public void process() {
        int temp = 42;               // local: lives on stack frame
        // int x; System.out.println(x); // COMPILE ERROR: local not initialized
    }
}

public class Shadow {
    int x = 10;                      // instance variable

    public void method(int x) {     // parameter shadows instance variable
        System.out.println(x);       // prints parameter value
        System.out.println(this.x);  // prints instance variable (10)

        int x = 5; // COMPILE ERROR: can't shadow local with another local
    }
}

// && : if left is false, right is NEVER evaluated
String s = null;
if (s != null && s.length() > 0) { } // safe: s.length() never called

// || : if left is true, right is NEVER evaluated
if (list.isEmpty() || list.get(0).isValid()) { } // safe if empty

// & and | : ALWAYS evaluate BOTH sides (no short-circuit)
if (s != null & s.length() > 0) { } // NullPointerException!

// XOR swap (no temp variable)
int a = 5, b = 3;
a = a ^ b;  // a=6
b = a ^ b;  // b=5
a = a ^ b;  // a=3

// Check if power of 2
boolean isPow2 = (n > 0) && ((n & (n - 1)) == 0);

// Multiply/divide by 2 (faster than * or /)
int doubled = n << 1;   // n * 2
int halved  = n >> 1;   // n / 2

// Unsigned right shift
int x = -1;             // 11111111 11111111 11111111 11111111
int y = x >>> 1;        // 01111111 11111111 11111111 11111111 = 2147483647
int z = x >> 1;         // 11111111 11111111 11111111 11111111 = -1 (sign extended)

byte b = 10;
b = b + 1;    // COMPILE ERROR: b + 1 is int
b += 1;       // OK! compound operators include implicit cast to (byte)
b++;          // OK! same implicit cast

// Traditional switch (statement, falls through)
switch (day) {
    case MONDAY:
    case FRIDAY:
        System.out.println("Working hard");
        break;  // forget this = fall-through bug
    default:
        System.out.println("Other");
}

// Java 14+ switch EXPRESSION (no fall-through, returns value)
String result = switch (day) {
    case MONDAY, FRIDAY -> "Working hard";
    case SATURDAY, SUNDAY -> "Weekend!";
    default -> {
        String computed = "Day " + day.ordinal();
        yield computed;  // yield for multi-line blocks
    }
};

// Enhanced for-each (Java 5+)
for (String item : list) { }  // can't modify list during iteration

// Labeled break/continue (useful for nested loops)
outer:
for (int i = 0; i < matrix.length; i++) {
    for (int j = 0; j < matrix[i].length; j++) {
        if (matrix[i][j] == target) {
            System.out.println("Found at [" + i + "][" + j + "]");
            break outer;  // exits BOTH loops
        }
    }
}

// do-while: always executes AT LEAST once
do {
    response = callService();
} while (response.isRetryable());

// Infinite loop: int overflow wraps around
for (int i = 0; i >= 0; i++) { }  // runs 2.1 billion times then i becomes negative

// ConcurrentModificationException
for (String s : list) {
    if (s.equals("remove")) list.remove(s);  // THROWS
}
// Fix: use Iterator.remove() or list.removeIf(s -> s.equals("remove"))

// Declaration
int[] numbers;           // preferred style
int numbers2[];          // C-style (legal but discouraged)

// Static initialization
int[] primes = {2, 3, 5, 7, 11};

// Dynamic initialization
int[] arr = new int[10]; // all zeros
String[] names = new String[5]; // all null

// Multi-dimensional
int[][] matrix = new int[3][4];    // 3 rows, 4 columns
int[][] jagged = new int[3][];     // rows of different lengths
jagged[0] = new int[2];
jagged[1] = new int[5];

import java.util.Arrays;

Arrays.sort(arr);                          // O(n log n) — DualPivotQuicksort
Arrays.binarySearch(sortedArr, key);       // O(log n) — array MUST be sorted
Arrays.fill(arr, 0);                       // fill all elements
Arrays.copyOf(arr, newLength);             // resize/copy
Arrays.equals(arr1, arr2);                 // element-by-element comparison
Arrays.deepEquals(matrix1, matrix2);       // for multi-dimensional
Arrays.stream(arr).sum();                  // stream operations

// Array covariance trap (compiles but fails at runtime)
Object[] arr = new String[3];
arr[0] = 42;  // Compiles! Throws ArrayStoreException at runtime

// ArrayList generics catch this at compile time
List<String> list = new ArrayList<>();
// list.add(42); // COMPILE ERROR — type safety