class Employee {
  // Private fields (using # syntax)
  #salary;
  #ssn;

  constructor(name, salary, ssn) {
    this.name = name;       // Public
    this.#salary = salary;  // Private
    this.#ssn = ssn;        // Private
  }

  // Public getter
  getSalary() {
    return this.#salary;
  }

  // Public setter with validation
  setSalary(amount) {
    if (amount >= 0) {
      this.#salary = amount;
    } else {
      throw new Error("Salary cannot be negative");
    }
  }

  // Private method
  #validateSSN() {
    return /^\d{3}-\d{2}-\d{4}$/.test(this.#ssn);
  }
}

const emp = new Employee("Alice", 75000, "123-45-6789");
console.log(emp.name);            // "Alice"
// console.log(emp.#salary);      // ❌ SyntaxError
console.log(emp.getSalary());     // 75000
emp.setSalary(80000);

function createCounter() {
  let count = 0; // Private via closure

  return {
    increment() {
      count++;
    },
    decrement() {
      count--;
    },
    getCount() {
      return count;
    }
  };
}

const counter = createCounter();
counter.increment();
counter.increment();
console.log(counter.getCount()); // 2
// console.log(counter.count);   // undefined — private

class Database {
  private connectionString: string;
  private isConnected: boolean = false;

  constructor(connectionString: string) {
    this.connectionString = connectionString;
  }

  // Public interface
  async connect(): Promise<void> {
    if (!this.isConnected) {
      await this.#establishConnection();
      this.isConnected = true;
    }
  }

  async disconnect(): Promise<void> {
    if (this.isConnected) {
      await this.#closeConnection();
      this.isConnected = false;
    }
  }

  // Private implementation
  private async #establishConnection(): Promise<void> {
    // Complex connection logic
  }

  private async #closeConnection(): Promise<void> {
    // Cleanup logic
  }
}

const db = new Database("postgres://localhost:5432/mydb");
await db.connect();
// db.isConnected; // ❌ Error: private

class Temperature:
    def __init__(self, celsius: float = 0):
        self.__celsius = celsius  # Name mangling (private-like)

    # Property getter
    @property
    def celsius(self) -> float:
        return self.__celsius

    # Property setter with validation
    @celsius.setter
    def celsius(self, value: float):
        if value < -273.15:
            raise ValueError("Temperature below absolute zero!")
        self.__celsius = value

    @property
    def fahrenheit(self) -> float:
        return (self.__celsius * 9/5) + 32

# Usage
temp = Temperature(25)
print(temp.celsius)      # 25 (uses getter)
temp.celsius = 30        # Uses setter with validation
# temp.celsius = -300    # ❌ ValueError!
# print(temp.__celsius)  # ❌ AttributeError (name mangling)

public class User {
    private String email;
    private String password;
    private boolean isActive;

    public User(String email) {
        this.email = email;
        this.isActive = true;
    }

    // Getter
    public String getEmail() {
        return email;
    }

    // Setter with validation
    public void setEmail(String email) {
        if (email != null && email.contains("@")) {
            this.email = email;
        } else {
            throw new IllegalArgumentException("Invalid email");
        }
    }

    // No getter for password — only verification
    public boolean verifyPassword(String input) {
        return this.password.equals(hash(input));
    }

    // Private helper
    private String hash(String input) {
        return input; // Actual hashing would happen here
    }
}