Java Class

// The class: a blueprint for dogs
public class Dog {

    // Attributes (fields) -- what a dog HAS
    String name;
    String breed;
    String color;
    int age;

    // Behaviors (methods) -- what a dog DOES
    public void bark() {
        System.out.println(name + " says: Woof! Woof!");
    }

    public void fetch(String item) {
        System.out.println(name + " fetches the " + item);
    }

    public void sleep() {
        System.out.println(name + " is sleeping... Zzz");
    }
}

// Creating objects (instances) from the blueprint
Dog dog1 = new Dog();
dog1.name = "Max";
dog1.breed = "Golden Retriever";
dog1.age = 3;
dog1.bark();   // Max says: Woof! Woof!
dog1.fetch("ball"); // Max fetches the ball

Dog dog2 = new Dog();
dog2.name = "Luna";
dog2.breed = "German Shepherd";
dog2.age = 5;
dog2.bark();   // Luna says: Woof! Woof!
dog2.sleep();  // Luna is sleeping... Zzz

package com.lovemesomecoding.model;          // 1. Package declaration

import java.util.Objects;                      // 2. Import statements
import java.time.LocalDate;

public class Employee {                        // 3. Class declaration

    // 4. Static fields (constants first)
    private static final String COMPANY = "LoveMeSomeCoding";
    private static int employeeCount = 0;

    // 5. Instance fields
    private String firstName;
    private String lastName;
    private String email;
    private double salary;
    private LocalDate hireDate;

    // 6. Constructors
    public Employee(String firstName, String lastName, String email, double salary) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.email = email;
        this.salary = salary;
        this.hireDate = LocalDate.now();
        employeeCount++;
    }

    // 7. Public methods
    public String getFullName() {
        return firstName + " " + lastName;
    }

    public double getAnnualSalary() {
        return salary * 12;
    }

    // 8. Private/helper methods
    private String formatEmail() {
        return email.toLowerCase().trim();
    }

    // 9. toString, equals, hashCode (standard overrides)
    @Override
    public String toString() {
        return "Employee{name='" + getFullName() + "', email='" + email + "'}";
    }
}

public class Product {

    // Field declarations with explicit initial values
    private String name = "Unknown";
    private double price = 0.0;
    private int quantity = 0;
    private boolean inStock = false;

    // Field declaration without initial values (uses defaults)
    private String category;      // default: null
    private double discount;      // default: 0.0
    private int reviewCount;      // default: 0
    private boolean featured;     // default: false
}

// Good -- descriptive, camelCase
private String firstName;
private double accountBalance;
private int totalOrderCount;
private boolean isActive;           // boolean fields often start with "is", "has", "can"
private boolean hasPermission;

// Bad -- vague, wrong conventions
private String s;                   // too short, meaningless
private double Account_Balance;     // wrong: uses underscores and uppercase start
private int x;                      // what does x represent?
private boolean flag;               // flag for what?

// Java provides a default constructor automatically here
// because we did not write any constructor
public class User {
    private String name;
    private int age;
}

// This works because the default constructor exists
User user = new User();
// user.name is null, user.age is 0 (default values)

public class User {
    private String name;
    private String email;
    private int age;

    // Parameterized constructor
    public User(String name, String email, int age) {
        this.name = name;
        this.email = email;
        this.age = age;
    }
}

// Creating an object with the parameterized constructor
User user = new User("Folau", "folau@email.com", 30);

// This will NOT compile -- no default constructor exists anymore
// User user2 = new User();  // Compilation error!

public class User {
    private String name;
    private String email;
    private int age;

    // Constructor 1: all fields
    public User(String name, String email, int age) {
        this.name = name;
        this.email = email;
        this.age = age;
    }

    // Constructor 2: name and email only, default age
    public User(String name, String email) {
        this.name = name;
        this.email = email;
        this.age = 0;  // default
    }

    // Constructor 3: no arguments
    public User() {
        this.name = "Unknown";
        this.email = "none@example.com";
        this.age = 0;
    }
}

// All three ways to create a User
User user1 = new User("Folau", "folau@email.com", 30);
User user2 = new User("Lisa", "lisa@email.com");
User user3 = new User();

public class User {
    private String name;
    private String email;
    private int age;

    // Primary constructor -- all initialization happens here
    public User(String name, String email, int age) {
        this.name = name;
        this.email = email;
        this.age = age;
        System.out.println("User created: " + name);
    }

    // Chains to the primary constructor with a default age
    public User(String name, String email) {
        this(name, email, 0);  // calls User(String, String, int)
    }

    // Chains to the two-argument constructor, which chains to the primary
    public User() {
        this("Unknown", "none@example.com");  // calls User(String, String)
    }
}

// All three constructors eventually call the primary constructor
User user1 = new User("Folau", "folau@email.com", 30); // User created: Folau
User user2 = new User("Lisa", "lisa@email.com");        // User created: Lisa
User user3 = new User();                                 // User created: Unknown

public class User {
    private String name;
    private String email;
    private int age;

    // Regular constructor
    public User(String name, String email, int age) {
        this.name = name;
        this.email = email;
        this.age = age;
    }

    // Copy constructor -- creates a new User from an existing one
    public User(User other) {
        this.name = other.name;
        this.email = other.email;
        this.age = other.age;
    }
}

User original = new User("Folau", "folau@email.com", 30);
User copy = new User(original);  // independent copy

System.out.println(original == copy);  // false -- different objects in memory
// But they have the same field values

// Creating objects
User user1 = new User("Folau", "folau@email.com", 30);
User user2 = new User("Lisa", "lisa@email.com", 28);

// user1 and user2 are separate objects on the heap
System.out.println(user1 == user2);  // false -- different objects

// Two references pointing to the SAME object
User user1 = new User("Folau", "folau@email.com", 30);
User user2 = user1;  // user2 now points to the same object as user1

// Modifying through user2 also affects user1 -- they share the same object
user2.setName("Folau K.");
System.out.println(user1.getName());  // Output: Folau K.
System.out.println(user1 == user2);   // Output: true -- same reference

// Null references
User user3 = null;  // user3 does not point to any object

// Calling a method on null throws NullPointerException
// user3.getName();  // NullPointerException at runtime!

// Always check for null before using a reference
if (user3 != null) {
    System.out.println(user3.getName());
} else {
    System.out.println("user3 is null");  // Output: user3 is null
}

// Three references, but how many objects?
User a = new User("Alice", "alice@email.com", 25);  // Object 1 created
User b = new User("Bob", "bob@email.com", 30);      // Object 2 created
User c = a;  // c points to Object 1 (same as a)

// Answer: 2 objects, 3 references
// a and c -> Object 1
// b       -> Object 2

a = null;  // a no longer points to Object 1, but c still does
// Object 1 is NOT garbage collected because c still references it

c = null;  // Now nothing references Object 1
// Object 1 is eligible for garbage collection

public class User {
    private String name;
    private int age;

    public User(String name, int age) {
        // Without "this", Java thinks you are assigning the parameter to itself
        // name = name;  // WRONG: does nothing useful

        // "this.name" refers to the field, "name" refers to the parameter
        this.name = name;
        this.age = age;
    }

    public void setName(String name) {
        this.name = name;  // this.name = field, name = parameter
    }
}

public class UserBuilder {
    private String name;
    private String email;
    private int age;

    public UserBuilder setName(String name) {
        this.name = name;
        return this;  // return the current object
    }

    public UserBuilder setEmail(String email) {
        this.email = email;
        return this;
    }

    public UserBuilder setAge(int age) {
        this.age = age;
        return this;
    }

    public User build() {
        return new User(name, email, age);
    }
}

// Method chaining -- clean and readable
User user = new UserBuilder()
    .setName("Folau")
    .setEmail("folau@email.com")
    .setAge(30)
    .build();

public class Order {
    private int orderId;

    public Order(int orderId) {
        this.orderId = orderId;
    }

    public void process(OrderProcessor processor) {
        // Pass the current Order object to the processor
        processor.process(this);
    }

    public int getOrderId() {
        return orderId;
    }
}

public class OrderProcessor {
    public void process(Order order) {
        System.out.println("Processing order #" + order.getOrderId());
    }
}

// Usage
Order order = new Order(1001);
OrderProcessor processor = new OrderProcessor();
order.process(processor);  // Output: Processing order #1001

// File: User.java

// This public class MUST be in a file named "User.java"
public class User {
    private String name;

    public User(String name) {
        this.name = name;
    }
}

// This package-private class can also be in User.java
// but it is only visible within the same package
class UserValidator {
    public boolean isValid(User user) {
        return user != null;
    }
}

// Classes in other packages CANNOT see UserValidator
// Only User is accessible everywhere

public class User {
    private String name;
    private String email;
    private int age;
    private boolean active;

    public User(String name, String email, int age) {
        this.name = name;
        setEmail(email);  // use the setter for validation even in the constructor
        setAge(age);
        this.active = true;
    }

    // --- Getters ---

    public String getName() {
        return name;
    }

    public String getEmail() {
        return email;
    }

    public int getAge() {
        return age;
    }

    // Boolean getter uses "is" prefix
    public boolean isActive() {
        return active;
    }

    // --- Setters with Validation ---

    public void setName(String name) {
        if (name == null || name.isBlank()) {
            throw new IllegalArgumentException("Name cannot be null or blank");
        }
        this.name = name;
    }

    public void setEmail(String email) {
        if (email == null || !email.contains("@")) {
            throw new IllegalArgumentException("Invalid email: " + email);
        }
        this.email = email.toLowerCase().trim();
    }

    public void setAge(int age) {
        if (age < 0 || age > 150) {
            throw new IllegalArgumentException("Age must be between 0 and 150, got: " + age);
        }
        this.age = age;
    }

    public void setActive(boolean active) {
        this.active = active;
    }
}

// Usage
User user = new User("Folau", "Folau@Email.com", 30);
System.out.println(user.getEmail());  // Output: folau@email.com (trimmed and lowercased)
System.out.println(user.isActive());  // Output: true

// Validation prevents invalid data
// user.setAge(-5);  // throws IllegalArgumentException: Age must be between 0 and 150, got: -5
// user.setEmail("bad");  // throws IllegalArgumentException: Invalid email: bad

public class User {
    private String name;
    private String email;
    private int age;

    // Constructor omitted for brevity

    @Override
    public String toString() {
        return "User{name='" + name + "', email='" + email + "', age=" + age + "}";
    }
}

User user = new User("Folau", "folau@email.com", 30);

// Without override: User@1a2b3c4d
// With override:
System.out.println(user);  // Output: User{name='Folau', email='folau@email.com', age=30}

import java.util.Objects;

public class User {
    private String name;
    private String email;
    private int age;

    public User(String name, String email, int age) {
        this.name = name;
        this.email = email;
        this.age = age;
    }

    @Override
    public boolean equals(Object obj) {
        // 1. Same reference? Must be equal.
        if (this == obj) return true;

        // 2. Null or different class? Cannot be equal.
        if (obj == null || getClass() != obj.getClass()) return false;

        // 3. Cast and compare fields
        User other = (User) obj;
        return age == other.age
            && Objects.equals(name, other.name)
            && Objects.equals(email, other.email);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, email, age);
    }

    @Override
    public String toString() {
        return "User{name='" + name + "', email='" + email + "', age=" + age + "}";
    }
}

// Demonstration
User user1 = new User("Folau", "folau@email.com", 30);
User user2 = new User("Folau", "folau@email.com", 30);
User user3 = new User("Lisa", "lisa@email.com", 28);

System.out.println(user1 == user2);       // false -- different objects in memory
System.out.println(user1.equals(user2));   // true  -- same field values
System.out.println(user1.equals(user3));   // false -- different field values

// Now they work correctly in collections
Set users = new HashSet<>();
users.add(user1);
users.add(user2);  // duplicate, not added
System.out.println(users.size());  // Output: 1

public class User {

    // Static field -- shared across ALL User objects
    private static int userCount = 0;

    // Static constant -- shared and immutable
    public static final int MAX_USERS = 10000;

    // Instance fields -- unique to each object
    private String name;
    private int userId;

    public User(String name) {
        this.name = name;
        userCount++;              // increment the shared counter
        this.userId = userCount;  // assign a unique ID
    }

    // Static method -- access through the class name, not an object
    public static int getUserCount() {
        return userCount;
    }

    public String getName() {
        return name;
    }

    public int getUserId() {
        return userId;
    }
}

User alice = new User("Alice");
User bob = new User("Bob");
User charlie = new User("Charlie");

System.out.println(User.getUserCount());  // Output: 3 (shared counter)
System.out.println(User.MAX_USERS);       // Output: 10000

System.out.println(alice.getUserId());    // Output: 1
System.out.println(bob.getUserId());      // Output: 2
System.out.println(charlie.getUserId());  // Output: 3

public class MathHelper {

    // Static method -- called on the class, not an instance
    public static int add(int a, int b) {
        return a + b;
    }

    public static double celsiusToFahrenheit(double celsius) {
        return (celsius * 9.0 / 5.0) + 32;
    }

    public static boolean isEven(int number) {
        return number % 2 == 0;
    }
}

// Called using the class name -- no object needed
int sum = MathHelper.add(10, 20);                  // 30
double temp = MathHelper.celsiusToFahrenheit(100); // 212.0
boolean even = MathHelper.isEven(7);               // false

public class AppConfig {
    private static final Map CONFIG;

    // Static block -- runs once when the class loads
    static {
        CONFIG = new HashMap<>();
        CONFIG.put("app.name", "LoveMeSomeCoding");
        CONFIG.put("app.version", "2.0");
        CONFIG.put("app.env", "production");
        System.out.println("AppConfig loaded.");
    }

    public static String get(String key) {
        return CONFIG.getOrDefault(key, "unknown");
    }
}

// The static block runs when this class is first referenced
String name = AppConfig.get("app.name");     // Output (first call): AppConfig loaded.
System.out.println(name);                    // Output: LoveMeSomeCoding
String version = AppConfig.get("app.version");
System.out.println(version);                 // Output: 2.0

public class User {
    private String name;
    private Address address;

    public User(String name, Address address) {
        this.name = name;
        this.address = address;
    }

    // Static nested class -- does NOT need a User instance
    public static class Address {
        private String street;
        private String city;
        private String state;
        private String zip;

        public Address(String street, String city, String state, String zip) {
            this.street = street;
            this.city = city;
            this.state = state;
            this.zip = zip;
        }

        @Override
        public String toString() {
            return street + ", " + city + ", " + state + " " + zip;
        }
    }

    @Override
    public String toString() {
        return name + " - " + address;
    }
}

// Creating the static nested class -- no User instance needed
User.Address address = new User.Address("123 Main St", "Orem", "UT", "84058");
User user = new User("Folau", address);
System.out.println(user);  // Output: Folau - 123 Main St, Orem, UT 84058

public class ShoppingCart {
    private String customerName;
    private List items = new ArrayList<>();

    public ShoppingCart(String customerName) {
        this.customerName = customerName;
    }

    public Item addItem(String productName, double price, int quantity) {
        Item item = new Item(productName, price, quantity);
        items.add(item);
        return item;
    }

    public double getTotal() {
        double total = 0;
        for (Item item : items) {
            total += item.getSubtotal();
        }
        return total;
    }

    // Non-static inner class -- has access to ShoppingCart's fields
    public class Item {
        private String productName;
        private double price;
        private int quantity;

        public Item(String productName, double price, int quantity) {
            this.productName = productName;
            this.price = price;
            this.quantity = quantity;
        }

        public double getSubtotal() {
            return price * quantity;
        }

        @Override
        public String toString() {
            // Can access the outer class's customerName field
            return customerName + "'s item: " + productName
                + " ($" + price + " x " + quantity + ")";
        }
    }
}

ShoppingCart cart = new ShoppingCart("Folau");
ShoppingCart.Item item1 = cart.addItem("Java Book", 49.99, 1);
ShoppingCart.Item item2 = cart.addItem("Coffee Mug", 12.50, 3);

System.out.println(item1);          // Output: Folau's item: Java Book ($49.99 x 1)
System.out.println(item2);          // Output: Folau's item: Coffee Mug ($12.5 x 3)
System.out.println(cart.getTotal()); // Output: 87.49

// Suppose we have this interface
public interface Greeting {
    void greet(String name);
}

// Anonymous class -- define and instantiate in one expression
Greeting formalGreeting = new Greeting() {
    @Override
    public void greet(String name) {
        System.out.println("Good day, " + name + ". How do you do?");
    }
};

formalGreeting.greet("Folau");  // Output: Good day, Folau. How do you do?

// Since Java 8, for single-method interfaces, you can use a lambda instead:
Greeting casualGreeting = name -> System.out.println("Hey, " + name + "!");
casualGreeting.greet("Folau");  // Output: Hey, Folau!

// Example: An immutable class following best practices
public final class Money {

    private final double amount;
    private final String currency;

    public Money(double amount, String currency) {
        if (amount < 0) {
            throw new IllegalArgumentException("Amount cannot be negative: " + amount);
        }
        if (currency == null || currency.isBlank()) {
            throw new IllegalArgumentException("Currency cannot be null or blank");
        }
        this.amount = amount;
        this.currency = currency.toUpperCase();
    }

    // Only getters -- no setters (immutable)
    public double getAmount() {
        return amount;
    }

    public String getCurrency() {
        return currency;
    }

    // Operations return NEW objects instead of modifying this one
    public Money add(Money other) {
        if (!this.currency.equals(other.currency)) {
            throw new IllegalArgumentException(
                "Cannot add " + this.currency + " and " + other.currency
            );
        }
        return new Money(this.amount + other.amount, this.currency);
    }

    @Override
    public String toString() {
        return String.format("%s %.2f", currency, amount);
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        Money other = (Money) obj;
        return Double.compare(other.amount, amount) == 0
            && Objects.equals(currency, other.currency);
    }

    @Override
    public int hashCode() {
        return Objects.hash(amount, currency);
    }
}

Money price = new Money(29.99, "usd");
Money tax = new Money(2.40, "usd");
Money total = price.add(tax);

System.out.println(price);  // Output: USD 29.99
System.out.println(tax);    // Output: USD 2.40
System.out.println(total);  // Output: USD 32.39

// price, tax, and total are all separate, immutable objects
// None of them can ever be changed after creation

import java.util.Objects;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class BankAccount {

    // --- Static fields ---

    private static final double MINIMUM_BALANCE = 0.0;
    private static final double MAX_WITHDRAWAL = 10000.0;
    private static final DateTimeFormatter FORMATTER =
        DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
    private static int accountCounter = 0;

    // --- Instance fields ---

    private final String accountNumber;
    private String ownerName;
    private String email;
    private double balance;
    private boolean active;
    private final LocalDateTime createdAt;
    private final List transactionHistory;

    // --- Constructors ---

    // Primary constructor -- all initialization happens here
    public BankAccount(String ownerName, String email, double initialDeposit) {
        if (ownerName == null || ownerName.isBlank()) {
            throw new IllegalArgumentException("Owner name cannot be null or blank");
        }
        if (email == null || !email.contains("@")) {
            throw new IllegalArgumentException("Invalid email: " + email);
        }
        if (initialDeposit < 0) {
            throw new IllegalArgumentException(
                "Initial deposit cannot be negative: " + initialDeposit
            );
        }

        accountCounter++;
        this.accountNumber = "ACC-" + String.format("%06d", accountCounter);
        this.ownerName = ownerName;
        this.email = email.toLowerCase().trim();
        this.balance = initialDeposit;
        this.active = true;
        this.createdAt = LocalDateTime.now();
        this.transactionHistory = new ArrayList<>();
        this.transactionHistory.add(formatTransaction("Account opened", initialDeposit));
    }

    // Constructor chaining -- zero initial deposit
    public BankAccount(String ownerName, String email) {
        this(ownerName, email, 0.0);
    }

    // Copy constructor
    public BankAccount(BankAccount other) {
        this(other.ownerName, other.email, other.balance);
    }

    // --- Static methods ---

    public static int getTotalAccounts() {
        return accountCounter;
    }

    public static double getMinimumBalance() {
        return MINIMUM_BALANCE;
    }

    // --- Public methods (business logic) ---

    public void deposit(double amount) {
        validateActive();
        if (amount <= 0) {
            throw new IllegalArgumentException("Deposit amount must be positive: " + amount);
        }
        balance += amount;
        transactionHistory.add(formatTransaction("Deposit", amount));
    }

    public void withdraw(double amount) {
        validateActive();
        if (amount <= 0) {
            throw new IllegalArgumentException("Withdrawal amount must be positive: " + amount);
        }
        if (amount > MAX_WITHDRAWAL) {
            throw new IllegalArgumentException(
                "Withdrawal exceeds max limit of $" + MAX_WITHDRAWAL + ": $" + amount
            );
        }
        if (balance - amount < MINIMUM_BALANCE) {
            throw new IllegalStateException(
                "Insufficient funds. Balance: $" + balance + ", Requested: $" + amount
            );
        }
        balance -= amount;
        transactionHistory.add(formatTransaction("Withdrawal", -amount));
    }

    public void transfer(BankAccount target, double amount) {
        if (target == null) {
            throw new IllegalArgumentException("Target account cannot be null");
        }
        this.withdraw(amount);
        target.deposit(amount);
        this.transactionHistory.add(
            formatTransaction("Transfer to " + target.accountNumber, -amount)
        );
        target.transactionHistory.add(
            formatTransaction("Transfer from " + this.accountNumber, amount)
        );
    }

    public void deactivate() {
        this.active = false;
        transactionHistory.add(formatTransaction("Account deactivated", 0));
    }

    // --- Getters ---

    public String getAccountNumber() {
        return accountNumber;
    }

    public String getOwnerName() {
        return ownerName;
    }

    public String getEmail() {
        return email;
    }

    public double getBalance() {
        return balance;
    }

    public boolean isActive() {
        return active;
    }

    public LocalDateTime getCreatedAt() {
        return createdAt;
    }

    // Return an unmodifiable view -- defensive copy for encapsulation
    public List getTransactionHistory() {
        return Collections.unmodifiableList(transactionHistory);
    }

    // --- Setters (only for fields that can change) ---

    public void setOwnerName(String ownerName) {
        if (ownerName == null || ownerName.isBlank()) {
            throw new IllegalArgumentException("Owner name cannot be null or blank");
        }
        this.ownerName = ownerName;
    }

    public void setEmail(String email) {
        if (email == null || !email.contains("@")) {
            throw new IllegalArgumentException("Invalid email: " + email);
        }
        this.email = email.toLowerCase().trim();
    }

    // No setters for accountNumber, balance, createdAt -- these are
    // controlled internally or are immutable

    // --- Private helper methods ---

    private void validateActive() {
        if (!active) {
            throw new IllegalStateException("Account " + accountNumber + " is deactivated");
        }
    }

    private String formatTransaction(String type, double amount) {
        return String.format("[%s] %s: $%.2f | Balance: $%.2f",
            LocalDateTime.now().format(FORMATTER), type, amount, balance);
    }

    // --- toString, equals, hashCode ---

    @Override
    public String toString() {
        return "BankAccount{" +
            "accountNumber='" + accountNumber + '\'' +
            ", owner='" + ownerName + '\'' +
            ", balance=$" + String.format("%.2f", balance) +
            ", active=" + active +
            '}';
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        BankAccount other = (BankAccount) obj;
        return Objects.equals(accountNumber, other.accountNumber);
    }

    @Override
    public int hashCode() {
        return Objects.hash(accountNumber);
    }
}

public class BankApp {

    public static void main(String[] args) {

        // --- Creating accounts (constructors) ---
        BankAccount folau = new BankAccount("Folau", "folau@email.com", 5000.00);
        BankAccount lisa = new BankAccount("Lisa", "lisa@email.com", 3000.00);
        BankAccount guest = new BankAccount("Guest", "guest@email.com"); // zero balance

        System.out.println("=== Accounts Created ===");
        System.out.println(folau);
        System.out.println(lisa);
        System.out.println(guest);
        System.out.println("Total accounts: " + BankAccount.getTotalAccounts());

        // --- Deposits and withdrawals ---
        System.out.println("\n=== Transactions ===");
        folau.deposit(1500.00);
        System.out.println("After deposit: " + folau.getBalance());  // 6500.00

        folau.withdraw(2000.00);
        System.out.println("After withdrawal: " + folau.getBalance());  // 4500.00

        // --- Transfer ---
        System.out.println("\n=== Transfer ===");
        folau.transfer(lisa, 1000.00);
        System.out.println("Folau's balance: $" + folau.getBalance());   // 3500.00
        System.out.println("Lisa's balance: $" + lisa.getBalance());     // 4000.00

        // --- Encapsulation: setter validation ---
        System.out.println("\n=== Update Email ===");
        folau.setEmail("  FOLAU.K@Email.com  ");
        System.out.println("New email: " + folau.getEmail());  // folau.k@email.com

        // --- toString ---
        System.out.println("\n=== toString ===");
        System.out.println(folau);

        // --- equals and hashCode ---
        System.out.println("\n=== equals ===");
        BankAccount folauCopy = new BankAccount(folau);  // copy constructor
        System.out.println("folau == folauCopy: " + (folau == folauCopy));
        System.out.println("folau.equals(folauCopy): " + folau.equals(folauCopy));
        // false -- copy constructor creates a new account number

        // --- Transaction history (defensive copy) ---
        System.out.println("\n=== Transaction History ===");
        for (String tx : folau.getTransactionHistory()) {
            System.out.println("  " + tx);
        }

        // --- Deactivation ---
        System.out.println("\n=== Deactivation ===");
        guest.deactivate();
        System.out.println(guest);

        // This would throw IllegalStateException:
        // guest.deposit(100.00);  // Account ACC-000003 is deactivated

        // --- Static members ---
        System.out.println("\n=== Static Info ===");
        System.out.println("Total accounts created: " + BankAccount.getTotalAccounts());
        System.out.println("Minimum balance: $" + BankAccount.getMinimumBalance());
    }
}

/*
 * Output:
 * === Accounts Created ===
 * BankAccount{accountNumber='ACC-000001', owner='Folau', balance=$5000.00, active=true}
 * BankAccount{accountNumber='ACC-000002', owner='Lisa', balance=$3000.00, active=true}
 * BankAccount{accountNumber='ACC-000003', owner='Guest', balance=$0.00, active=true}
 * Total accounts: 3
 *
 * === Transactions ===
 * After deposit: 6500.0
 * After withdrawal: 4500.0
 *
 * === Transfer ===
 * Folau's balance: $3500.0
 * Lisa's balance: $4000.0
 *
 * === Update Email ===
 * New email: folau.k@email.com
 *
 * === toString ===
 * BankAccount{accountNumber='ACC-000001', owner='Folau', balance=$3500.00, active=true}
 *
 * === equals ===
 * folau == folauCopy: false
 * folau.equals(folauCopy): false
 *
 * === Transaction History ===
 *   [2026-02-28 10:00:00] Account opened: $5000.00 | Balance: $5000.00
 *   [2026-02-28 10:00:01] Deposit: $1500.00 | Balance: $6500.00
 *   [2026-02-28 10:00:01] Withdrawal: $-2000.00 | Balance: $4500.00
 *   [2026-02-28 10:00:01] Transfer to ACC-000002: $-1000.00 | Balance: $3500.00
 *
 * === Deactivation ===
 * BankAccount{accountNumber='ACC-000003', owner='Guest', balance=$0.00, active=false}
 *
 * === Static Info ===
 * Total accounts created: 4
 * Minimum balance: $0.0
 */

---