Non-Primitive Data Types

// String literals — special syntax, but still objects:
String name = "Alice";
String greeting = "Hello, " + name;   // creates a new String

// String is immutable — methods return new Strings, never modify in place:
String original = "  Hello, World!  ";
String trimmed   = original.trim();           // "Hello, World!"
String upper     = original.toUpperCase();    // "  HELLO, WORLD!  "
String replaced  = original.replace("World", "Java");
// original is unchanged — still "  Hello, World!  "

// Common String methods:
String s = "Hello, Java!";
s.length()                    // 12
s.charAt(0)                   // 'H'
s.indexOf("Java")             // 7
s.substring(7)                // "Java!"
s.substring(7, 11)            // "Java"
s.contains("Java")            // true
s.startsWith("Hello")         // true
s.endsWith("!")               // true
s.toLowerCase()               // "hello, java!"
s.toUpperCase()               // "HELLO, JAVA!"
s.trim()                      // removes leading/trailing whitespace
s.split(", ")                 // ["Hello", "Java!"]
s.replace("Java", "World")    // "Hello, World!"

// == vs .equals() — the most common String bug in Java:
String a = new String("Alice");
String b = new String("Alice");
System.out.println(a == b);        // false — different objects in memory
System.out.println(a.equals(b));   // true  — same character sequence

// String pool — literals are interned and reused:
String x = "Alice";
String y = "Alice";
System.out.println(x == y);        // true — both point to same pool entry
System.out.println(x.equals(y));   // true

// Always use .equals() for String comparison — never ==:
if (status.equals("ACTIVE")) { }          // correct
if (status.equalsIgnoreCase("active")) { } // case-insensitive comparison

// Null-safe comparison — put the known string first:
if ("ACTIVE".equals(status)) { }   // safe even if status is null

// DON'T — string concatenation in a loop creates N intermediate objects:
String result = "";
for (int i = 0; i < 10000; i++) {
    result += i;   // creates a new String object on every iteration
}

// DO — StringBuilder is mutable, builds in place:
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 10000; i++) {
    sb.append(i);
}
String result = sb.toString();   // one final String at the end

// StringBuilder methods:
StringBuilder sb2 = new StringBuilder("Hello");
sb2.append(", World");           // Hello, World
sb2.insert(5, " there");         // Hello there, World
sb2.delete(5, 11);               // Hello, World
sb2.reverse();                   // dlroW ,olleH
sb2.replace(0, 5, "Hi");         // Hi ,olleH  (after reverse — just for demo)
sb2.toString();                  // convert to String when done

// StringBuilder vs StringBuffer:
// StringBuilder — NOT thread-safe, faster — use this in single-threaded code
// StringBuffer  — thread-safe (synchronized), slower — use only when needed across threads

// Declaring and initializing arrays:
int[] numbers = new int[5];             // array of 5 ints, all initialized to 0
String[] names = new String[3];         // array of 3 Strings, all null

// Array initializer — size inferred from values:
int[] scores = {95, 87, 76, 91, 88};
String[] days = {"Mon", "Tue", "Wed", "Thu", "Fri"};

// Accessing elements — zero-indexed:
System.out.println(scores[0]);    // 95 — first element
System.out.println(scores[4]);    // 88 — last element
scores[2] = 80;                   // modify element

// Array length:
System.out.println(scores.length);  // 5 — field, not method (no parentheses)

// Out of bounds throws at runtime:
scores[5] = 100;   // throws ArrayIndexOutOfBoundsException

// Iterating:
for (int i = 0; i < scores.length; i++) {
    System.out.println(scores[i]);
}

// Enhanced for loop (for-each) — cleaner when index not needed:
for (int score : scores) {
    System.out.println(score);
}

// 2D arrays:
int[][] matrix = new int[3][3];
int[][] grid = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
System.out.println(grid[1][2]);  // 6 — row 1, column 2

// Arrays utility class:
import java.util.Arrays;
Arrays.sort(scores);                        // sort in place
Arrays.fill(numbers, 0);                   // fill all with 0
int[] copy = Arrays.copyOf(scores, 3);     // copy first 3 elements
int[] range = Arrays.copyOfRange(scores, 1, 4);  // copy index 1 to 3
System.out.println(Arrays.toString(scores)); // "[76, 87, 88, 91, 95]"
System.out.println(Arrays.equals(scores, copy)); // compare contents

// Defining a class:
public class BankAccount {

    // Fields — data the object holds:
    private String accountNumber;
    private String owner;
    private double balance;

    // Constructor — called when creating an object with new:
    public BankAccount(String accountNumber, String owner, double initialBalance) {
        this.accountNumber = accountNumber;
        this.owner = owner;
        this.balance = initialBalance;
    }

    // Methods — behavior the object has:
    public void deposit(double amount) {
        if (amount <= 0) throw new IllegalArgumentException("Amount must be positive");
        this.balance += amount;
    }

    public void withdraw(double amount) {
        if (amount > balance) throw new IllegalStateException("Insufficient funds");
        this.balance -= amount;
    }

    public double getBalance() { return balance; }

    @Override
    public String toString() {
        return "BankAccount[" + accountNumber + ", owner=" + owner
             + ", balance=" + balance + "]";
    }
}

// Creating objects (instances) — each gets its own copy of the fields:
BankAccount acc1 = new BankAccount("ACC001", "Alice", 1000.0);
BankAccount acc2 = new BankAccount("ACC002", "Bob", 500.0);

acc1.deposit(250.0);
acc1.withdraw(100.0);
System.out.println(acc1.getBalance());   // 1150.0
System.out.println(acc1);               // BankAccount[ACC001, owner=Alice, balance=1150.0]

// Reference behavior — two variables can point to the same object:
BankAccount ref1 = acc1;
BankAccount ref2 = acc1;         // both point to the SAME object
ref1.deposit(500.0);
System.out.println(ref2.getBalance()); // 1650.0 — same object was modified

// null — a reference that points to nothing:
BankAccount empty = null;
empty.deposit(100.0);   // throws NullPointerException

// Defining an interface:
public interface Drawable {
    void draw();                          // abstract — must be implemented
    default String getDescription() {    // default — optional to override
        return "A drawable shape";
    }
}

public interface Resizable {
    void resize(double factor);
}

// Implementing interfaces:
public class Circle implements Drawable, Resizable {
    private double radius;

    public Circle(double radius) { this.radius = radius; }

    @Override
    public void draw() {
        System.out.println("Drawing circle with radius " + radius);
    }

    @Override
    public void resize(double factor) {
        this.radius *= factor;
    }
}

// Interface as a type — polymorphism:
Drawable shape = new Circle(5.0);  // variable type is Drawable
shape.draw();                       // calls Circle's implementation

// Works with any class that implements Drawable:
List<Drawable> shapes = new ArrayList<>();
shapes.add(new Circle(3.0));
shapes.add(new Rectangle(4.0, 6.0));
shapes.forEach(Drawable::draw);    // each draws itself its own way

// Basic enum:
public enum Direction {
    NORTH, SOUTH, EAST, WEST
}

// Using an enum:
Direction dir = Direction.NORTH;

switch (dir) {
    case NORTH -> System.out.println("Going north");
    case SOUTH -> System.out.println("Going south");
    case EAST  -> System.out.println("Going east");
    case WEST  -> System.out.println("Going west");
}

// Enums with fields and methods — each constant can have its own data:
public enum Planet {
    MERCURY(3.303e+23, 2.4397e6),
    VENUS  (4.869e+24, 6.0518e6),
    EARTH  (5.976e+24, 6.37814e6),
    MARS   (6.421e+23, 3.3972e6);

    private final double mass;    // in kilograms
    private final double radius;  // in meters

    Planet(double mass, double radius) {
        this.mass = mass;
        this.radius = radius;
    }

    // Surface gravity in m/s²:
    public double surfaceGravity() {
        final double G = 6.67300E-11;
        return G * mass / (radius * radius);
    }
}

System.out.println(Planet.EARTH.surfaceGravity());  // 9.802...

// Built-in enum methods:
Direction.values()               // Direction[] — all constants
Direction.valueOf("NORTH")       // Direction.NORTH — from string
Direction.NORTH.name()           // "NORTH" — constant name as String
Direction.NORTH.ordinal()        // 0 — position in declaration order

// Traditional immutable class — lots of boilerplate:
public final class Point {
    private final int x;
    private final int y;

    public Point(int x, int y) { this.x = x; this.y = y; }
    public int x() { return x; }
    public int y() { return y; }

    @Override public boolean equals(Object o) { ... }
    @Override public int hashCode() { ... }
    @Override public String toString() { ... }
}

// The same thing as a record — one line:
public record Point(int x, int y) { }

// Using a record:
Point p1 = new Point(3, 4);
Point p2 = new Point(3, 4);

System.out.println(p1.x());          // 3 — accessor method (not getX)
System.out.println(p1.y());          // 4
System.out.println(p1);              // Point[x=3, y=4] — auto toString
System.out.println(p1.equals(p2));   // true — auto equals compares values

// Records are immutable — no setters, fields are final:
// p1.x = 10;   // COMPILE ERROR — no setter, field is final

// Records can have custom methods:
public record Circle(double centerX, double centerY, double radius) {
    // Compact constructor — add validation:
    Circle {
        if (radius <= 0) throw new IllegalArgumentException("Radius must be positive");
    }

    // Custom method:
    public double area() {
        return Math.PI * radius * radius;
    }
}

Circle c = new Circle(0, 0, 5.0);
System.out.println(c.area());   // 78.539...

// The eight wrapper classes:
// byte    → Byte
// short   → Short
// int     → Integer
// long    → Long
// float   → Float
// double  → Double
// char    → Character
// boolean → Boolean

// Autoboxing — Java automatically converts primitive to wrapper:
Integer boxed = 42;           // same as: Integer.valueOf(42)
Double price = 19.99;         // same as: Double.valueOf(19.99)

// Unboxing — wrapper automatically converts back to primitive:
int value = boxed;            // same as: boxed.intValue()
double d = price;             // same as: price.doubleValue()

// Required for generics — List<int> is illegal, List<Integer> is correct:
List<Integer> numbers = new ArrayList<>();
numbers.add(1);               // autoboxed: Integer.valueOf(1)
numbers.add(2);
int first = numbers.get(0);   // unboxed: .intValue()

// Wrapper utility methods:
Integer.parseInt("42")         // String → int
Integer.toString(42)           // int → String
Integer.MAX_VALUE              // 2147483647
Integer.MIN_VALUE              // -2147483648
Integer.toBinaryString(255)    // "11111111"
Integer.toHexString(255)       // "ff"
Double.parseDouble("3.14")     // String → double
Boolean.parseBoolean("true")   // String → boolean

// Autoboxing pitfall — == compares references, not values:
Integer a = 1000;
Integer b = 1000;
System.out.println(a == b);      // false — different objects
System.out.println(a.equals(b)); // true  — same value

// Integer cache — values -128 to 127 are cached, == works "by accident":
Integer x = 127;
Integer y = 127;
System.out.println(x == y);   // true — cached, same object
Integer p = 128;
Integer q = 128;
System.out.println(p == q);   // false — outside cache range, different objects
// Moral: always use .equals() for wrapper comparison, never ==

// null is the default for uninitialized reference fields:
String name;          // null (field)
String[] arr;         // null (field)
BankAccount account;  // null (field)

// Dereferencing null throws NullPointerException:
String s = null;
s.length();          // throws NullPointerException

// Null checks — the traditional approach:
if (name != null) {
    System.out.println(name.length());
}

// Optional — the modern approach (Java 8+):
// Wrap values that might be absent in Optional instead of returning null:
Optional<String> maybeName = Optional.ofNullable(getName());

// Use safely:
maybeName.ifPresent(n -> System.out.println(n.length()));
String result = maybeName.orElse("Unknown");
String upper = maybeName.map(String::toUpperCase).orElse("UNKNOWN");

// Helpful NullPointerExceptions (Java 14+):
// Before Java 14: NullPointerException (no details)
// Java 14+: Cannot invoke "String.length()" because "name" is null
// Much easier to diagnose which variable was null

// Objects utility for null-safe operations:
import java.util.Objects;
Objects.requireNonNull(name, "name must not be null");  // throws with message if null
Objects.isNull(name)      // true if null
Objects.nonNull(name)     // true if not null
String safe = Objects.toString(name, "default");  // returns "default" if null