Java Static Variables, Methods, and Classes

// Comprehensive static variables example
import java.util.ArrayList;
import java.util.List;

class Bank {
    // ========== STATIC VARIABLES ==========
    
    // 1. Static constant (final static)
    public static final String BANK_NAME = "Global Bank";
    public static final double INTEREST_RATE = 4.5;
    public static final int MAX_ACCOUNTS_PER_CUSTOMER = 5;
    
    // 2. Static variable for counting objects
    private static int totalAccountsCreated = 0;
    
    // 3. Static variable for shared resource
    private static double totalBankBalance = 0.0;
    
    // 4. Static collection shared by all instances
    private static List allAccountNumbers = new ArrayList<>();
    
    // 5. Static variable with lazy initialization
    private static BankStatistics statistics = null;
    
    // 6. Static variable for configuration
    private static Configuration config = new Configuration();
    
    // 7. Static variable tracking class state
    private static boolean isBankOpen = true;
    
    // ========== INSTANCE VARIABLES ==========
    private String accountNumber;
    private String accountHolder;
    private double balance;
    private AccountType type;
    
    // ========== CONSTRUCTOR ==========
    public Bank(String accountHolder, double initialBalance, AccountType type) {
        this.accountNumber = generateAccountNumber();
        this.accountHolder = accountHolder;
        this.balance = initialBalance;
        this.type = type;
        
        // Update static variables
        totalAccountsCreated++;
        totalBankBalance += initialBalance;
        allAccountNumbers.add(accountNumber);
        
        System.out.println("Account created: " + accountNumber + 
                          " for " + accountHolder);
    }
    
    // ========== STATIC METHODS ==========
    public static int getTotalAccountsCreated() {
        return totalAccountsCreated;
    }
    
    public static double getTotalBankBalance() {
        return totalBankBalance;
    }
    
    public static List getAllAccountNumbers() {
        // Return copy to prevent modification
        return new ArrayList<>(allAccountNumbers);
    }
    
    public static BankStatistics getStatistics() {
        if (statistics == null) {
            statistics = new BankStatistics();
        }
        return statistics;
    }
    
    public static boolean isBankOpen() {
        return isBankOpen;
    }
    
    public static void closeBank() {
        isBankOpen = false;
        System.out.println("Bank is now closed for the day");
    }
    
    public static void openBank() {
        isBankOpen = true;
        System.out.println("Bank is now open");
    }
    
    // Static utility method
    private static String generateAccountNumber() {
        return "ACC" + (100000 + totalAccountsCreated);
    }
    
    // ========== INSTANCE METHODS ==========
    public void deposit(double amount) {
        if (isBankOpen && amount > 0) {
            balance += amount;
            totalBankBalance += amount;  // Update static variable
            System.out.println("Deposited $" + amount + " to " + accountNumber);
        }
    }
    
    public void withdraw(double amount) {
        if (isBankOpen && amount > 0 && balance >= amount) {
            balance -= amount;
            totalBankBalance -= amount;  // Update static variable
            System.out.println("Withdrew $" + amount + " from " + accountNumber);
        }
    }
    
    public void transfer(Bank recipient, double amount) {
        if (isBankOpen && amount > 0 && balance >= amount) {
            this.balance -= amount;
            recipient.balance += amount;
            // totalBankBalance unchanged (money stays in bank)
            System.out.println("Transferred $" + amount + " from " + 
                             accountNumber + " to " + recipient.accountNumber);
        }
    }
    
    // ========== GETTERS ==========
    public String getAccountNumber() {
        return accountNumber;
    }
    
    public String getAccountHolder() {
        return accountHolder;
    }
    
    public double getBalance() {
        return balance;
    }
    
    public AccountType getType() {
        return type;
    }
    
    @Override
    public String toString() {
        return String.format("Account[%s: %s - $%.2f (%s)]", 
                           accountNumber, accountHolder, balance, type);
    }
}

// ========== SUPPORTING CLASSES ==========
enum AccountType {
    SAVINGS, CHECKING, BUSINESS, STUDENT
}

class BankStatistics {
    private int transactionsToday = 0;
    private double averageBalance = 0.0;
    
    public void recordTransaction() {
        transactionsToday++;
    }
    
    public double calculateAverageBalance() {
        int totalAccounts = Bank.getTotalAccountsCreated();
        if (totalAccounts > 0) {
            return Bank.getTotalBankBalance() / totalAccounts;
        }
        return 0.0;
    }
    
    public void displayStatistics() {
        System.out.println("\n=== Bank Statistics ===");
        System.out.println("Total Accounts: " + Bank.getTotalAccountsCreated());
        System.out.println("Total Bank Balance: $" + Bank.getTotalBankBalance());
        System.out.println("Average Balance: $" + calculateAverageBalance());
        System.out.println("Transactions Today: " + transactionsToday);
        System.out.println("Bank Open: " + Bank.isBankOpen());
    }
}

class Configuration {
    private int maxWithdrawalLimit = 5000;
    private double overdraftFee = 35.0;
    private String currency = "USD";
    
    public int getMaxWithdrawalLimit() {
        return maxWithdrawalLimit;
    }
    
    public double getOverdraftFee() {
        return overdraftFee;
    }
    
    public String getCurrency() {
        return currency;
    }
}

public class StaticVariablesExample {
    public static void main(String[] args) {
        System.out.println("=== Static Variables (Class Variables) ===\n");
        
        System.out.println("1. Accessing static constants:");
        System.out.println("Bank Name: " + Bank.BANK_NAME);
        System.out.println("Interest Rate: " + Bank.INTEREST_RATE + "%");
        System.out.println("Max Accounts: " + Bank.MAX_ACCOUNTS_PER_CUSTOMER);
        
        System.out.println("\n2. Creating bank accounts:");
        Bank account1 = new Bank("Alice Johnson", 5000.0, AccountType.SAVINGS);
        Bank account2 = new Bank("Bob Smith", 3000.0, AccountType.CHECKING);
        Bank account3 = new Bank("Charlie Brown", 10000.0, AccountType.BUSINESS);
        
        System.out.println("\n3. Static variable sharing demonstration:");
        System.out.println("Total accounts created: " + Bank.getTotalAccountsCreated());
        System.out.println("Total bank balance: $" + Bank.getTotalBankBalance());
        
        System.out.println("\n4. Performing transactions:");
        account1.deposit(1000.0);
        account2.withdraw(500.0);
        account3.transfer(account1, 2000.0);
        
        System.out.println("\n5. After transactions:");
        System.out.println("Total bank balance: $" + Bank.getTotalBankBalance());
        System.out.println("Account 1 balance: $" + account1.getBalance());
        System.out.println("Account 2 balance: $" + account2.getBalance());
        System.out.println("Account 3 balance: $" + account3.getBalance());
        
        System.out.println("\n6. Shared static collection:");
        List allAccounts = Bank.getAllAccountNumbers();
        System.out.println("All account numbers: " + allAccounts);
        
        System.out.println("\n7. Singleton pattern with static variable:");
        BankStatistics stats1 = Bank.getStatistics();
        BankStatistics stats2 = Bank.getStatistics();
        System.out.println("Same statistics object? " + (stats1 == stats2));
        stats1.recordTransaction();
        stats1.recordTransaction();
        stats1.displayStatistics();
        
        System.out.println("\n8. Static variable for class state:");
        System.out.println("Bank open? " + Bank.isBankOpen());
        Bank.closeBank();
        System.out.println("Bank open? " + Bank.isBankOpen());
        
        // Try transaction when bank is closed
        account1.deposit(100.0);  // Should not work
        
        Bank.openBank();
        account1.deposit(100.0);  // Should work now
        
        System.out.println("\n9. Memory demonstration:");
        System.out.println("Each Bank object has:");
        System.out.println("  - Instance variables: accountNumber, accountHolder, balance, type");
        System.out.println("  - Shared static variables: totalAccountsCreated, totalBankBalance, etc.");
        System.out.println("\nMemory layout:");
        System.out.println("Heap: 3 Bank objects (each ~40 bytes)");
        System.out.println("Static Area: 1 copy of static variables");
        System.out.println("Total memory: ~120 bytes (heap) + ~50 bytes (static)");
        System.out.println("Without static, would need: ~170 bytes * 3 = 510 bytes");
        
        System.out.println("\n10. Creating more accounts to see counter:");
        Bank account4 = new Bank("Diana Prince", 7500.0, AccountType.SAVINGS);
        Bank account5 = new Bank("Ethan Hunt", 2500.0, AccountType.STUDENT);
        
        System.out.println("\nFinal statistics:");
        stats1.displayStatistics();
        
        System.out.println("\n=== Static Variable Rules ===");
        System.out.println("1. Single copy shared by all instances");
        System.out.println("2. Loaded when class is loaded (before object creation)");
        System.out.println("3. Can be accessed without object: ClassName.variable");
        System.out.println("4. Can be accessed with object: object.variable (not recommended)");
        System.out.println("5. Default value based on type (0, null, false)");
        System.out.println("6. Can be public, private, protected, or default");
        System.out.println("7. Can be final (constant)");
        System.out.println("8. Exist for program lifetime");
    }
}

// Comprehensive static classes example

// ========== OUTER CLASS ==========
class University {
    // Static variables of outer class
    private static String universityName = "Tech University";
    private static int establishedYear = 1950;
    private static int totalStudents = 0;
    
    // Instance variables
    private String departmentName;
    private int departmentStudents;
    
    // Constructor
    public University(String departmentName, int departmentStudents) {
        this.departmentName = departmentName;
        this.departmentStudents = departmentStudents;
        totalStudents += departmentStudents;
    }
    
    // ========== STATIC NESTED CLASS ==========
    // Can be public, private, protected, or package-private
    public static class Student {
        // Can have its own static variables
        private static int nextStudentId = 1000;
        
        // Instance variables
        private int studentId;
        private String name;
        private String major;
        private double gpa;
        
        // Constructor
        public Student(String name, String major) {
            this.studentId = nextStudentId++;
            this.name = name;
            this.major = major;
            this.gpa = 0.0;
        }
        
        // Can access static members of outer class DIRECTLY
        public void displayUniversityInfo() {
            System.out.println("University: " + universityName);
            System.out.println("Established: " + establishedYear);
            System.out.println("Total Students: " + totalStudents);
        }
        
        // CANNOT access instance members of outer class
        /*
        public void displayDepartmentInfo() {
            System.out.println(departmentName);  // COMPILE ERROR!
            // Cannot make static reference to non-static field
        }
        */
        
        // Instance methods
        public void enroll() {
            System.out.println(name + " (ID: " + studentId + 
                             ") enrolled in " + major);
        }
        
        public void updateGPA(double newGPA) {
            this.gpa = newGPA;
            System.out.println(name + "'s GPA updated to: " + gpa);
        }
        
        // Static method in static nested class
        public static int getNextStudentId() {
            return nextStudentId;
        }
        
        // Getters
        public int getStudentId() { return studentId; }
        public String getName() { return name; }
        public String getMajor() { return major; }
        public double getGpa() { return gpa; }
        
        @Override
        public String toString() {
            return String.format("Student[%d: %s - %s (GPA: %.2f)]", 
                               studentId, name, major, gpa);
        }
    }
    
    // ========== ANOTHER STATIC NESTED CLASS ==========
    private static class Statistics {
        // Private static nested class - only accessible within University
        private static int graduatesThisYear = 0;
        
        public static void recordGraduation() {
            graduatesThisYear++;
            totalStudents--;  // Can access outer class static variable
        }
        
        public static void displayStatistics() {
            System.out.println("\n=== University Statistics ===");
            System.out.println("University: " + universityName);
            System.out.println("Total Students: " + totalStudents);
            System.out.println("Graduates This Year: " + graduatesThisYear);
            System.out.println("Next Student ID: " + Student.getNextStudentId());
        }
    }
    
    // ========== STATIC NESTED ENUM ==========
    public static enum DegreeType {
        BACHELOR("Bachelor's Degree", 4),
        MASTER("Master's Degree", 2),
        DOCTORATE("Doctorate", 4),
        ASSOCIATE("Associate Degree", 2);
        
        private final String displayName;
        private final int typicalYears;
        
        DegreeType(String displayName, int typicalYears) {
            this.displayName = displayName;
            this.typicalYears = typicalYears;
        }
        
        public String getDisplayName() {
            return displayName;
        }
        
        public int getTypicalYears() {
            return typicalYears;
        }
    }
    
    // ========== OUTER CLASS METHODS ==========
    public void displayDepartmentInfo() {
        System.out.println("\n=== Department Info ===");
        System.out.println("Department: " + departmentName);
        System.out.println("Students: " + departmentStudents);
        System.out.println("University: " + universityName);
        
        // Can access static nested classes
        Statistics.displayStatistics();
    }
    
    public void graduateStudent(Student student) {
        System.out.println("\n" + student.getName() + " is graduating!");
        Statistics.recordGraduation();
        departmentStudents--;
    }
    
    // Static method in outer class
    public static void displayUniversityOverview() {
        System.out.println("\n=== University Overview ===");
        System.out.println("Name: " + universityName);
        System.out.println("Established: " + establishedYear);
        System.out.println("Total Students: " + totalStudents);
        
                // Can create instances of static nested class
        Student prospective = new Student("Prospective", "Undecided");
        System.out.println("Next available ID: " + Student.getNextStudentId());
    }
}

// ========== EXAMPLE OF COMPLETE UTILITY CLASS ==========
// Often used for organization and encapsulation
final class MathConstants {
    // Private constructor to prevent instantiation
    private MathConstants() {
        throw new AssertionError("Cannot instantiate utility class");
    }
    
    // Static nested class for geometric constants
    public static class Geometry {
        public static final double PI = 3.141592653589793;
        public static final double E = 2.718281828459045;
        public static final double GOLDEN_RATIO = 1.618033988749895;
        
        // Private constructor for nested static class too
        private Geometry() {}
    }
    
    // Static nested class for physics constants
    public static class Physics {
        public static final double GRAVITY = 9.80665;
        public static final double LIGHT_SPEED = 299792458;
        public static final double PLANCK = 6.62607015e-34;
        
        private Physics() {}
    }
    
    // Static nested class for conversion factors
    public static class Conversions {
        public static final double INCH_TO_CM = 2.54;
        public static final double POUND_TO_KG = 0.453592;
        public static final double MILE_TO_KM = 1.60934;
        
        private Conversions() {}
    }
}

// ========== BUILDER PATTERN WITH STATIC NESTED CLASS ==========
class Computer {
    private final String cpu;
    private final int ram;
    private final int storage;
    private final boolean hasGraphicsCard;
    private final String operatingSystem;
    
    // Private constructor
    private Computer(Builder builder) {
        this.cpu = builder.cpu;
        this.ram = builder.ram;
        this.storage = builder.storage;
        this.hasGraphicsCard = builder.hasGraphicsCard;
        this.operatingSystem = builder.operatingSystem;
    }
    
    // Static nested Builder class
    public static class Builder {
        // Required parameters
        private final String cpu;
        private final int ram;
        
        // Optional parameters - initialized to default values
        private int storage = 256;
        private boolean hasGraphicsCard = false;
        private String operatingSystem = "Windows 10";
        
        // Constructor for required fields
        public Builder(String cpu, int ram) {
            this.cpu = cpu;
            this.ram = ram;
        }
        
        // Setters for optional parameters (return Builder for chaining)
        public Builder storage(int storage) {
            this.storage = storage;
            return this;
        }
        
        public Builder graphicsCard(boolean hasGraphicsCard) {
            this.hasGraphicsCard = hasGraphicsCard;
            return this;
        }
        
        public Builder operatingSystem(String operatingSystem) {
            this.operatingSystem = operatingSystem;
            return this;
        }
        
        // Build method
        public Computer build() {
            return new Computer(this);
        }
    }
    
    // Getters
    public String getCpu() { return cpu; }
    public int getRam() { return ram; }
    public int getStorage() { return storage; }
    public boolean hasGraphicsCard() { return hasGraphicsCard; }
    public String getOperatingSystem() { return operatingSystem; }
    
    @Override
    public String toString() {
        return String.format("Computer[CPU: %s, RAM: %dGB, Storage: %dGB, GPU: %s, OS: %s]",
                cpu, ram, storage, hasGraphicsCard ? "Yes" : "No", operatingSystem);
    }
}

public class StaticClassesExample {
    public static void main(String[] args) {
        System.out.println("=== Static Classes & Nested Static Classes ===\n");
        
        System.out.println("1. Creating University departments:");
        University csDept = new University("Computer Science", 300);
        University engDept = new University("Engineering", 250);
        
        System.out.println("\n2. Creating Students (using static nested class):");
        // Note: Can create Student without University instance
        University.Student student1 = new University.Student("Alice", "Computer Science");
        University.Student student2 = new University.Student("Bob", "Engineering");
        University.Student student3 = new University.Student("Charlie", "Mathematics");
        
        student1.enroll();
        student2.enroll();
        student3.enroll();
        
        student1.updateGPA(3.8);
        student2.updateGPA(3.5);
        student3.updateGPA(3.9);
        
        System.out.println("\n3. Students accessing university info:");
        student1.displayUniversityInfo();
        
        System.out.println("\n4. Using static nested enum:");
        University.DegreeType bachelors = University.DegreeType.BACHELOR;
        University.DegreeType masters = University.DegreeType.MASTER;
        
        System.out.println(bachelors.getDisplayName() + " typically takes " + 
                         bachelors.getTypicalYears() + " years");
        System.out.println(masters.getDisplayName() + " typically takes " + 
                         masters.getTypicalYears() + " years");
        
        System.out.println("\n5. Department displaying info:");
        csDept.displayDepartmentInfo();
        
        System.out.println("\n6. University static method:");
        University.displayUniversityOverview();
        
        System.out.println("\n7. Using MathConstants utility class:");
        System.out.println("PI: " + MathConstants.Geometry.PI);
        System.out.println("Gravity: " + MathConstants.Physics.GRAVITY);
        System.out.println("Inch to CM: " + MathConstants.Conversions.INCH_TO_CM);
        
        // Try to instantiate (should be prevented by private constructor)
        // MathConstants constants = new MathConstants(); // COMPILE ERROR
        
        System.out.println("\n8. Builder pattern with static nested class:");
        Computer gamingPC = new Computer.Builder("Intel i9", 32)
                .storage(1000)
                .graphicsCard(true)
                .operatingSystem("Windows 11")
                .build();
        
        Computer officePC = new Computer.Builder("Intel i5", 16)
                .operatingSystem("Ubuntu 22.04")
                .build();
        
        System.out.println("Gaming PC: " + gamingPC);
        System.out.println("Office PC: " + officePC);
        
        System.out.println("\n=== Key Characteristics of Static Nested Classes ===");
        System.out.println("1. Can be instantiated without outer class instance");
        System.out.println("2. Can access outer class STATIC members directly");
        System.out.println("3. CANNOT access outer class INSTANCE members directly");
        System.out.println("4. Can be public, private, protected, or package-private");
        System.out.println("5. Can have static and instance members");
        System.out.println("6. Useful for logical grouping, encapsulation");
        System.out.println("7. Commonly used for Builder pattern, constants, utilities");
        
        System.out.println("\n=== When to Use Static Nested Classes ===");
        System.out.println("✅ Builder pattern implementation");
        System.out.println("✅ Constants organization (MathConstants.Geometry.PI)");
        System.out.println("✅ Utility classes within a class");
        System.out.println("✅ Node classes in data structures");
        System.out.println("✅ Related classes that don't need outer instance");
        System.out.println("✅ Enum definitions within a class");
        
        System.out.println("\n=== Memory Considerations ===");
        System.out.println("Static nested classes don't hold reference to outer instance");
        System.out.println("More memory efficient than non-static inner classes");
        System.out.println("Can be serialized independently");
    }
}