Access Modifiers

BankAccount acc = new BankAccount(); acc.balance = -999999; // Nothing prevents this!

// WITH access control — safe class BankAccount { private double balance; // Only this class can modify it

public void deposit(double amount) { if (amount > 0) { // Validation enforced balance += amount; } } }

public class CreditCard { private String cardNumber; // Only this class can see this private double creditLimit; private double currentBalance;

public CreditCard(String number, double limit) { this.cardNumber = number; this.creditLimit = limit; this.currentBalance = 0; }

// Private helper — internal logic private boolean hasAvailableCredit(double amount) { return (currentBalance + amount) <= creditLimit; }

// Public interface — controlled access public boolean charge(double amount) { if (amount <= 0) return false; if (!hasAvailableCredit(amount)) return false; currentBalance += amount; return true; }

public String getMaskedNumber() { // Only shows last 4 digits return "**--**-" + cardNumber.substring(cardNumber.length() - 4); } }

public class Vehicle { protected int speed; // Subclasses need this protected String fuelType; private String vinNumber; // Even subclasses shouldn't access this

protected void accelerate(int amount) { speed += amount; if (speed > getMaxSpeed()) { speed = getMaxSpeed(); } }

protected int getMaxSpeed() { return 100; // Default max speed } }

public class SportsCar extends Vehicle { public void turboBoost() { accelerate(50); // Can access protected method System.out.println("Speed: " + speed); // Can access protected field // System.out.println(vinNumber); // ERROR! Can't access private }

@Override protected int getMaxSpeed() { return 250; // Sports cars go faster } }

public class Calculator { // Public methods — the interface other code uses public double add(double a, double b) { return a + b; } public double subtract(double a, double b) { return a - b; } public double multiply(double a, double b) { return a * b; }

public double divide(double a, double b) { if (b == 0) throw new ArithmeticException("Cannot divide by zero"); return a / b; } }

class Employee { private: // Section starts here std::string ssn; // Very sensitive double salary;

void calculateTax() { // Internal helper // ... }

protected: // Section starts here std::string department; int employeeId;

void transferDepartment(std::string newDept) { department = newDept; }

public: // Section starts here std::string name;

Employee(std::string name, int id, double salary) : name(name), employeeId(id), salary(salary) {}

void displayInfo() const { std::cout << name << " (ID: " << employeeId << ")" << std::endl; // Can access private members here }

double getSalary() const { return salary; } };

class Account: def __init__(self, owner, balance): self.owner = owner # Public — no underscore self._transaction_log = [] # Protected — single underscore (convention) self.__balance = balance # Private — double underscore (name mangling)

def deposit(self, amount): """Public method""" if amount > 0: self.__balance += amount self._log_transaction(f"Deposit: +${amount}")

def _log_transaction(self, message): """Protected method — subclasses can use, but outsiders shouldn't""" self._transaction_log.append(message)

def __validate_amount(self, amount): """Private method — only this class should use""" return amount > 0

acc = Account("Alice", 1000) print(acc.owner) # Works — public print(acc._transaction_log) # Works but discouraged — protected by convention

print(acc.__balance) # AttributeError! Name mangling applied

print(acc._Account__balance) # Works but VERY bad practice

public class ShoppingCart { // Private: internal implementation private List<Item> items = new ArrayList<>(); private double taxRate = 0.08;

// Private: helper methods private double calculateSubtotal() { return items.stream().mapToDouble(Item::getPrice).sum(); }

// Public: the interface users need public void addItem(Item item) { items.add(item); }

public void removeItem(Item item) { items.remove(item); }

public double getTotal() { double subtotal = calculateSubtotal(); return subtotal + (subtotal * taxRate); }

public int getItemCount() { return items.size(); } }