Unit I: Core Java Fundamentals & Multithreading

Java is an object-oriented, class-based, concurrent, secured, and general-purpose programming language developed by James Gosling at Sun Microsystems in 1991 (initially named Oak, renamed to Java in 1995, and acquired by Oracle Corporation in 2010).

The relationship between the three core Java platform components is hierarchical: JDK $\supset$ JRE $\supset$ JVM.

In Java, program execution begins unconditionally with this exact method signature:

public static void main(String[] args) {
    System.out.println("Hello, Kanpur!");
}

Java is a strictly typed language with two categories of data types:

Bitwise operators manipulate individual binary bits of integer data types (byte, short, int, long):

1. Arrays in Java

An array is an object containing a fixed number of elements of the same type. Array indices start at $0$. If an invalid index is accessed, JVM throws ArrayIndexOutOfBoundsException.

// Declaration and initialization
int[] marks = new int[5]; // Allocated in heap memory with default values (0)
int[] grades = {90, 85, 78, 92, 88};
System.out.println("First element: " + grades[0] + " | Length: " + grades.length);

2. String Immutability & Methods

In Java, String objects are immutable (their contents cannot be modified once created in the String Constant Pool inside heap memory). Any modification creates a brand new String object.

3. Vector Class (Dynamic Array)

java.util.Vector implements a growable, dynamic array of objects. Key characteristics:

• Unlike standard arrays, a Vector can dynamically expand when elements exceed current capacity (default doubles in size).
• Thread-Safe (Synchronized): All methods in Vector are synchronized, making it safe for multithreaded applications (though slightly slower than ArrayList).
• Methods: add(e), addElement(e), get(i), remove(i), size(), capacity().

1. Encapsulation (Data Hiding)

Encapsulation is the mechanism of wrapping data (variables) and code (methods) together into a single unit (class) while keeping fields private and providing controlled access via public getters and setters.

class Account {
    private double balance; // Data hidden from external modification

    public void deposit(double amount) {
        if (amount > 0) this.balance += amount; // Business logic validation
    }
    public double getBalance() {
        return this.balance;
    }
}

2. Inheritance (Code Reusability)

Inheritance allows a subclass to inherit non-private fields and methods from a superclass using the extends keyword.

• Types supported via classes: Single, Multilevel, and Hierarchical.
• Why Multiple Inheritance is NOT supported via classes: Prevents the "Diamond Problem" where a child class inherits two different implementations of the same method from two parent classes. Java achieves multiple inheritance safely via Interfaces!
• super keyword: Used to call superclass constructors (super()) or invoke overridden superclass methods (super.method()).

3. Polymorphism: Compile-Time vs. Runtime

4. Abstraction: Abstract Classes vs. Interfaces

A Package is a namespace that groups related classes, interfaces, and subpackages. It prevents class name collisions, controls access, and facilitates search and maintenance. java.lang is imported automatically into every Java file.

// File 1: mypack/Calculator.java
package mypack;

public class Calculator {
    public int multiply(int a, int b) {
        return a * b;
    }
}

// File 2: TestPack.java (in parent folder)
import mypack.Calculator;

public class TestPack {
    public static void main(String[] args) {
        Calculator calc = new Calculator();
        System.out.println("Result: " + calc.multiply(6, 7)); // Outputs 42
    }
}

An Exception is an abnormal event that disrupts the normal flow of program instructions during runtime. Java's exception architecture derives from java.lang.Throwable:

A Thread is the smallest independent unit of execution within a process. Multithreading allows concurrent execution of two or more parts of a program for maximum CPU utilization.

class BankAccount {
    private int balance = 1000;

    // Only ONE thread can execute this method at any instant
    public synchronized void withdraw(int amount) {
        if (balance >= amount) {
            balance -= amount;
        }
    }
}

// Complete Working Producer-Consumer Queue in Java:
class SharedQueue {
    int item;
    boolean valueSet = false;

    synchronized void produce(int item) {
        while (valueSet) {
            try { wait(); } catch (InterruptedException e) {}
        }
        this.item = item;
        valueSet = true;
        System.out.println("Produced: " + item);
        notify(); // Notify consumer
    }

    synchronized int consume() {
        while (!valueSet) {
            try { wait(); } catch (InterruptedException e) {}
        }
        valueSet = false;
        System.out.println("Consumed: " + item);
        notify(); // Notify producer
        return item;
    }
}

Verify your conceptual mastery across Core Java, OOP pillars, packages, exception handling, and threads with this 10-question quiz.