Java OOP Basics - Objects & Classes

// Book class for object demonstration
class Book {
    private String title;
    private String author;
    private double price;
    private int pages;
    
    // Constructors
    public Book() {
        this.title = "Unknown";
        this.author = "Unknown";
        this.price = 0.0;
        this.pages = 0;
    }
    
    public Book(String title, String author) {
        this.title = title;
        this.author = author;
        this.price = 0.0;
        this.pages = 0;
    }
    
    public Book(String title, String author, double price, int pages) {
        this.title = title;
        this.author = author;
        this.price = price;
        this.pages = pages;
    }
    
    // Getters and Setters
    public String getTitle() { return title; }
    public void setTitle(String title) { this.title = title; }
    
    public String getAuthor() { return author; }
    public void setAuthor(String author) { this.author = author; }
    
    public double getPrice() { return price; }
    public void setPrice(double price) { 
        if (price >= 0) this.price = price; 
    }
    
    public int getPages() { return pages; }
    public void setPages(int pages) { 
        if (pages >= 0) this.pages = pages; 
    }
    
    // Business methods
    public void applyDiscount(double percentage) {
        if (percentage > 0 && percentage <= 100) {
            price = price * (100 - percentage) / 100;
        }
    }
    
    public double getPricePerPage() {
        if (pages > 0) {
            return price / pages;
        }
        return 0;
    }
    
    @Override
    public String toString() {
        return String.format("Book: %s by %s ($%.2f, %d pages)", 
                           title, author, price, pages);
    }
}

public class ObjectCreation {
    public static void main(String[] args) {
        System.out.println("=== Different Ways to Create Objects ===\n");
        
        // Method 1: Using 'new' keyword (most common)
        Book book1 = new Book();
        book1.setTitle("Java Programming");
        book1.setAuthor("John Doe");
        book1.setPrice(49.99);
        book1.setPages(500);
        
        // Method 2: Using parameterized constructor
        Book book2 = new Book("Python Basics", "Jane Smith", 39.99, 400);
        
        // Method 3: Using constructor with partial parameters
        Book book3 = new Book("C++ Essentials", "Mike Johnson");
        book3.setPrice(44.99);
        book3.setPages(350);
        
        // Method 4: Array of objects
        Book[] library = new Book[3];
        library[0] = book1;
        library[1] = book2;
        library[2] = book3;
        
        // Method 5: Anonymous object (one-time use)
        System.out.println("Anonymous object price: $" + 
                          new Book("Quick Reference", "Author", 9.99, 100).getPrice());
        
        // Display all books
        System.out.println("\n=== Library Collection ===");
        for (Book book : library) {
            System.out.println(book);
        }
        
        // Demonstrate object behavior
        System.out.println("\n=== Object Behavior Demonstration ===");
        book1.applyDiscount(20);
        System.out.println("After 20% discount: " + book1);
        System.out.printf("Price per page: $%.4f\n", book1.getPricePerPage());
        
        // Object comparison
        System.out.println("\n=== Object Comparison ===");
        Book book4 = new Book("Java Programming", "John Doe", 49.99, 500);
        Book book5 = book1;
        
        System.out.println("book1 == book4: " + (book1 == book4));  // false (different objects)
        System.out.println("book1 == book5: " + (book1 == book5));  // true (same object)
        System.out.println("book1.equals(book4): " + book1.equals(book4));  // false (default equals())
        
        // Object null reference
        System.out.println("\n=== Null Reference Demonstration ===");
        Book nullBook = null;
        System.out.println("nullBook is: " + nullBook);
        
        // This would cause NullPointerException:
        // nullBook.getTitle();  // UNCOMMENT TO SEE ERROR
        
        // Safe way to handle null
        if (nullBook != null) {
            System.out.println("Title: " + nullBook.getTitle());
        } else {
            System.out.println("Book is null!");
        }
        
        // Garbage collection hint
        System.out.println("\n=== Memory Management ===");
        Book tempBook = new Book("Temp Book", "Temp Author", 1.99, 50);
        tempBook = null;  // Now eligible for garbage collection
        System.gc();  // Hint to JVM (not guaranteed to run immediately)
    }
}

// Bank Account example for object lifecycle
class BankAccount {
    private static int accountCounter = 1000;
    
    private final int accountNumber;  // final - can't be changed after initialization
    private String accountHolder;
    private double balance;
    private boolean isActive;
    
    // Static initialization block
    static {
        System.out.println("BankAccount class loaded. Initializing...");
    }
    
    // Instance initialization block (runs before each constructor)
    {
        System.out.println("Creating a new BankAccount object...");
        this.isActive = true;
    }
    
    // Constructors
    public BankAccount(String accountHolder) {
        this.accountNumber = ++accountCounter;  // Auto-generated
        this.accountHolder = accountHolder;
        this.balance = 0.0;
    }
    
    public BankAccount(String accountHolder, double initialBalance) {
        this.accountNumber = ++accountCounter;
        this.accountHolder = accountHolder;
        this.balance = initialBalance;
    }
    
    // Methods
    public void deposit(double amount) {
        if (amount > 0 && isActive) {
            balance += amount;
            System.out.printf("Deposited $%.2f. New balance: $%.2f\n", amount, balance);
        }
    }
    
    public void withdraw(double amount) {
        if (amount > 0 && isActive && amount <= balance) {
            balance -= amount;
            System.out.printf("Withdrew $%.2f. New balance: $%.2f\n", amount, balance);
        }
    }
    
    public void transfer(BankAccount recipient, double amount) {
        if (amount > 0 && this.isActive && recipient.isActive && amount <= balance) {
            this.balance -= amount;
            recipient.balance += amount;
            System.out.printf("Transferred $%.2f to %s\n", amount, recipient.accountHolder);
        }
    }
    
    public void deactivate() {
        this.isActive = false;
        System.out.println("Account deactivated.");
    }
    
    public void activate() {
        this.isActive = true;
        System.out.println("Account activated.");
    }
    
    // Getters
    public int getAccountNumber() { return accountNumber; }
    public String getAccountHolder() { return accountHolder; }
    public double getBalance() { return balance; }
    public boolean isActive() { return isActive; }
    
    @Override
    public String toString() {
        return String.format("Account #%d: %s - $%.2f [%s]", 
                           accountNumber, accountHolder, balance, 
                           isActive ? "Active" : "Inactive");
    }
    
    // Finalizer (deprecated in Java 9+, shown for demonstration)
    @Override
    protected void finalize() throws Throwable {
        try {
            System.out.println("Finalizing account #" + accountNumber);
        } finally {
            super.finalize();
        }
    }
}

public class ObjectLifecycle {
    public static void main(String[] args) {
        System.out.println("=== Object Lifecycle Demonstration ===\n");
        
        // 1. Object Creation
        System.out.println("1. Creating BankAccount objects:");
        BankAccount account1 = new BankAccount("Alice");
        BankAccount account2 = new BankAccount("Bob", 1000.0);
        
        System.out.println("\n2. Initial state:");
        System.out.println(account1);
        System.out.println(account2);
        
        // 3. Object Usage
        System.out.println("\n3. Using objects:");
        account1.deposit(500.0);
        account1.withdraw(200.0);
        account1.transfer(account2, 100.0);
        
        System.out.println("\n4. After transactions:");
        System.out.println(account1);
        System.out.println(account2);
        
        // 4. Object State Changes
        System.out.println("\n5. Changing object state:");
        account1.deactivate();
        account1.deposit(100.0);  // Should fail - account inactive
        
        account1.activate();
        account1.deposit(100.0);  // Should work now
        
        // 5. Object References
        System.out.println("\n6. Object references:");
        BankAccount account3 = account1;  // Both reference same object
        System.out.println("account1: " + account1.getAccountNumber());
        System.out.println("account3: " + account3.getAccountNumber());
        System.out.println("Same object? " + (account1 == account3));
        
        // 6. Making object eligible for garbage collection
        System.out.println("\n7. Making objects eligible for GC:");
        account3 = null;
        
        // Suggest garbage collection (for demonstration only)
        System.gc();
        
        // Wait a bit to see finalizer output
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        System.out.println("\n=== Object Lifecycle Summary ===");
        System.out.println("1. Creation: new keyword");
        System.out.println("2. Initialization: constructors, initialization blocks");
        System.out.println("3. Usage: method calls, state changes");
        System.out.println("4. Inaccessibility: null reference, out of scope");
        System.out.println("5. Garbage Collection: automatic memory reclamation");
    }
}

// Employee class demonstrating different constructor types
class Employee {
    private int id;
    private String name;
    private String department;
    private double salary;
    private String email;
    private String phone;
    
    // ========== CONSTRUCTOR TYPES ==========
    
    // 1. Default (No-arg) Constructor
    public Employee() {
        this.id = 0;
        this.name = "Unknown";
        this.department = "Unassigned";
        this.salary = 0.0;
        this.email = "no-email@company.com";
        this.phone = "000-000-0000";
        System.out.println("Default constructor called");
    }
    
    // 2. Parameterized Constructor
    public Employee(int id, String name, String department, double salary) {
        this.id = id;
        this.name = name;
        this.department = department;
        this.salary = salary;
        this.email = name.toLowerCase().replace(" ", ".") + "@company.com";
        this.phone = "000-000-0000";
        System.out.println("Parameterized constructor called");
    }
    
    // 3. Constructor Overloading (different parameter list)
    public Employee(String name, String department) {
        this(0, name, department, 0.0);  // Calling another constructor
        System.out.println("Two-parameter constructor called");
    }
    
    // 4. Copy Constructor (creates copy of another object)
    public Employee(Employee other) {
        this.id = other.id;
        this.name = other.name;
        this.department = other.department;
        this.salary = other.salary;
        this.email = other.email;
        this.phone = other.phone;
        System.out.println("Copy constructor called");
    }
    
    // 5. Constructor with Object Parameter
    public Employee(int id, String name, Department dept) {
        this.id = id;
        this.name = name;
        this.department = dept.getName();
        this.salary = dept.getBaseSalary();
        this.email = generateEmail(name);
        this.phone = "000-000-0000";
    }
    
    // ========== HELPER METHODS ==========
    private String generateEmail(String name) {
        return name.toLowerCase().replace(" ", ".") + "@company.com";
    }
    
    // ========== GETTERS AND SETTERS ==========
    public int getId() { return id; }
    public void setId(int id) { this.id = id; }
    
    public String getName() { return name; }
    public void setName(String name) { 
        this.name = name;
        this.email = generateEmail(name);
    }
    
    public String getDepartment() { return department; }
    public void setDepartment(String department) { this.department = department; }
    
    public double getSalary() { return salary; }
    public void setSalary(double salary) { this.salary = salary; }
    
    public String getEmail() { return email; }
    public String getPhone() { return phone; }
    public void setPhone(String phone) { this.phone = phone; }
    
    // ========== BUSINESS METHODS ==========
    public void giveRaise(double percentage) {
        if (percentage > 0) {
            salary += salary * percentage / 100;
            System.out.printf("%s got %.1f%% raise. New salary: $%.2f\n", 
                            name, percentage, salary);
        }
    }
    
    public void transferDepartment(String newDept) {
        System.out.printf("%s transferred from %s to %s\n", 
                         name, department, newDept);
        department = newDept;
    }
    
    @Override
    public String toString() {
        return String.format("Employee #%d: %s (%s) - $%.2f", 
                           id, name, department, salary);
    }
}

// Supporting Department class
class Department {
    private String name;
    private double baseSalary;
    
    public Department(String name, double baseSalary) {
        this.name = name;
        this.baseSalary = baseSalary;
    }
    
    public String getName() { return name; }
    public double getBaseSalary() { return baseSalary; }
}

public class ConstructorTypes {
    public static void main(String[] args) {
        System.out.println("=== Constructor Types Demonstration ===\n");
        
        // 1. Using default constructor
        System.out.println("1. Default Constructor:");
        Employee emp1 = new Employee();
        System.out.println(emp1);
        
        // 2. Using parameterized constructor
        System.out.println("\n2. Parameterized Constructor:");
        Employee emp2 = new Employee(101, "John Doe", "Engineering", 75000.0);
        System.out.println(emp2);
        System.out.println("Email: " + emp2.getEmail());
        
        // 3. Using overloaded constructor
        System.out.println("\n3. Overloaded Constructor:");
        Employee emp3 = new Employee("Jane Smith", "Marketing");
        System.out.println(emp3);
        
        // 4. Using copy constructor
        System.out.println("\n4. Copy Constructor:");
        Employee emp4 = new Employee(emp2);  // Copy of emp2
        emp4.setId(102);  // Change ID to make it different
        emp4.setName("John Doe Clone");
        System.out.println("Original: " + emp2);
        System.out.println("Copy: " + emp4);
        
        // 5. Constructor with object parameter
        System.out.println("\n5. Constructor with Object Parameter:");
        Department itDept = new Department("IT", 80000.0);
        Employee emp5 = new Employee(103, "Bob Johnson", itDept);
        System.out.println(emp5);
        
        // 6. Constructor chaining demonstration
        System.out.println("\n6. Constructor Chaining:");
        System.out.println("Note how constructors call each other using this()");
        
        // 7. Object initialization sequence
        System.out.println("\n7. Initialization Sequence:");
        System.out.println("1. Default values assigned");
        System.out.println("2. Instance initialization blocks executed");
        System.out.println("3. Constructor executed");
        
        // 8. Common constructor mistakes
        System.out.println("\n8. Common Constructor Mistakes to Avoid:");
        System.out.println("- Forgetting to initialize all fields");
        System.out.println("- Not validating input parameters");
        System.out.println("- Not calling super() in inheritance hierarchy");
        System.out.println("- Making constructors too complex");
        
        // 9. Best practices
        System.out.println("\n9. Constructor Best Practices:");
        System.out.println("- Keep constructors simple");
        System.out.println("- Overload constructors for flexibility");
        System.out.println("- Use copy constructors for immutable objects");
        System.out.println("- Consider using factory methods for complex creation");
        System.out.println("- Always validate parameters in public constructors");
    }
}