Java Programming Notes

class Car {
    // Fields (attributes)
    String model;
    int speed;

    // Method (behavior)
    void accelerate() {
        speed += 10;
        System.out.println("Speed: " + speed);
    }
}

// Object creation
Car myCar = new Car();   // myCar is a reference variable
myCar.model = "Tesla";
myCar.accelerate();

Car anotherRef = myCar;   // both point to same object!Java

Car c = new Car();  // Object created on heap
c = null;             // Object now eligible for GC

// Requesting GC (not guaranteed)
System.gc();
Runtime.getRuntime().gc();Java

A constructor is a special method called when an object is created. It has the same name as the class and no return type.

class Student {
    String name;
    int age;

    // Static initializer block — runs once when class is loaded
    static {
        System.out.println("Class loaded!");
    }

    // Instance initializer block — runs before every constructor
    {
        age = 18;  // default age
    }

    // Default constructor
    Student() { name = "Unknown"; }

    // Parameterized constructor
    Student(String n, int a) {
        name = n;
        age = a;
    }

    // Constructor chaining with this()
    Student(String n) {
        this(n, 18);  // calls parameterized constructor
    }
}Java

final class Constants {
    public static final double PI = 3.14159;  // constant
    private transient int tempData;           // not serialized
    private volatile boolean flag = true;     // thread-visible
}Java

class Outer {
    private int x = 10;

    // Inner class
    class Inner {
        void show() { System.out.println(x); } // accesses outer x
    }

    // Static nested class
    static class Nested {
        void display() { System.out.println("Static nested"); }
    }

    void method() {
        // Local class
        class Local { void run() {} }

        // Anonymous class implementing Runnable
        Runnable r = new Runnable() {
            public void run() { System.out.println("Running!"); }
        };
        r.run();
    }
}

// Creating inner class instance (requires outer instance)
Outer o = new Outer();
Outer.Inner i = o.new Inner();
Outer.Nested n = new Outer.Nested();  // no outer instance neededJava

// Abstract class
abstract class Shape {
    String color;
    Shape(String c) { color = c; }

    abstract double area();          // must override
    void describe() {                 // concrete method
        System.out.println("Color: " + color);
    }
}

// Interface with default method (Java 8+)
interface Drawable {
    void draw();                      // abstract
    default void render() {          // default (Java 8+)
        System.out.println("Rendering...");
    }
    static void info() {              // static method
        System.out.println("Drawable interface");
    }
}

class Circle extends Shape implements Drawable {
    double radius;
    Circle(String c, double r) { super(c); radius = r; }
    public double area() { return Math.PI * radius * radius; }
    public void draw() { System.out.println("Drawing circle"); }
}Java

// modifier returnType methodName(params) throws Exception
public static int add(int a, int b) {
    return a + b;
}

// Varargs - variable number of arguments
public int sum(int... nums) {
    int total = 0;
    for (int n : nums) total += n;
    return total;
}Java

class Calculator {
    int    add(int a, int b)          { return a + b; }
    double add(double a, double b)  { return a + b; }
    int    add(int a, int b, int c)  { return a + b + c; }
    String add(String a, String b)  { return a + b; }
}
// Each call is resolved by the compiler based on argument typesJava

Recursion occurs when a method calls itself. Every recursive solution needs a base case (stops recursion) and a recursive case (moves toward base case).

// Factorial: n! = n × (n-1)!
int factorial(int n) {
    if (n <= 1) return 1;       // Base case
    return n * factorial(n - 1); // Recursive case
}

// Fibonacci: fib(n) = fib(n-1) + fib(n-2)
int fib(int n) {
    if (n <= 1) return n;
    return fib(n-1) + fib(n-2);
}

// Stack trace for factorial(3):
// factorial(3) → 3 × factorial(2)
//   factorial(2) → 2 × factorial(1)
//     factorial(1) → 1 (base case)
//   returns 2 × 1 = 2
// returns 3 × 2 = 6Java

class BankAccount {
    private static int totalAccounts = 0; // class-level counter
    private int balance;

    static {
        System.out.println("BankAccount class loaded");
    }

    BankAccount() { totalAccounts++; }

    public static int getTotalAccounts() {
        return totalAccounts; // OK: accessing static from static
        // return balance;   // ERROR: cannot access instance var
    }
}

// Calling static method
System.out.println(BankAccount.getTotalAccounts());Java

Called by the GC before reclaiming an object's memory. Used for cleanup (closing resources). Deprecated since Java 9 — prefer try-with-resources or Cleaner.

class Resource {
    protected void finalize() throws Throwable {
        try {
            System.out.println("Cleaning up resource...");
            // close file handles, DB connections, etc.
        } finally {
            super.finalize(); // always call super
        }
    }
}Java

class NativeDemo {
    public native void nativeMethod(); // no body!

    static {
        System.loadLibrary("nativeLib"); // load .dll/.so file
    }
}Java

class Builder {
  String name;
  Builder setName(String n) {
    this.name = n;
    return this; // method chaining
  }
}

class Person {
    String name;
    int age;

    Person(String name, int age) {
        this.name = name; // this.name = field, name = param
        this.age = age;
    }

    Person(String name) {
        this(name, 0); // constructor chaining — must be first statement
    }

    void greet(Greeter g) {
        g.greetPerson(this); // passing current object
    }
}Java

class Employee {
    private String name;
    private double salary;
    private boolean active;

    // Accessor (getter)
    public String getName() { return name; }
    public double getSalary() { return salary; }
    public boolean isActive() { return active; } // boolean: 'is'

    // Mutator (setter) with validation
    public void setName(String name) {
        if (name == null || name.isBlank())
            throw new IllegalArgumentException("Name cannot be empty");
        this.name = name;
    }

    public void setSalary(double salary) {
        if (salary < 0)
            throw new IllegalArgumentException("Salary cannot be negative");
        this.salary = salary;
    }
}

// Usage: JavaBeans convention
Employee e = new Employee();
e.setName("Alice");
System.out.println(e.getName());Java

// Shallow Copy
class Address {
    String city;
    Address(String c) { city = c; }
}

class Person implements Cloneable {
    String name;
    Address address;  // reference type

    // SHALLOW CLONE — address is NOT duplicated
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    // DEEP CLONE — address IS duplicated
    Person deepClone() {
        Person copy = new Person();
        copy.name = this.name;
        copy.address = new Address(this.address.city); // new object!
        return copy;
    }
}

Person p1 = new Person(); p1.name = "Alice"; p1.address = new Address("NY");
Person p2 = p1.deepClone();
p2.address.city = "LA";  // p1.address.city still "NY"Java

Generics enable writing type-safe code that works with any data type, catching type errors at compile time rather than runtime.

// Generic class
class Box<T> {
    private T item;
    public void set(T item) { this.item = item; }
    public T get() { return item; }
}

// Generic method
public static <T extends Comparable<T>> T max(T a, T b) {
    return a.compareTo(b) >= 0 ? a : b;
}

// Wildcards
void printList(List<?> list) { ... }               // unknown type
void addNums(List<? super Integer> l) { ... }      // lower bound
void readNums(List<? extends Number> l) { ... }    // upper bound

// Usage
Box<String> strBox = new Box<>();
strBox.set("Hello");
String s = strBox.get(); // no cast needed!Java

// Array declaration and initialization
int[] nums = new int[5];                  // default zeros
int[] primes = {2, 3, 5, 7, 11};           // array literal
String[] names = new String[]{"Alice", "Bob"};

// Accessing
System.out.println(primes[0]);              // 2
System.out.println(primes.length);          // 5

// Enhanced for-loop
for (int p : primes) System.out.print(p + " ");

// 2D Array (Matrix)
int[][] matrix = {{1,2},{3,4},{5,6}};
for (int[] row : matrix)
    for (int val : row) System.out.print(val + "\t");

// Jagged array
int[][] jagged = new int[3][];
jagged[0] = new int[2]; jagged[1] = new int[4]; jagged[2] = new int[1];Java

// Immutable String — creates new objects
String s = "Hello";
s = s + " World";    // old "Hello" object abandoned

// StringBuilder — modifies in-place
StringBuilder sb = new StringBuilder("Hello");
sb.append(" World");   // same object
sb.insert(5, ",");     // "Hello, World"
sb.delete(0, 5);      // ", World"
sb.reverse();          // "dlroW ,"
sb.replace(0, 2, "XX"); // replace range
String result = sb.toString();

// StringBuffer (thread-safe, same API as StringBuilder)
StringBuffer buf = new StringBuffer();
buf.append("safe"); // synchronized

// Tokenizing with StringTokenizer
import java.util.StringTokenizer;
StringTokenizer st = new StringTokenizer("one two three", " ");
while (st.hasMoreTokens())
    System.out.println(st.nextToken());

// Loop over characters
for (int i = 0; i < s.length(); i++)
    System.out.print(s.charAt(i));

// Collection classes for strings
List<String> list = new ArrayList<>(Arrays.asList("a", "b", "c"));Java

class Animal {
    String name;
    Animal(String name) { this.name = name; }
    void speak() { System.out.println("..."); }
    void breathe() { System.out.println("Breathing"); }
}

class Dog extends Animal {
    String breed;

    // Constructor chaining with super()
    Dog(String name, String breed) {
        super(name);         // must be first!
        this.breed = breed;
    }

    // Method overriding
    @Override
    void speak() {
        super.speak();        // call parent version
        System.out.println("Woof!");
    }
}

class GoldenRetriever extends Dog {   // Multilevel
    GoldenRetriever(String name) { super(name, "Golden"); }
}Java

// Runtime Polymorphism (dynamic dispatch)
Animal a = new Dog("Rex", "Labrador"); // upcasting (implicit)
a.speak();   // calls Dog's speak() at runtime

// Downcasting (explicit, may throw ClassCastException)
if (a instanceof Dog) {
    Dog d = (Dog) a;       // safe downcast
    System.out.println(d.breed);
}

// Implementing an interface
interface Swimmable { void swim(); }
class Duck extends Animal implements Swimmable {
    Duck(String n) { super(n); }
    public void swim() { System.out.println("Splashing!"); }
    public void speak() { System.out.println("Quack!"); }
}Java

A package is a namespace that organizes related classes and interfaces into groups — similar to folders in a file system. Packages prevent naming conflicts and control access.

// File: com/myapp/utils/MathHelper.java
package com.myapp.utils;   // must be first statement

public class MathHelper {
    public static int square(int n) { return n * n; }
    static void helper() {}   // package-private (default)
}

// File: com/myapp/Main.java
package com.myapp;

import com.myapp.utils.MathHelper;       // specific class
import com.myapp.utils.*;                 // all public classes
import static java.lang.Math.PI;         // static import

public class Main {
    public static void main(String[] args) {
        System.out.println(MathHelper.square(5)); // 25
        System.out.println(PI);               // static import usage
    }
}

// Directory structure mirrors package name:
// src/
//   com/
//     myapp/
//       Main.java
//       utils/
//         MathHelper.javaJava

An exception is an abnormal condition that disrupts normal program flow. Java separates error-handling code from regular code using a structured mechanism, making programs more robust and readable.

// Basic try-catch-finally
try {
    int[] arr = new int[3];
    arr[5] = 10;                // throws ArrayIndexOutOfBoundsException
} catch (ArrayIndexOutOfBoundsException e) {
    System.out.println("Index error: " + e.getMessage());
} catch (Exception e) {        // catch-all (more specific first!)
    e.printStackTrace();
} finally {
    System.out.println("Always runs — close resources here");
}

// Multi-catch (Java 7+)
try { ... }
catch (IOException | SQLException e) { e.printStackTrace(); }

// throw — manually throw an exception
void setAge(int age) {
    if (age < 0) throw new IllegalArgumentException("Age cannot be negative");
    this.age = age;
}

// throws — declare checked exceptions in method signature
void readFile(String path) throws IOException {
    new FileReader(path);     // checked exception
}

// try-with-resources (Java 7+) — auto-closes resources
try (FileReader fr = new FileReader("file.txt")) {
    // fr.close() is called automatically
}

// User-defined exception
class InsufficientFundsException extends Exception {
    double amount;
    InsufficientFundsException(double amt) {
        super("Insufficient funds: " + amt);
        amount = amt;
    }
}Java

A thread is the smallest unit of execution within a process. Java supports multithreading natively, enabling concurrent tasks to run within a single program.

// Method 1: Extending Thread class
class MyThread extends Thread {
    public void run() { System.out.println("Thread running: " + getName()); }
}

// Method 2: Implementing Runnable (preferred)
class Task implements Runnable {
    public void run() { System.out.println("Task running"); }
}

// Creating and starting threads
Thread t1 = new MyThread();
Thread t2 = new Thread(new Task());
Thread t3 = new Thread(() -> System.out.println("Lambda thread"));

t1.setPriority(Thread.MAX_PRIORITY); // priority 10
t1.start(); t2.start(); t3.start();

t1.join(); // wait for t1 to complete before continuing
Thread.sleep(1000); // pause current thread 1 secondJava

class Counter {
    private int count = 0;

    // Synchronized method — only one thread at a time
    public synchronized void increment() { count++; }

    // Synchronized block — finer control
    public void add(int n) {
        synchronized (this) { count += n; }
    }

    public int getCount() { return count; }
}

// Inter-thread communication (Producer-Consumer pattern)
class SharedBuffer {
    private int data; private boolean ready = false;

    public synchronized void produce(int v) throws InterruptedException {
        while (ready) wait();   // release lock, wait
        data = v; ready = true;
        notifyAll();              // wake waiting threads
    }

    public synchronized int consume() throws InterruptedException {
        while (!ready) wait();
        ready = false;
        notifyAll();
        return data;
    }
}Java

// Deadlock scenario
Object lockA = new Object(), lockB = new Object();

Thread t1 = new Thread(() -> {
    synchronized (lockA) {
        synchronized (lockB) { System.out.println("T1 done"); }
    }
});

Thread t2 = new Thread(() -> {
    synchronized (lockB) {   // DEADLOCK: opposite lock order!
        synchronized (lockA) { System.out.println("T2 done"); }
    }
});
// Fix: both threads acquire lockA THEN lockBJava

A stream is a sequence of data flowing from a source to a destination. Java I/O is built around two stream hierarchies:

import java.io.*;
import java.nio.file.*;
import java.nio.channels.*;

// Working with File object
File f = new File("data.txt");
System.out.println(f.exists());      // true/false
System.out.println(f.length());     // bytes
System.out.println(f.getName());    // "data.txt"
f.createNewFile();                   // create if not exists
f.delete();                          // delete file

// Writing to a file (BufferedWriter)
try (BufferedWriter bw = new BufferedWriter(new FileWriter("out.txt"))) {
    bw.write("Hello, File!");
    bw.newLine();
    bw.write("Second line");
}

// Reading from a file (BufferedReader)
try (BufferedReader br = new BufferedReader(new FileReader("out.txt"))) {
    String line;
    while ((line = br.readLine()) != null)
        System.out.println(line);
}

// PrintWriter for formatted output
try (PrintWriter pw = new PrintWriter(new FileWriter("log.txt", true))) {
    pw.printf("Value: %d%n", 42); // append mode
}Java

// NIO FileChannel Read/Write with Buffer
try (FileChannel fc = FileChannel.open(Paths.get("data.bin"),
        StandardOpenOption.READ, StandardOpenOption.WRITE, StandardOpenOption.CREATE)) {

    // Write
    ByteBuffer wBuf = ByteBuffer.allocate(64);
    wBuf.put("NIO Channel Write".getBytes());
    wBuf.flip();       // switch to read mode
    fc.write(wBuf);

    // Read
    fc.position(0);    // rewind
    ByteBuffer rBuf = ByteBuffer.allocate(64);
    fc.read(rBuf);
    rBuf.flip();
    System.out.println(new String(rBuf.array(), 0, rBuf.limit()));
}Java

import java.io.*;

class Student implements Serializable {
    private static final long serialVersionUID = 1L;
    String name;
    int roll;
    transient String password;  // NOT serialized
}

// Serialize (write object to file)
try (ObjectOutputStream oos = new ObjectOutputStream(
        new FileOutputStream("student.ser"))) {
    Student s = new Student(); s.name = "Alice"; s.roll = 101;
    oos.writeObject(s);
}

// Deserialize (read object from file)
try (ObjectInputStream ois = new ObjectInputStream(
        new FileInputStream("student.ser"))) {
    Student s = (Student) ois.readObject();
    System.out.println(s.name + " " + s.roll);
    System.out.println(s.password); // null — was transient
}Java