☕ Java Programming

// java.lang is auto-imported - no import needed! // String class String name = "Ankush"; int length = name.length(); // Math class double result = Math.sqrt(25); // 5.0 int maximum = Math.max(10, 20); // 20 // System class System.out.println("Hello World"); // Wrapper classes Integer num = Integer.parseInt("123"); Double decimal = Double.parseDouble("45.67"); // Object class (parent of all classes) Object obj = new String("test"); Output: Hello World

import java.util.*; // ArrayList - dynamic array ArrayList fruits = new ArrayList<>(); fruits.add("Apple"); fruits.add("Banana"); fruits.add("Orange"); System.out.println(fruits); // [Apple, Banana, Orange] // HashMap - key-value pairs HashMap marks = new HashMap<>(); marks.put("Raj", 85); marks.put("Priya", 92); System.out.println(marks.get("Raj")); // 85 // Scanner - user input Scanner sc = new Scanner(System.in); System.out.print("Enter name: "); String name = sc.nextLine(); // Date Date today = new Date(); System.out.println(today); // Random Random rand = new Random(); int randomNum = rand.nextInt(100); // 0 to 99

import java.io.*; // Reading from file try { FileReader fr = new FileReader("data.txt"); BufferedReader br = new BufferedReader(fr); String line; while ((line = br.readLine()) != null) { System.out.println(line); } br.close(); } catch (IOException e) { System.out.println("Error: " + e.getMessage()); } // Writing to file try { FileWriter fw = new FileWriter("output.txt"); PrintWriter pw = new PrintWriter(fw); pw.println("Hello File!"); pw.println("Java is awesome"); pw.close(); System.out.println("File written successfully"); } catch (IOException e) { System.out.println("Error: " + e.getMessage()); }

import java.awt.*; // Creating a simple window Frame f = new Frame("My First Window"); Button b = new Button("Click Me"); Label l = new Label("Welcome!"); f.add(b); f.add(l); f.setSize(400, 300); f.setLayout(new FlowLayout()); f.setVisible(true); // Output: A window appears with a button and label

import java.math.*; // BigInteger - very large numbers BigInteger big1 = new BigInteger("123456789012345678901234567890"); BigInteger big2 = new BigInteger("987654321098765432109876543210"); BigInteger sum = big1.add(big2); BigInteger product = big1.multiply(big2); System.out.println("Sum: " + sum); System.out.println("Product: " + product); // BigDecimal - precise decimal math BigDecimal price1 = new BigDecimal("19.99"); BigDecimal price2 = new BigDecimal("5.01"); BigDecimal total = price1.add(price2); System.out.println("Total: $" + total); // $25.00 (exact!)

import java.sql.*; // Database connection and query try { // 1. Load driver (automatic in modern Java) // 2. Establish connection Connection con = DriverManager.getConnection( "jdbc:mysql://localhost:3306/college", "root", "password" ); // 3. Create statement Statement stmt = con.createStatement(); // 4. Execute query ResultSet rs = stmt.executeQuery("SELECT * FROM students"); // 5. Process results while (rs.next()) { int id = rs.getInt("id"); String name = rs.getString("name"); int marks = rs.getInt("marks"); System.out.println(id + " | " + name + " | " + marks); } // 6. Close connection con.close(); } catch (SQLException e) { System.out.println("Database Error: " + e.getMessage()); } Output: 1 | Raj | 85 2 | Priya | 92 3 | Amit | 78

// File: Student.java // Step 1: Package declaration (MUST be first) package college.students; // Step 2: Imports (if needed) import java.util.*; // Step 3: Class definition public class Student { private String name; private int rollNo; public Student(String name, int rollNo) { this.name = name; this.rollNo = rollNo; } public void display() { System.out.println("Name: " + name); System.out.println("Roll No: " + rollNo); } } // Compile command: // javac -d . Student.java // Directory structure created: // college/ // students/ // Student.class

// File: CSEStudent.java package college.students.engineering.cse; public class CSEStudent { String branch = "Computer Science"; String semester = "5th"; public void showDetails() { System.out.println("Branch: " + branch); System.out.println("Semester: " + semester); } } // Directory structure: // college/ // students/ // engineering/ // cse/ // CSEStudent.class

// Good package names: package com.company.project.module; package edu.university.department; package org.opensource.library; // Bad package names: package MyPackage; // Capital letters package com.company.class; // 'class' is keyword package 123project; // Starts with number

// Import specific class import java.util.ArrayList; import college.students.Student; public class Main { public static void main(String[] args) { ArrayList list = new ArrayList<>(); // OK Student s = new Student("Raj", 101); // OK s.display(); } } // Import all classes from package import java.util.*; public class Test { public static void main(String[] args) { ArrayList list = new ArrayList<>(); // OK HashMap map = new HashMap<>(); // OK Scanner sc = new Scanner(System.in); // OK } }

// No import needed - use full package path public class Main { public static void main(String[] args) { // Full package path java.util.ArrayList list = new java.util.ArrayList<>(); college.students.Student s = new college.students.Student("Raj", 101); } } // Solving name conflicts public class DateExample { public static void main(String[] args) { // Both packages have Date class! java.util.Date utilDate = new java.util.Date(); // Current date java.sql.Date sqlDate = new java.sql.Date(System.currentTimeMillis()); // SQL date System.out.println("Util Date: " + utilDate); System.out.println("SQL Date: " + sqlDate); } }

// Without static import public class Test1 { public static void main(String[] args) { System.out.println(Math.PI); // Need Math. System.out.println(Math.max(10, 20)); // Need Math. System.out.println(Math.sqrt(25)); // Need Math. } } // With static import import static java.lang.Math.*; // Import all static members public class Test2 { public static void main(String[] args) { System.out.println(PI); // Direct use! System.out.println(max(10, 20)); // Direct use! System.out.println(sqrt(25)); // Direct use! } } Output (both programs): 3.141592653589793 20 5.0

// Step 1: Create package class // File: Calculator.java package mypackage.utils; public class Calculator { public int add(int a, int b) { return a + b; } public int subtract(int a, int b) { return a - b; } public int multiply(int a, int b) { return a * b; } } // Compile: // javac -d . Calculator.java // Creates: mypackage/utils/Calculator.class

// Step 2: Use package in another program // File: Main.java import mypackage.utils.Calculator; public class Main { public static void main(String[] args) { Calculator calc = new Calculator(); System.out.println("10 + 5 = " + calc.add(10, 5)); System.out.println("10 - 5 = " + calc.subtract(10, 5)); System.out.println("10 * 5 = " + calc.multiply(10, 5)); } } // Compile: // javac Main.java // Run: // java Main Output: 10 + 5 = 15 10 - 5 = 5 10 * 5 = 50

// Windows: set CLASSPATH=.;C:\myproject\classes;C:\libraries\lib.jar // Linux/Mac: export CLASSPATH=.:/home/user/myproject/classes:/libs/lib.jar // In Java command: java -cp .:/path/to/classes Main // Dot (.) means current directory

import java.io.*; // FileInputStream - Read bytes from file public class ByteStreamExample { public static void main(String[] args) { try { FileInputStream fis = new FileInputStream("image.jpg"); int data; // Read byte by byte while ((data = fis.read()) != -1) { // Process byte data System.out.print(data + " "); } fis.close(); System.out.println("\nFile read successfully!"); } catch (IOException e) { System.out.println("Error: " + e.getMessage()); } } } // FileOutputStream - Write bytes to file public class ByteWriteExample { public static void main(String[] args) { try { FileOutputStream fos = new FileOutputStream("output.dat"); String data = "Hello Bytes!"; // Convert string to bytes and write fos.write(data.getBytes()); fos.close(); System.out.println("Data written successfully!"); } catch (IOException e) { System.out.println("Error: " + e.getMessage()); } } }

import java.io.*; // FileReader - Read characters from file public class CharStreamExample { public static void main(String[] args) { try { FileReader fr = new FileReader("data.txt"); int ch; // Read character by character while ((ch = fr.read()) != -1) { System.out.print((char) ch); } fr.close(); } catch (IOException e) { System.out.println("Error: " + e.getMessage()); } } } // FileWriter - Write characters to file public class CharWriteExample { public static void main(String[] args) { try { FileWriter fw = new FileWriter("output.txt"); fw.write("Hello World!\n"); fw.write("Java File I/O is easy!"); fw.close(); System.out.println("File written successfully!"); } catch (IOException e) { System.out.println("Error: " + e.getMessage()); } } }

import java.io.*; public class FileReadExample { public static void main(String[] args) { try { // Create FileReader FileReader fr = new FileReader("students.txt"); // Wrap in BufferedReader for efficiency BufferedReader br = new BufferedReader(fr); String line; int lineNumber = 1; // Read line by line while ((line = br.readLine()) != null) { System.out.println(lineNumber + ": " + line); lineNumber++; } // Close the reader br.close(); } catch (FileNotFoundException e) { System.out.println("File not found: " + e.getMessage()); } catch (IOException e) { System.out.println("Error reading file: " + e.getMessage()); } } } // If students.txt contains: // Raj // Priya // Amit Output: 1: Raj 2: Priya 3: Amit

import java.io.*; public class FileWriteExample { public static void main(String[] args) { try { // Create FileWriter FileWriter fw = new FileWriter("output.txt"); // Wrap in PrintWriter for convenience PrintWriter pw = new PrintWriter(fw); // Write data pw.println("Student Records"); pw.println("================"); pw.println("Name: Raj Kumar"); pw.println("Roll No: 101"); pw.println("Marks: 85"); pw.println(); pw.println("Name: Priya Sharma"); pw.println("Roll No: 102"); pw.println("Marks: 92"); // Close the writer pw.close(); System.out.println("Data written to output.txt successfully!"); } catch (IOException e) { System.out.println("Error writing file: " + e.getMessage()); } } } Output (in output.txt file): Student Records ================ Name: Raj Kumar Roll No: 101 Marks: 85 Name: Priya Sharma Roll No: 102 Marks: 92

import java.io.*; public class AutoCloseExample { public static void main(String[] args) { // Try-with-resources automatically closes streams try (BufferedReader br = new BufferedReader( new FileReader("data.txt"))) { String line; while ((line = br.readLine()) != null) { System.out.println(line); } // No need to call br.close() - automatic! } catch (IOException e) { System.out.println("Error: " + e.getMessage()); } } }

Object (parent of all) └── Throwable ├── Error (serious problems - NOT handled) │ ├── OutOfMemoryError │ └── StackOverflowError │ └── Exception (handled by programmers) ├── IOException (Checked) ├── SQLException (Checked) └── RuntimeException (Unchecked) ├── NullPointerException ├── ArithmeticException ├── ArrayIndexOutOfBoundsException └── NumberFormatException

String name = null; System.out.println(name.length()); // NullPointerException! // Output: Exception in thread "main" java.lang.NullPointerException // Fix: if (name != null) { System.out.println(name.length()); } else { System.out.println("Name is null"); }

int a = 10, b = 0; int result = a / b; // ArithmeticException: / by zero // Fix: if (b != 0) { int result = a / b; System.out.println("Result: " + result); } else { System.out.println("Cannot divide by zero"); }

int[] arr = {10, 20, 30}; System.out.println(arr[5]); // ArrayIndexOutOfBoundsException! // Fix: int index = 5; if (index >= 0 && index < arr.length) { System.out.println(arr[index]); } else { System.out.println("Invalid index: " + index); }

String str = "abc"; int num = Integer.parseInt(str); // NumberFormatException! // Fix: try { int num = Integer.parseInt(str); System.out.println("Number: " + num); } catch (NumberFormatException e) { System.out.println("Invalid number format: " + str); }

import java.io.*; // Must handle - compiler forces you! try { FileReader fr = new FileReader("nonexistent.txt"); } catch (FileNotFoundException e) { System.out.println("File not found: " + e.getMessage()); }

// Step 1: Create custom exception class class InvalidAgeException extends Exception { // Default constructor public InvalidAgeException() { super("Invalid age provided"); } // Parameterized constructor public InvalidAgeException(String message) { super(message); } } // Step 2: Use in program class AgeValidator { public static void checkAge(int age) throws InvalidAgeException { if (age < 18) { throw new InvalidAgeException("Age must be 18 or above. You are: " + age); } System.out.println("Age verified: " + age); } } // Step 3: Handle exception public class Main { public static void main(String[] args) { try { AgeValidator.checkAge(15); // Will throw exception } catch (InvalidAgeException e) { System.out.println("Error: " + e.getMessage()); } } } Output: Error: Age must be 18 or above. You are: 15

// Custom exception for insufficient balance class InsufficientFundsException extends Exception { private double amount; public InsufficientFundsException(double amount) { super("Insufficient funds. Need: " + amount); this.amount = amount; } public double getAmount() { return amount; } } // Bank account class class BankAccount { private double balance; public BankAccount(double balance) { this.balance = balance; } public void withdraw(double amount) throws InsufficientFundsException { if (amount > balance) { double shortage = amount - balance; throw new InsufficientFundsException(shortage); } balance -= amount; System.out.println("Withdrawal successful. New balance: " + balance); } public double getBalance() { return balance; } } // Using the custom exception public class BankDemo { public static void main(String[] args) { BankAccount account = new BankAccount(5000); try { System.out.println("Current balance: " + account.getBalance()); account.withdraw(3000); // OK account.withdraw(4000); // Will throw exception } catch (InsufficientFundsException e) { System.out.println("Transaction failed: " + e.getMessage()); System.out.println("Short by: " + e.getAmount()); } } } Output: Current balance: 5000.0 Withdrawal successful. New balance: 2000.0 Transaction failed: Insufficient funds. Need: 2000.0 Short by: 2000.0

// Checked exception (extends Exception) class InvalidEmailException extends Exception { public InvalidEmailException(String message) { super(message); } } // Unchecked exception (extends RuntimeException) class InvalidPasswordException extends RuntimeException { public InvalidPasswordException(String message) { super(message); } } // Usage difference class UserValidator { // Checked - must declare with 'throws' public static void validateEmail(String email) throws InvalidEmailException { if (!email.contains("@")) { throw new InvalidEmailException("Email must contain @"); } } // Unchecked - 'throws' optional public static void validatePassword(String password) { if (password.length() < 8) { throw new InvalidPasswordException("Password too short"); } } }

public class MultipleCatchExample { public static void main(String[] args) { try { int[] arr = {10, 20, 30}; // Can throw ArrayIndexOutOfBoundsException System.out.println(arr[5]); // Can throw ArithmeticException int result = 10 / 0; // Can throw NullPointerException String name = null; System.out.println(name.length()); } catch (ArrayIndexOutOfBoundsException e) { System.out.println("Error: Invalid array index"); System.out.println("Details: " + e.getMessage()); } catch (ArithmeticException e) { System.out.println("Error: Mathematical error"); System.out.println("Details: " + e.getMessage()); } catch (NullPointerException e) { System.out.println("Error: Null value encountered"); System.out.println("Details: " + e.getMessage()); } System.out.println("Program continues..."); } } Output: Error: Invalid array index Details: Index 5 out of bounds for length 3 Program continues...

public class MultiCatchExample { public static void main(String[] args) { try { String input = "abc"; int num = Integer.parseInt(input); // NumberFormatException int[] arr = {1, 2, 3}; System.out.println(arr[10]); // ArrayIndexOutOfBoundsException } catch (NumberFormatException | ArrayIndexOutOfBoundsException e) { // Same handling for both exceptions System.out.println("Error occurred: " + e.getClass().getSimpleName()); System.out.println("Message: " + e.getMessage()); } System.out.println("Program continues..."); } } Output: Error occurred: NumberFormatException Message: For input string: "abc" Program continues...

// CORRECT order - specific to general try { // code } catch (ArrayIndexOutOfBoundsException e) { // Specific System.out.println("Array error"); } catch (RuntimeException e) { // General (parent) System.out.println("Runtime error"); } catch (Exception e) { // Most general System.out.println("General error"); } // WRONG order - will not compile! try { // code } catch (Exception e) { // Most general first System.out.println("General error"); } catch (ArrayIndexOutOfBoundsException e) { // Unreachable! System.out.println("Array error"); // Compiler error! }

import java.io.*; public class FileReadMultipleCatch { public static void main(String[] args) { BufferedReader br = null; try { // Can throw FileNotFoundException br = new BufferedReader(new FileReader("data.txt")); // Can throw IOException String line = br.readLine(); System.out.println("First line: " + line); // Can throw NumberFormatException int number = Integer.parseInt(line); System.out.println("Number: " + number); // Can throw ArithmeticException int result = 100 / number; System.out.println("Result: " + result); } catch (FileNotFoundException e) { System.out.println("File not found: " + e.getMessage()); } catch (IOException e) { System.out.println("Error reading file: " + e.getMessage()); } catch (NumberFormatException e) { System.out.println("Invalid number format: " + e.getMessage()); } catch (ArithmeticException e) { System.out.println("Mathematical error: " + e.getMessage()); } catch (Exception e) { // Generic catch for any other exception System.out.println("Unexpected error: " + e.getMessage()); } finally { // Cleanup code (discussed in next section) try { if (br != null) { br.close(); } } catch (IOException e) { System.out.println("Error closing file"); } } } }

try { // Code that may throw exception } catch (ExceptionType e) { // Handle exception } finally { // Always executes (cleanup code) }

public class FinallyExample1 { public static void main(String[] args) { System.out.println("Start"); try { System.out.println("Inside try block"); int result = 10 / 2; // No exception System.out.println("Result: " + result); } catch (ArithmeticException e) { System.out.println("Inside catch block"); } finally { System.out.println("Inside finally block - ALWAYS executes"); } System.out.println("End"); } } Output: Start Inside try block Result: 5 Inside finally block - ALWAYS executes End

public class FinallyExample2 { public static void main(String[] args) { System.out.println("Start"); try { System.out.println("Inside try block"); int result = 10 / 0; // ArithmeticException! System.out.println("This won't execute"); } catch (ArithmeticException e) { System.out.println("Inside catch block: " + e.getMessage()); } finally { System.out.println("Inside finally block - ALWAYS executes"); } System.out.println("End"); } } Output: Start Inside try block Inside catch block: / by zero Inside finally block - ALWAYS executes End

public class FinallyWithReturn { public static int testFinally() { try { System.out.println("Inside try"); return 10; // Will return, but finally executes first! } catch (Exception e) { System.out.println("Inside catch"); return 20; } finally { System.out.println("Inside finally - executes even with return!"); } } public static void main(String[] args) { int result = testFinally(); System.out.println("Returned value: " + result); } } Output: Inside try Inside finally - executes even with return! Returned value: 10

import java.io.*; public class FinallyFileExample { public static void main(String[] args) { BufferedReader br = null; try { br = new BufferedReader(new FileReader("data.txt")); String line = br.readLine(); System.out.println("Data: " + line); // Some processing that may throw exception int num = Integer.parseInt(line); System.out.println("Number: " + num); } catch (FileNotFoundException e) { System.out.println("File not found"); } catch (IOException e) { System.out.println("Error reading file"); } catch (NumberFormatException e) { System.out.println("Invalid number"); } finally { // ALWAYS close the file - cleanup code System.out.println("Closing file..."); try { if (br != null) { br.close(); System.out.println("File closed successfully"); } } catch (IOException e) { System.out.println("Error closing file"); } } System.out.println("Program ends"); } }

// Old way with finally BufferedReader br = null; try { br = new BufferedReader(new FileReader("file.txt")); } finally { if (br != null) br.close(); } // New way - try-with-resources (preferred) try (BufferedReader br = new BufferedReader(new FileReader("file.txt"))) { // Use br - automatically closed! }

returnType methodName(parameters) throws Exception1, Exception2 { // Method body // May throw Exception1 or Exception2 }

import java.io.*; class FileProcessor { // Declares that this method can throw IOException public static void readFile(String filename) throws IOException { FileReader fr = new FileReader(filename); // May throw IOException BufferedReader br = new BufferedReader(fr); String line = br.readLine(); System.out.println("Data: " + line); br.close(); } } public class ThrowsExample1 { public static void main(String[] args) { try { // Caller must handle the declared exception FileProcessor.readFile("data.txt"); } catch (IOException e) { System.out.println("Error: " + e.getMessage()); } } }

class Calculator { // Declares multiple possible exceptions public static int divide(String num1, String num2) throws NumberFormatException, ArithmeticException { int a = Integer.parseInt(num1); // May throw NumberFormatException int b = Integer.parseInt(num2); return a / b; // May throw ArithmeticException } } public class ThrowsExample2 { public static void main(String[] args) { try { int result = Calculator.divide("10", "2"); System.out.println("Result: " + result); result = Calculator.divide("10", "0"); // Will throw } catch (NumberFormatException e) { System.out.println("Invalid number: " + e.getMessage()); } catch (ArithmeticException e) { System.out.println("Math error: " + e.getMessage()); } } } Output: Result: 5 Math error: / by zero

import java.io.*; class FileHandler { // Method 1 declares exception public static void processFile() throws IOException { readFile(); // Calling method that throws } // Method 2 declares exception public static void readFile() throws IOException { FileReader fr = new FileReader("data.txt"); // Reading code fr.close(); } } public class ThrowsChain { public static void main(String[] args) { try { // Final caller handles the exception FileHandler.processFile(); } catch (IOException e) { System.out.println("File error: " + e.getMessage()); } } }

class VoterValidator { // Declares that method can throw exception public static void checkEligibility(int age) throws Exception { if (age < 18) { // Actually throws the exception throw new Exception("Not eligible. Age: " + age); } System.out.println("Eligible to vote. Age: " + age); } } public class ThrowVsThrows { public static void main(String[] args) { try { VoterValidator.checkEligibility(20); // OK VoterValidator.checkEligibility(15); // Will throw } catch (Exception e) { System.out.println("Error: " + e.getMessage()); } } } Output: Eligible to vote. Age: 20 Error: Not eligible. Age: 15

class MyThread extends Thread { public void run() { for (int i = 1; i <= 5; i++) { System.out.println(Thread.currentThread().getName() + ": " + i); } } } public class ThreadDemo { public static void main(String[] args) { MyThread t1 = new MyThread(); MyThread t2 = new MyThread(); t1.start(); // Starts thread 1 t2.start(); // Starts thread 2 } } Output (may vary - concurrent execution): Thread-0: 1 Thread-1: 1 Thread-0: 2 Thread-1: 2 Thread-0: 3 Thread-1: 3 Thread-0: 4 Thread-1: 4 Thread-0: 5 Thread-1: 5

Thread Life Cycle Diagram: NEW | | start() ↓ RUNNABLE ←──────────────┐ | | | Scheduler picks | I/O complete, notify() ↓ | sleep() time up RUNNING | | | | sleep(), wait() | | I/O request | ↓ | BLOCKED/WAITING ─────────┘ RUNNING | | run() completes ↓ TERMINATED

// Check thread state Thread t = new Thread(); System.out.println(t.getState()); // NEW t.start(); System.out.println(t.getState()); // RUNNABLE // Thread state constants: Thread.State.NEW Thread.State.RUNNABLE Thread.State.BLOCKED Thread.State.WAITING Thread.State.TIMED_WAITING Thread.State.TERMINATED

class LifeCycleThread extends Thread { public void run() { System.out.println("State: RUNNING"); try { Thread.sleep(2000); // Goes to TIMED_WAITING System.out.println("Woke up from sleep"); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("About to terminate"); } } public class ThreadLifeCycle { public static void main(String[] args) throws InterruptedException { LifeCycleThread t = new LifeCycleThread(); System.out.println("After creation: " + t.getState()); // NEW t.start(); System.out.println("After start(): " + t.getState()); // RUNNABLE Thread.sleep(100); System.out.println("While sleeping: " + t.getState()); // TIMED_WAITING t.join(); // Wait for thread to complete System.out.println("After completion: " + t.getState()); // TERMINATED } } Output: After creation: NEW After start(): RUNNABLE State: RUNNING While sleeping: TIMED_WAITING Woke up from sleep About to terminate After completion: TERMINATED

// Step 1: Create class extending Thread class MyThread extends Thread { // Step 2: Override run() method public void run() { for (int i = 1; i <= 5; i++) { System.out.println(Thread.currentThread().getName() + ": " + i); try { Thread.sleep(500); // Pause 500ms } catch (InterruptedException e) { e.printStackTrace(); } } } } public class ThreadExample1 { public static void main(String[] args) { // Step 3: Create thread objects MyThread t1 = new MyThread(); MyThread t2 = new MyThread(); // Step 4: Start threads t1.start(); t2.start(); } } Output: Thread-0: 1 Thread-1: 1 Thread-0: 2 Thread-1: 2 ...

// Step 1: Create class implementing Runnable class MyRunnable implements Runnable { // Step 2: Implement run() method public void run() { for (int i = 1; i <= 5; i++) { System.out.println(Thread.currentThread().getName() + ": " + i); try { Thread.sleep(500); } catch (InterruptedException e) { e.printStackTrace(); } } } } public class RunnableExample { public static void main(String[] args) { // Step 3: Create Runnable objects MyRunnable r = new MyRunnable(); // Step 4: Create Thread objects with Runnable Thread t1 = new Thread(r); Thread t2 = new Thread(r); // Step 5: Start threads t1.start(); t2.start(); } }

class Counter implements Runnable { private String name; public Counter(String name) { this.name = name; } public void run() { for (int i = 1; i <= 3; i++) { System.out.println(name + ": Count " + i); try { Thread.sleep(300); } catch (InterruptedException e) { e.printStackTrace(); } } } } public class MultipleThreads { public static void main(String[] args) { // Create multiple threads Thread t1 = new Thread(new Counter("Thread-A")); Thread t2 = new Thread(new Counter("Thread-B")); Thread t3 = new Thread(new Counter("Thread-C")); // Start all threads t1.start(); t2.start(); t3.start(); } } Output (interleaved): Thread-A: Count 1 Thread-B: Count 1 Thread-C: Count 1 Thread-A: Count 2 Thread-B: Count 2 Thread-C: Count 2 Thread-A: Count 3 Thread-B: Count 3 Thread-C: Count 3

Thread.MIN_PRIORITY = 1 // Lowest priority Thread.NORM_PRIORITY = 5 // Default priority Thread.MAX_PRIORITY = 10 // Highest priority

class PriorityThread extends Thread { public void run() { System.out.println(Thread.currentThread().getName() + " - Priority: " + Thread.currentThread().getPriority()); } } public class PriorityDemo { public static void main(String[] args) { PriorityThread t1 = new PriorityThread(); PriorityThread t2 = new PriorityThread(); PriorityThread t3 = new PriorityThread(); // Set priorities t1.setPriority(Thread.MIN_PRIORITY); // 1 t2.setPriority(Thread.NORM_PRIORITY); // 5 t3.setPriority(Thread.MAX_PRIORITY); // 10 // Start threads t1.start(); t2.start(); t3.start(); } } Output: Thread-2 - Priority: 10 Thread-1 - Priority: 5 Thread-0 - Priority: 1

class Task implements Runnable { private String name; public Task(String name) { this.name = name; } public void run() { for (int i = 1; i <= 3; i++) { System.out.println(name + " (Priority: " + Thread.currentThread().getPriority() + ") - Count: " + i); } } } public class PriorityExample { public static void main(String[] args) { Thread highPriority = new Thread(new Task("HIGH"), "High-Priority"); Thread normalPriority = new Thread(new Task("NORM"), "Normal-Priority"); Thread lowPriority = new Thread(new Task("LOW"), "Low-Priority"); // Set priorities highPriority.setPriority(10); normalPriority.setPriority(5); lowPriority.setPriority(1); // Start all lowPriority.start(); normalPriority.start(); highPriority.start(); } } Output (high priority likely executes first): HIGH (Priority: 10) - Count: 1 HIGH (Priority: 10) - Count: 2 HIGH (Priority: 10) - Count: 3 NORM (Priority: 5) - Count: 1 NORM (Priority: 5) - Count: 2 NORM (Priority: 5) - Count: 3 LOW (Priority: 1) - Count: 1 LOW (Priority: 1) - Count: 2 LOW (Priority: 1) - Count: 3

class Counter { private int count = 0; public void increment() { count++; // NOT thread-safe! } public int getCount() { return count; } } class CounterThread extends Thread { private Counter counter; public CounterThread(Counter counter) { this.counter = counter; } public void run() { for (int i = 0; i < 1000; i++) { counter.increment(); } } } public class RaceConditionDemo { public static void main(String[] args) throws InterruptedException { Counter counter = new Counter(); Thread t1 = new CounterThread(counter); Thread t2 = new CounterThread(counter); t1.start(); t2.start(); t1.join(); t2.join(); System.out.println("Expected: 2000"); System.out.println("Actual: " + counter.getCount()); // May be less! } } Output (unpredictable): Expected: 2000 Actual: 1847 // WRONG! Lost updates due to race condition

class SynchronizedCounter { private int count = 0; // synchronized keyword - only one thread at a time public synchronized void increment() { count++; } public int getCount() { return count; } } class SyncThread extends Thread { private SynchronizedCounter counter; public SyncThread(SynchronizedCounter counter) { this.counter = counter; } public void run() { for (int i = 0; i < 1000; i++) { counter.increment(); } } } public class SynchronizationDemo { public static void main(String[] args) throws InterruptedException { SynchronizedCounter counter = new SynchronizedCounter(); Thread t1 = new SyncThread(counter); Thread t2 = new SyncThread(counter); t1.start(); t2.start(); t1.join(); t2.join(); System.out.println("Expected: 2000"); System.out.println("Actual: " + counter.getCount()); // Always correct! } } Output: Expected: 2000 Actual: 2000 // CORRECT! synchronized ensures thread safety

class BankAccount { private int balance = 1000; public void withdraw(int amount) { System.out.println(Thread.currentThread().getName() + " attempting withdrawal"); // Only critical section is synchronized synchronized(this) { if (balance >= amount) { System.out.println(Thread.currentThread().getName() + " proceeding with withdrawal"); balance -= amount; System.out.println(Thread.currentThread().getName() + " completed. Balance: " + balance); } else { System.out.println(Thread.currentThread().getName() + " insufficient funds"); } } } } public class SyncBlockDemo { public static void main(String[] args) { BankAccount account = new BankAccount(); Thread t1 = new Thread(() -> account.withdraw(600), "Thread-1"); Thread t2 = new Thread(() -> account.withdraw(600), "Thread-2"); t1.start(); t2.start(); } } Output: Thread-1 attempting withdrawal Thread-2 attempting withdrawal Thread-1 proceeding with withdrawal Thread-1 completed. Balance: 400 Thread-2 insufficient funds

class SharedQueue { private int data; private boolean available = false; // Producer produces data public synchronized void produce(int value) { while (available) { try { wait(); // Wait if data already available } catch (InterruptedException e) { e.printStackTrace(); } } data = value; available = true; System.out.println("Produced: " + value); notify(); // Notify consumer } // Consumer consumes data public synchronized int consume() { while (!available) { try { wait(); // Wait if no data available } catch (InterruptedException e) { e.printStackTrace(); } } available = false; System.out.println("Consumed: " + data); notify(); // Notify producer return data; } } class Producer extends Thread { private SharedQueue queue; public Producer(SharedQueue queue) { this.queue = queue; } public void run() { for (int i = 1; i <= 5; i++) { queue.produce(i); try { Thread.sleep(500); } catch (InterruptedException e) { e.printStackTrace(); } } } } class Consumer extends Thread { private SharedQueue queue; public Consumer(SharedQueue queue) { this.queue = queue; } public void run() { for (int i = 1; i <= 5; i++) { queue.consume(); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } } } public class ProducerConsumerDemo { public static void main(String[] args) { SharedQueue queue = new SharedQueue(); Producer producer = new Producer(queue); Consumer consumer = new Consumer(queue); producer.start(); consumer.start(); } } Output: Produced: 1 Consumed: 1 Produced: 2 Consumed: 2 Produced: 3 Consumed: 3 Produced: 4 Consumed: 4 Produced: 5 Consumed: 5

class ControlledThread extends Thread { private volatile boolean suspended = false; private volatile boolean stopped = false; public void run() { System.out.println("Thread started"); for (int i = 1; i <= 10 && !stopped; i++) { // Check if suspended synchronized(this) { while (suspended) { try { wait(); // Wait until resumed } catch (InterruptedException e) { e.printStackTrace(); } } } System.out.println("Count: " + i); try { Thread.sleep(500); } catch (InterruptedException e) { System.out.println("Thread interrupted"); } } System.out.println("Thread stopped"); } // Safe suspend using flag public void suspendThread() { suspended = true; } // Safe resume using notify public synchronized void resumeThread() { suspended = false; notify(); } // Safe stop using flag public void stopThread() { stopped = true; } } public class ThreadControlDemo { public static void main(String[] args) throws InterruptedException { ControlledThread thread = new ControlledThread(); thread.start(); Thread.sleep(2000); System.out.println("\n--- SUSPENDING THREAD ---"); thread.suspendThread(); Thread.sleep(2000); System.out.println("--- RESUMING THREAD ---\n"); thread.resumeThread(); Thread.sleep(2000); System.out.println("\n--- STOPPING THREAD ---"); thread.stopThread(); } } Output: Thread started Count: 1 Count: 2 Count: 3 --- SUSPENDING THREAD --- --- RESUMING THREAD --- Count: 4 Count: 5 Count: 6 --- STOPPING THREAD --- Thread stopped

class InterruptibleThread extends Thread { public void run() { try { for (int i = 1; i <= 10; i++) { if (Thread.interrupted()) { System.out.println("Thread interrupted at count: " + i); return; // Exit gracefully } System.out.println("Count: " + i); Thread.sleep(500); } } catch (InterruptedException e) { System.out.println("Thread interrupted during sleep"); } } } public class InterruptDemo { public static void main(String[] args) throws InterruptedException { InterruptibleThread thread = new InterruptibleThread(); thread.start(); Thread.sleep(2000); System.out.println("\nInterrupting thread...\n"); thread.interrupt(); // Safe way to signal stop } } Output: Count: 1 Count: 2 Count: 3 Interrupting thread... Thread interrupted during sleep