Java Access Modifiers—Public Field Allows Negative Balances

// This file demonstrates all four access modifiers in one place.
// Run this as a single file (Java 11+) or create the classes in separate files.

// A public class — visible to everyone, everywhere
public class AccessModifierDemo {

    // public field — any code in the entire project can read/change this
    public String brandName = "TheCodeForge";

    // protected field — accessible in this class, same package, and subclasses
    protected int articleCount = 42;

    // default (no keyword) field — only accessible within the same package
    String internalCategory = "Java Basics"; // no modifier = package-private

    // private field — ONLY this class can read or change this value
    private String editorPassword = "s3cr3tP@ss";

    // public method — anyone can call this
    public void showBrandName() {
        // This method is the 'front door' — safe to expose publicly
        System.out.println("Brand: " + brandName);
    }

    // private method — internal helper, no outside class should call this
    private String encryptPassword(String rawPassword) {
        // Hiding the implementation detail — callers don't need to know HOW
        return "[ENCRYPTED]" + rawPassword.hashCode();
    }

    // public method that uses the private method internally
    public void printEncryptedPassword() {
        // We expose a safe action publicly, but keep the logic private
        System.out.println("Encrypted: " + encryptPassword(editorPassword));
    }

    public static void main(String[] args) {
        AccessModifierDemo demo = new AccessModifierDemo();

        // Accessing public field directly — perfectly fine
        System.out.println("Public field: " + demo.brandName);

        // Accessing protected field from within the SAME class — fine
        System.out.println("Protected field: " + demo.articleCount);

        // Accessing default field from within the SAME package — fine
        System.out.println("Default field: " + demo.internalCategory);

        // Accessing private field from within the SAME class — fine
        System.out.println("Private field: " + demo.editorPassword);

        // Calling public method — fine from anywhere
        demo.showBrandName();

        // Calling public method that internally uses a private method
        demo.printEncryptedPassword();

        // NOTE: If you tried to call demo.encryptPassword() from OUTSIDE
        // this class, the compiler would throw an error. Try it and see!
    }
}

public class BankAccount {

    // private — no outside class can directly read or write the balance
    // This is the single most important use of 'private' you'll encounter
    private double balance;

    // private — internal account identifier, nobody outside needs this raw
    private String accountNumber;

    // public constructor — anyone who wants to create an account can do so
    public BankAccount(String accountNumber, double openingBalance) {
        this.accountNumber = accountNumber;

        // Validate even at construction time — private data, our rules
        if (openingBalance < 0) {
            throw new IllegalArgumentException("Opening balance cannot be negative.");
        }
        this.balance = openingBalance;
    }

    // public getter — allows READ access to balance, but not direct WRITE access
    public double getBalance() {
        return balance; // we return a copy of the value, not the field itself
    }

    // public method to deposit money — enforces our business rules
    public void deposit(double amount) {
        if (amount <= 0) {
            System.out.println("Deposit amount must be positive. Ignoring.");
            return;
        }
        balance += amount; // only THIS class modifies balance directly
        System.out.println("Deposited £" + amount + ". New balance: £" + balance);
    }

    // public method to withdraw money — enforces our business rules
    public void withdraw(double amount) {
        if (amount <= 0) {
            System.out.println("Withdrawal amount must be positive. Ignoring.");
            return;
        }
        if (amount > balance) {
            // private data lets us protect this logic completely
            System.out.println("Insufficient funds. Balance is only £" + balance);
            return;
        }
        balance -= amount;
        System.out.println("Withdrew £" + amount + ". New balance: £" + balance);
    }

    // private helper — only used internally, no outside class needs to know this exists
    private boolean isHighValueAccount() {
        return balance > 10000;
    }

    // public method that uses the private helper — safe, controlled exposure
    public void printAccountSummary() {
        System.out.println("Account: " + accountNumber);
        System.out.println("Balance: £" + balance);
        System.out.println("High-value account: " + isHighValueAccount());
    }

    public static void main(String[] args) {
        BankAccount myAccount = new BankAccount("ACC-00192", 500.00);

        // Reading balance through the public getter — correct approach
        System.out.println("Initial balance: £" + myAccount.getBalance());

        myAccount.deposit(250.00);
        myAccount.withdraw(100.00);
        myAccount.withdraw(800.00); // should fail — insufficient funds

        System.out.println();
        myAccount.printAccountSummary();

        // The line below would cause a COMPILE ERROR if you uncommented it:
        // myAccount.balance = 999999; // ERROR: balance has private access in BankAccount
        // myAccount.isHighValueAccount(); // ERROR: isHighValueAccount() has private access
    }
}

// === FILE 1: Vehicle.java (in package: com.codeforge.vehicles) ===
// Imagine this is in: com/codeforge/vehicles/Vehicle.java

package com.codeforge.vehicles;

public class Vehicle {

    // public — any class anywhere can read the brand
    public String brand;

    // protected — this class AND any subclass (even in other packages) can access this
    // It's the parent sharing something specifically with its children
    protected int engineCapacityCC;

    // default (no modifier) — only classes in com.codeforge.vehicles can see this
    String factoryLocation; // package-private

    // private — only Vehicle itself can touch this
    private String internalSerialCode;

    public Vehicle(String brand, int engineCapacityCC, String factoryLocation, String internalSerialCode) {
        this.brand = brand;
        this.engineCapacityCC = engineCapacityCC;
        this.factoryLocation = factoryLocation;
        this.internalSerialCode = internalSerialCode;
    }

    // protected method — subclasses can call and even override this
    protected String getEngineDescription() {
        return brand + " engine: " + engineCapacityCC + "cc";
    }

    // public method — the 'front door' for external callers
    public void displayInfo() {
        System.out.println("Brand: " + brand);
        System.out.println("Engine: " + engineCapacityCC + "cc");
        System.out.println("Factory: " + factoryLocation);
        // Internal serial code stays private — even displayInfo() is careful about it
        System.out.println("Serial: [RESTRICTED]");
    }
}


// === FILE 2: ElectricCar.java (in package: com.codeforge.electric) ===
// A DIFFERENT package — notice it can still access the protected member
// Imagine this is in: com/codeforge/electric/ElectricCar.java

package com.codeforge.electric;

import com.codeforge.vehicles.Vehicle; // importing the parent class

public class ElectricCar extends Vehicle { // 'extends' means ElectricCar is a subclass of Vehicle

    private int batteryRangeKm;

    public ElectricCar(String brand, int batteryRangeKm) {
        // Calling the parent constructor — electric cars have near-zero CC engine
        super(brand, 0, "Tesla Gigafactory", "EV-" + brand + "-001");
        this.batteryRangeKm = batteryRangeKm;
    }

    @Override
    protected String getEngineDescription() {
        // Subclass CAN access engineCapacityCC because it's protected
        // Even though ElectricCar is in a DIFFERENT package, inheritance allows this
        return brand + " electric motor (no CC), range: " + batteryRangeKm + "km";
    }

    public void showElectricInfo() {
        // We can call the protected method because we're a subclass
        System.out.println(getEngineDescription());

        // We can access protected field engineCapacityCC directly
        System.out.println("Engine CC (should be 0 for EV): " + engineCapacityCC);

        // We CANNOT access factoryLocation here — it's default/package-private
        // and ElectricCar is in a DIFFERENT package. Uncommenting this would fail:
        // System.out.println(factoryLocation); // COMPILE ERROR
    }
}


// === FILE 3: Main.java (in package: com.codeforge.electric) ===

package com.codeforge.electric;

public class Main {
    public static void main(String[] args) {
        ElectricCar tesla = new ElectricCar("Tesla Model 3", 560);

        // Public method — accessible from anywhere
        tesla.displayInfo();

        System.out.println();

        // Calling the subclass-specific method
        tesla.showElectricInfo();

        // Accessing public field directly — fine
        System.out.println("\nBrand directly: " + tesla.brand);

        // From OUTSIDE the class hierarchy, protected members are NOT accessible:
        // System.out.println(tesla.engineCapacityCC); // COMPILE ERROR from here
    }
}

// This file demonstrates access modifiers applied at the CLASS level
// A single .java file can have only ONE public class
// The filename must match: ClassAccessModifierDemo.java

public class ClassAccessModifierDemo {

    // private inner class — completely hidden from outside
    // Only ClassAccessModifierDemo can create or use a Node
    // This is a common pattern in data structures (LinkedList nodes, tree nodes, etc.)
    private class Node {
        int value;
        Node nextNode; // points to the next node in a chain

        Node(int value) {
            this.value = value;
            this.nextNode = null;
        }
    }

    // public inner class — anyone can use this if they have a ClassAccessModifierDemo instance
    public class Statistics {
        private int totalNodes;

        public Statistics(int totalNodes) {
            this.totalNodes = totalNodes;
        }

        public void printStats() {
            System.out.println("Total nodes in chain: " + totalNodes);
        }
    }

    // The outer class uses its private inner class freely
    private Node firstNode;
    private int nodeCount;

    // public method — builds an internal chain using private Node objects
    public void addValue(int value) {
        Node newNode = new Node(value); // Node is private, but we're inside the owner class

        if (firstNode == null) {
            firstNode = newNode;
        } else {
            // Walk to the end of the chain
            Node currentNode = firstNode;
            while (currentNode.nextNode != null) {
                currentNode = currentNode.nextNode;
            }
            currentNode.nextNode = newNode; // attach the new node at the end
        }
        nodeCount++;
    }

    // public method — lets outsiders read values without knowing Node exists
    public void printAllValues() {
        System.out.print("Chain: ");
        Node currentNode = firstNode;
        while (currentNode != null) {
            System.out.print(currentNode.value);
            if (currentNode.nextNode != null) System.out.print(" -> ");
            currentNode = currentNode.nextNode;
        }
        System.out.println();
    }

    public Statistics getStatistics() {
        return new Statistics(nodeCount); // returns a public inner class instance
    }

    public static void main(String[] args) {
        ClassAccessModifierDemo chain = new ClassAccessModifierDemo();

        chain.addValue(10);
        chain.addValue(25);
        chain.addValue(37);

        chain.printAllValues();

        Statistics stats = chain.getStatistics();
        stats.printStats();

        // The line below would cause a COMPILE ERROR:
        // ClassAccessModifierDemo.Node n = new ClassAccessModifierDemo.Node(5);
        // ERROR: Node has private access in ClassAccessModifierDemo
    }
}

package com.thecodeforge.internal;

public class UserService {
    String calculateHash(String raw) { // default access — hidden trap
        return raw.hashCode() + "";
    }
}

class RogueService {
    public void exploit() {
        UserService svc = new UserService();
        String hash = svc.calculateHash("password123"); // access granted!
        System.out.println(hash);
    }
}

package com.thecodeforge.base;

public class TemplateProcessor {
    protected void preProcess() {  // intended for subclasses
        System.out.println("Template: pre-processing...");
    }

    public final void execute() {
        preProcess();
        System.out.println("Template: processing...");
    }
}

// Subclass in a different package:
package com.thecodeforge.extensions;

import com.thecodeforge.base.TemplateProcessor;

public class CustomProcessor extends TemplateProcessor {
    @Override
    protected void preProcess() {
        System.out.println("Custom: extended pre-processing!");
    }
}

public class Main {
    public static void main(String[] args) {
        new CustomProcessor().execute();
    }
}

// Valid top-level classes:
package com.thecodeforge.model;

public class PublicClass { }         // Accessible everywhere

class PackagePrivateClass { }        // Only in this package

// Invalid — won't compile:
// protected class ProtectedClass { }
// private class PrivateClass { }

// Valid nested classes:
public class OuterClass {
    protected class NestedProtected { }  // OK — nested
    private class NestedPrivate { }      // OK — nested
}