Unit I: Java Fundamentals

// This is your first Java program
public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
        
        // Print numbers
        System.out.println(42);
        
        // Perform calculations
        System.out.println(10 + 20);
    }
}

public class VariablesDemo {
    public static void main(String[] args) {
        // Declaring and initializing variables
        int age = 25;
        double salary = 50000.50;
        String name = "John Doe";
        boolean isEmployed = true;
        
        // Printing variables
        System.out.println("Name: " + name);
        System.out.println("Age: " + age);
        System.out.println("Salary: $" + salary);
        System.out.println("Employed: " + isEmployed);
        
        // Performing operations
        int yearsToRetirement = 60 - age;
        System.out.println("Years to retirement: " + yearsToRetirement);
    }
}

import java.util.Scanner;

public class UserInputDemo {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        // Reading user input
        System.out.print("Enter your name: ");
        String name = scanner.nextLine();
        
        System.out.print("Enter your age: ");
        int age = scanner.nextInt();
        
        // Processing and displaying
        System.out.println("\\nWelcome, " + name + "!");
        System.out.println("You are " + age + " years old.");
        
        if (age >= 18) {
            System.out.println("You are an adult.");
        } else {
            System.out.println("You are a minor.");
        }
        
        scanner.close();
    }
}

# Compile Java source file
javac HelloWorld.java

# Run the compiled program
java HelloWorld

# Output: Hello, World!

public class Example {
    static int count = 0;  // Stored in Method Area
    
    public static void main(String[] args) {  // Stack frame created
        int x = 10;  // x stored in Stack
        Example obj = new Example();  // obj reference in Stack, object in Heap
        obj.display(x);
    }
    
    void display(int num) {  // New stack frame created
        System.out.println("Number: " + num);
        // Stack frame destroyed after method completes
    }
}

# Step 1: Create Java source file
# Write your code in HelloWorld.java

# Step 2: Compile Java source file
javac HelloWorld.java
# Creates HelloWorld.class (bytecode file)

# Step 3: View bytecode (optional)
javap -c HelloWorld
# Shows the bytecode instructions

# Step 4: Run the compiled program
java HelloWorld
# JVM loads, verifies, and executes bytecode
# Output: Hello, World!

# The .class file can run on any platform with JVM
# Windows, Linux, Mac - all use the same .class file!

// 1. Package declaration (optional, must be first)
package com.example.myapp;

// 2. Import statements (optional)
import java.util.Scanner;
import java.util.ArrayList;

// 3. Class declaration
public class SourceFileStructure {
    // Fields (instance variables)
    private String name;
    private int age;
    
    // Constructor
    public SourceFileStructure(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    // Methods
    public void display() {
        System.out.println("Name: " + name);
        System.out.println("Age: " + age);
    }
    
    // Main method - entry point
    public static void main(String[] args) {
        SourceFileStructure obj = new SourceFileStructure("John", 25);
        obj.display();
    }
}

public class DataTypesDemo {
    public static void main(String[] args) {
        // Integer types
        byte b = 100;
        short s = 10000;
        int i = 100000;
        long l = 10000000000L;  // Note: L suffix for long
        
        // Floating-point types
        float f = 3.14f;      // Note: f suffix for float
        double d = 3.14159265359;
        
        // Character type
        char c = 'A';
        char unicode = '\u0041';  // Also 'A'
        
        // Boolean type
        boolean isJavaFun = true;
        
        // Reference type (String is a class)
        String name = "Java";
        
        System.out.println("byte: " + b);
        System.out.println("int: " + i);
        System.out.println("double: " + d);
        System.out.println("char: " + c);
        System.out.println("boolean: " + isJavaFun);
    }
}

public class TypeCasting {
    public static void main(String[] args) {
        // Widening (Implicit) - automatic
        int intVal = 100;
        double doubleVal = intVal;  // int to double
        System.out.println("Widening: " + doubleVal);  // 100.0
        
        // Narrowing (Explicit) - requires cast
        double d = 9.78;
        int i = (int) d;  // double to int (truncates)
        System.out.println("Narrowing: " + i);  // 9
        
        // String to int
        String str = "123";
        int num = Integer.parseInt(str);
        
        // int to String
        int value = 456;
        String s = String.valueOf(value);
    }
}

public class LogicalOperators {
    public static void main(String[] args) {
        boolean a = true;
        boolean b = false;
        
        // AND - both must be true
        System.out.println("a && b: " + (a && b));  // false
        
        // OR - at least one must be true
        System.out.println("a || b: " + (a || b));  // true
        
        // NOT - reverses the value
        System.out.println("!a: " + !a);  // false
        
        // Practical example
        int age = 25;
        boolean hasLicense = true;
        boolean canDrive = (age >= 18) && hasLicense;
        System.out.println("Can drive: " + canDrive);  // true
    }
}

int x = 10;
x += 5;   // x = x + 5;  x = 15
x -= 3;   // x = x - 3;  x = 12
x *= 2;   // x = x * 2;  x = 24
x /= 4;   // x = x / 4;  x = 6
x %= 4;   // x = x % 4;  x = 2

int a = 5;

// Pre-increment: increment first, then use
System.out.println(++a);  // Output: 6

// Post-increment: use first, then increment
a = 5;
System.out.println(a++);  // Output: 5
System.out.println(a);    // Output: 6

// Pre-decrement and Post-decrement work similarly
int b = 10;
System.out.println(--b);  // Output: 9
System.out.println(b--);  // Output: 9
System.out.println(b);    // Output: 8

// Syntax: condition ? value_if_true : value_if_false

int age = 20;
String status = (age >= 18) ? "Adult" : "Minor";
System.out.println(status);  // Output: Adult

// Finding maximum
int a = 10, b = 20;
int max = (a > b) ? a : b;
System.out.println("Max: " + max);  // Output: Max: 20

public class BitwiseDemo {
    public static void main(String[] args) {
        int a = 5;   // Binary: 0101
        int b = 3;   // Binary: 0011
        
        System.out.println("a & b: " + (a & b));   // 1 (0001)
        System.out.println("a | b: " + (a | b));   // 7 (0111)
        System.out.println("a ^ b: " + (a ^ b));   // 6 (0110)
        System.out.println("~a: " + (~a));         // -6 (inverts all bits)
        
        // Shift operators
        System.out.println("a << 1: " + (a << 1));  // 10 (multiply by 2)
        System.out.println("a >> 1: " + (a >> 1));  // 2 (divide by 2)
    }
}

public class InstanceOfDemo {
    public static void main(String[] args) {
        String str = "Hello";
        Integer num = 100;
        Object obj = "Test";
        
        // Check object types
        System.out.println(str instanceof String);    // true
        System.out.println(num instanceof Integer);   // true
        System.out.println(obj instanceof String);    // true
        System.out.println(str instanceof Object);    // true (String is subclass of Object)
    }
}

public class OperatorPrecedence {
    public static void main(String[] args) {
        // Understanding precedence
        int result1 = 10 + 5 * 2;
        System.out.println(result1);  // 20, not 30 (* has higher precedence)
        
        // Using parentheses to change order
        int result2 = (10 + 5) * 2;
        System.out.println(result2);  // 30
        
        // Complex expression
        int a = 5, b = 10, c = 15;
        int result3 = a + b * c / 3 - 2;
        System.out.println(result3);  // 5 + (10*15/3) - 2 = 5 + 50 - 2 = 53
        
        // Combining logical operators
        boolean flag = (a < b) && (b < c) || (a > c);
        System.out.println(flag);  // true
    }
}

public class ShortCircuit {
    public static void main(String[] args) {
        int x = 5;
        
        // && stops if first condition is false
        if (x < 3 && ++x > 4) {
            System.out.println("True");
        }
        System.out.println("x = " + x);  // x = 5 (++x was not executed)
        
        // || stops if first condition is true
        if (x > 3 || ++x > 6) {
            System.out.println("True");
        }
        System.out.println("x = " + x);  // x = 5 (++x was not executed)
    }
}

public class IfElseDemo {
    public static void main(String[] args) {
        int age = 20;
        
        // Simple if
        if (age >= 18) {
            System.out.println("You are an adult");
        }
        
        // if-else
        if (age >= 18) {
            System.out.println("Can vote");
        } else {
            System.out.println("Cannot vote");
        }
        
        // if-else-if ladder
        int score = 85;
        if (score >= 90) {
            System.out.println("Grade: A");
        } else if (score >= 80) {
            System.out.println("Grade: B");
        } else if (score >= 70) {
            System.out.println("Grade: C");
        } else {
            System.out.println("Grade: F");
        }
    }
}

public class SwitchDemo {
    public static void main(String[] args) {
        int day = 3;
        
        switch (day) {
            case 1:
                System.out.println("Monday");
                break;
            case 2:
                System.out.println("Tuesday");
                break;
            case 3:
                System.out.println("Wednesday");
                break;
            case 4:
                System.out.println("Thursday");
                break;
            case 5:
                System.out.println("Friday");
                break;
            default:
                System.out.println("Weekend");
        }
        
        // Switch with String (Java 7+)
        String fruit = "Apple";
        switch (fruit) {
            case "Apple":
                System.out.println("Red fruit");
                break;
            case "Banana":
                System.out.println("Yellow fruit");
                break;
            default:
                System.out.println("Unknown fruit");
        }
    }
}

public class ForLoopDemo {
    public static void main(String[] args) {
        // Basic for loop
        for (int i = 1; i <= 5; i++) {
            System.out.println("Count: " + i);
        }
        
        // Enhanced for loop (for-each)
        int[] numbers = {10, 20, 30, 40, 50};
        for (int num : numbers) {
            System.out.println("Number: " + num);
        }
        
        // Nested for loop
        for (int i = 1; i <= 3; i++) {
            for (int j = 1; j <= 3; j++) {
                System.out.print(i * j + " ");
            }
            System.out.println();
        }
    }
}

public class WhileLoopDemo {
    public static void main(String[] args) {
        // while loop
        int count = 1;
        while (count <= 5) {
            System.out.println("Count: " + count);
            count++;
        }
        
        // do-while loop (executes at least once)
        int num = 1;
        do {
            System.out.println("Number: " + num);
            num++;
        } while (num <= 5);
    }
}

public class BreakContinueDemo {
    public static void main(String[] args) {
        // break - exits the loop
        for (int i = 1; i <= 10; i++) {
            if (i == 5) {
                break;  // Exits loop when i is 5
            }
            System.out.println(i);  // Prints 1, 2, 3, 4
        }
        
        // continue - skips current iteration
        for (int i = 1; i <= 5; i++) {
            if (i == 3) {
                continue;  // Skips when i is 3
            }
            System.out.println(i);  // Prints 1, 2, 4, 5
        }
    }
}

public class ArrayDemo {
    public static void main(String[] args) {
        // Declaration and initialization
        int[] numbers = new int[5];  // Array of 5 integers
        
        // Assigning values
        numbers[0] = 10;
        numbers[1] = 20;
        numbers[2] = 30;
        numbers[3] = 40;
        numbers[4] = 50;
        
        // Declaration with values (array literal)
        int[] scores = {85, 90, 78, 92, 88};
        
        // String array
        String[] fruits = {"Apple", "Banana", "Cherry"};
        
        // Accessing elements
        System.out.println("First fruit: " + fruits[0]);
        System.out.println("Array length: " + fruits.length);
        
        // Iterating with for loop
        for (int i = 0; i < scores.length; i++) {
            System.out.println("Score " + i + ": " + scores[i]);
        }
        
        // Iterating with enhanced for loop
        for (String fruit : fruits) {
            System.out.println(fruit);
        }
    }
}

public class MultiDimensionalArray {
    public static void main(String[] args) {
        // 2D array declaration
        int[][] matrix = new int[3][3];
        
        // 2D array with values
        int[][] grid = {
            {1, 2, 3},
            {4, 5, 6},
            {7, 8, 9}
        };
        
        // Accessing elements
        System.out.println("Element at [1][2]: " + grid[1][2]);  // 6
        
        // Iterating 2D array
        for (int i = 0; i < grid.length; i++) {
            for (int j = 0; j < grid[i].length; j++) {
                System.out.print(grid[i][j] + " ");
            }
            System.out.println();
        }
        
        // Jagged array (rows with different lengths)
        int[][] jagged = new int[3][];
        jagged[0] = new int[2];
        jagged[1] = new int[4];
        jagged[2] = new int[3];
    }
}

public class StringDemo {
    public static void main(String[] args) {
        // String literal (stored in String Pool)
        String s1 = "Hello";
        
        // Using new keyword (creates new object in heap)
        String s2 = new String("Hello");
        
        // Concatenation
        String fullName = "John" + " " + "Doe";
        
        // String length
        System.out.println("Length: " + s1.length());  // 5
        
        // Comparison
        System.out.println(s1 == s2);           // false (different objects)
        System.out.println(s1.equals(s2));      // true (same content)
        System.out.println(s1.equalsIgnoreCase("HELLO"));  // true
    }
}

public class StringMethods {
    public static void main(String[] args) {
        String str = "Hello World";
        
        // Character access
        char ch = str.charAt(0);  // 'H'
        
        // Substring
        String sub = str.substring(0, 5);  // "Hello"
        
        // Case conversion
        String upper = str.toUpperCase();  // "HELLO WORLD"
        String lower = str.toLowerCase();  // "hello world"
        
        // Trim whitespace
        String padded = "  Java  ";
        String trimmed = padded.trim();  // "Java"
        
        // Replace
        String replaced = str.replace('l', 'x');  // "Hexxo Worxd"
        
        // Split
        String csv = "apple,banana,cherry";
        String[] parts = csv.split(",");  // ["apple", "banana", "cherry"]
        
        // Contains and indexOf
        boolean contains = str.contains("World");  // true
        int index = str.indexOf("World");  // 6
        
        // StartsWith and EndsWith
        boolean starts = str.startsWith("Hello");  // true
        boolean ends = str.endsWith("World");  // true
        
        // isEmpty and isBlank (Java 11+)
        boolean empty = "".isEmpty();  // true
    }
}

public class StringBuilderDemo {
    public static void main(String[] args) {
        // StringBuilder - mutable, not thread-safe, faster
        StringBuilder sb = new StringBuilder();
        sb.append("Hello");
        sb.append(" ");
        sb.append("World");
        System.out.println(sb.toString());  // "Hello World"
        
        sb.insert(5, ",");  // "Hello, World"
        sb.reverse();  // "dlroW ,olleH"
        sb.delete(0, 5);  // ", olleH"
        
        // StringBuffer - mutable, thread-safe, slower
        StringBuffer buffer = new StringBuffer("Thread Safe");
    }
}

public class Student {
    // Instance variables (fields)
    private String name;
    private int age;
    private String rollNo;
    
    // Constructor
    public Student(String name, int age, String rollNo) {
        this.name = name;
        this.age = age;
        this.rollNo = rollNo;
    }
    
    // Default constructor
    public Student() {
        this.name = "Unknown";
        this.age = 0;
    }
    
    // Getter methods
    public String getName() {
        return name;
    }
    
    public int getAge() {
        return age;
    }
    
    // Setter methods
    public void setName(String name) {
        this.name = name;
    }
    
    public void setAge(int age) {
        if (age > 0) {
            this.age = age;
        }
    }
    
    // Method
    public void display() {
        System.out.println("Name: " + name + ", Age: " + age);
    }
    
    // Main method for testing
    public static void main(String[] args) {
        // Creating objects
        Student s1 = new Student("John", 20, "CS101");
        Student s2 = new Student();
        
        s1.display();
        s2.setName("Jane");
        s2.display();
    }
}

// Parent class (Superclass)
class Animal {
    protected String name;
    
    public void eat() {
        System.out.println(name + " is eating");
    }
    
    public void sleep() {
        System.out.println(name + " is sleeping");
    }
}

// Child class (Subclass)
class Dog extends Animal {
    public Dog(String name) {
        this.name = name;
    }
    
    // Additional method
    public void bark() {
        System.out.println(name + " is barking");
    }
    
    // Method overriding
    @Override
    public void eat() {
        System.out.println(name + " is eating dog food");
    }
}

public class InheritanceDemo {
    public static void main(String[] args) {
        Dog dog = new Dog("Buddy");
        dog.eat();    // Overridden method
        dog.sleep();  // Inherited method
        dog.bark();   // Own method
    }
}

class Shape {
    public void draw() {
        System.out.println("Drawing a shape");
    }
}

class Circle extends Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a circle");
    }
}

class Rectangle extends Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a rectangle");
    }
}

public class PolymorphismDemo {
    public static void main(String[] args) {
        // Runtime polymorphism
        Shape shape1 = new Circle();
        Shape shape2 = new Rectangle();
        
        shape1.draw();  // Drawing a circle
        shape2.draw();  // Drawing a rectangle
        
        // Method overloading (compile-time polymorphism)
        Calculator calc = new Calculator();
        System.out.println(calc.add(5, 3));
        System.out.println(calc.add(5.0, 3.0));
    }
}

class Calculator {
    // Method overloading
    public int add(int a, int b) {
        return a + b;
    }
    
    public double add(double a, double b) {
        return a + b;
    }
}

// Abstract class
abstract class Vehicle {
    protected String brand;
    
    public Vehicle(String brand) {
        this.brand = brand;
    }
    
    // Abstract method (no implementation)
    public abstract void start();
    
    // Concrete method
    public void stop() {
        System.out.println(brand + " stopped");
    }
}

// Interface
interface Electric {
    void charge();  // implicitly public abstract
    int VOLTAGE = 220;  // implicitly public static final
}

// Concrete class implementing abstract class and interface
class Tesla extends Vehicle implements Electric {
    public Tesla() {
        super("Tesla");
    }
    
    @Override
    public void start() {
        System.out.println("Tesla starting silently");
    }
    
    @Override
    public void charge() {
        System.out.println("Charging at " + VOLTAGE + "V");
    }
}

// Demonstrating all OOP principles

// Abstraction using abstract class
abstract class Account {
    protected String accountNumber;
    protected String holderName;
    protected double balance;
    
    public Account(String accountNumber, String holderName, double initialBalance) {
        this.accountNumber = accountNumber;
        this.holderName = holderName;
        this.balance = initialBalance;
    }
    
    // Abstract method (must be implemented by subclasses)
    public abstract void calculateInterest();
    
    // Concrete method
    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
            System.out.println("Deposited: $" + amount);
        }
    }
    
    public void withdraw(double amount) {
        if (amount > 0 && amount <= balance) {
            balance -= amount;
            System.out.println("Withdrawn: $" + amount);
        } else {
            System.out.println("Insufficient balance");
        }
    }
    
    public double getBalance() {
        return balance;
    }
}

// Inheritance and Polymorphism
class SavingsAccount extends Account {
    private double interestRate;
    
    public SavingsAccount(String accountNumber, String holderName, double balance, double interestRate) {
        super(accountNumber, holderName, balance);
        this.interestRate = interestRate;
    }
    
    @Override
    public void calculateInterest() {
        double interest = balance * interestRate / 100;
        balance += interest;
        System.out.println("Interest added: $" + interest);
    }
}

class CurrentAccount extends Account {
    private double overdraftLimit;
    
    public CurrentAccount(String accountNumber, String holderName, double balance, double overdraftLimit) {
        super(accountNumber, holderName, balance);
        this.overdraftLimit = overdraftLimit;
    }
    
    @Override
    public void withdraw(double amount) {
        if (amount > 0 && amount <= (balance + overdraftLimit)) {
            balance -= amount;
            System.out.println("Withdrawn: $" + amount);
        } else {
            System.out.println("Exceeds overdraft limit");
        }
    }
    
    @Override
    public void calculateInterest() {
        // No interest for current accounts
        System.out.println("No interest for current accounts");
    }
}

public class BankAccountSystem {
    public static void main(String[] args) {
        // Polymorphism: Parent reference to child object
        Account savings = new SavingsAccount("SAV001", "John Doe", 1000, 5.0);
        Account current = new CurrentAccount("CUR001", "Jane Smith", 500, 200);
        
        // Demonstrating polymorphism
        savings.deposit(500);
        savings.calculateInterest();
        System.out.println("Savings Balance: $" + savings.getBalance());
        
        current.withdraw(600);  // Uses overdraft
        System.out.println("Current Balance: $" + current.getBalance());
    }
}

class Calculator {
    // Method Overloading (Compile-time Polymorphism)
    public int add(int a, int b) {
        return a + b;
    }
    
    public int add(int a, int b, int c) {
        return a + b + c;
    }
    
    public double add(double a, double b) {
        return a + b;
    }
}

class Shape {
    public void draw() {
        System.out.println("Drawing a shape");
    }
}

class Circle extends Shape {
    // Method Overriding (Runtime Polymorphism)
    @Override
    public void draw() {
        System.out.println("Drawing a circle");
    }
}

class Rectangle extends Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a rectangle");
    }
}

public class PolymorphismDemo {
    public static void main(String[] args) {
        // Overloading example
        Calculator calc = new Calculator();
        System.out.println(calc.add(5, 3));           // 8
        System.out.println(calc.add(5, 3, 2));        // 10
        System.out.println(calc.add(5.5, 3.2));      // 8.7
        
        // Overriding example (Runtime Polymorphism)
        Shape shape1 = new Circle();
        Shape shape2 = new Rectangle();
        
        shape1.draw();  // Drawing a circle
        shape2.draw();  // Drawing a rectangle
    }
}

class Parent {
    int value = 100;
    
    public Parent() {
        System.out.println("Parent constructor");
    }
    
    public void display() {
        System.out.println("Parent display: " + value);
    }
}

class Child extends Parent {
    int value = 200;
    
    public Child() {
        super();  // Calls parent constructor
        System.out.println("Child constructor");
    }
    
    public void display() {
        System.out.println("Child value: " + this.value);      // 200
        System.out.println("Parent value: " + super.value);   // 100
        super.display();  // Calls parent method
    }
}

public class ThisSuperDemo {
    public static void main(String[] args) {
        Child child = new Child();
        child.display();
    }
}

class Counter {
    // Static variable (shared by all instances)
    static int count = 0;
    
    // Instance variable (unique to each instance)
    int id;
    
    public Counter() {
        count++;  // Increment shared counter
        id = count;  // Assign unique id
    }
    
    // Static method
    public static int getCount() {
        return count;
    }
    
    // Instance method
    public void display() {
        System.out.println("Object ID: " + id + ", Total objects: " + count);
    }
}

public class StaticDemo {
    public static void main(String[] args) {
        Counter c1 = new Counter();
        Counter c2 = new Counter();
        Counter c3 = new Counter();
        
        c1.display();  // Object ID: 1, Total objects: 3
        c2.display();  // Object ID: 2, Total objects: 3
        c3.display();  // Object ID: 3, Total objects: 3
        
        System.out.println("Total created: " + Counter.getCount());  // 3
    }
}

final class FinalClass {  // Cannot be extended
    final int MAX_VALUE = 100;  // Constant (cannot be changed)
    
    final void display() {  // Cannot be overridden
        System.out.println("Final method");
    }
}

class Example {
    final int x;  // Blank final variable
    
    public Example(int x) {
        this.x = x;  // Must be initialized in constructor
    }
}

// Package declaration (must match directory structure)
package com.example.util;

public class MathHelper {
    public static int add(int a, int b) {
        return a + b;
    }
    
    public static int multiply(int a, int b) {
        return a * b;
    }
}

// Import single class
import com.example.util.MathHelper;

// Import all classes from package
import java.util.*;

// Static import - import static members
import static java.lang.Math.PI;
import static java.lang.Math.sqrt;

public class Main {
    public static void main(String[] args) {
        // Using imported class
        int sum = MathHelper.add(5, 3);
        
        // Using static imports (no class name needed)
        double area = PI * 5 * 5;
        double root = sqrt(16);
        
        // Using fully qualified name (no import needed)
        java.util.Date date = new java.util.Date();
    }
}

# Windows
set CLASSPATH=.;C:\myproject\classes;C:\libs\mylib.jar

# Linux/Mac
export CLASSPATH=.:/home/user/classes:/home/user/libs/mylib.jar

# Using -cp or -classpath option
java -cp .;lib/mylib.jar Main

# Create a JAR file
jar cf myapp.jar *.class

# Create JAR with manifest
jar cfm myapp.jar manifest.txt *.class

# View contents of JAR
jar tf myapp.jar

# Extract JAR
jar xf myapp.jar

# Run executable JAR
java -jar myapp.jar