JavaScriptのアクセス指定子を使ったオブジェクト指向プログラミング徹底解説

class Person {
    constructor(name, age) {
        this.name = name; // public
        this.age = age;   // public
    }

    greet() { // public method
        console.log(`Hello, my name is ${this.name} and I am ${this.age} years old.`);
    }
}

const john = new Person('John', 30);
console.log(john.name); // John
console.log(john.age);  // 30
john.greet(); // Hello, my name is John and I am 30 years old.

class Person {
    #name;  // private
    #age;   // private

    constructor(name, age) {
        this.#name = name;
        this.#age = age;
    }

    #calculateBirthYear() { // private method
        const currentYear = new Date().getFullYear();
        return currentYear - this.#age;
    }

    greet() { // public method
        console.log(`Hello, my name is ${this.#name} and I was born in ${this.#calculateBirthYear()}.`);
    }
}

const john = new Person('John', 30);
console.log(john.name); // undefined
console.log(john.age);  // undefined
john.greet(); // Hello, my name is John and I was born in 1994.

class Person {
    constructor(name, age) {
        this._name = name; // protected
        this._age = age;   // protected
    }

    greet() { // public method
        console.log(`Hello, my name is ${this._name} and I am ${this._age} years old.`);
    }
}

class Employee extends Person {
    constructor(name, age, jobTitle) {
        super(name, age);
        this._jobTitle = jobTitle; // protected
    }

    introduce() { // public method
        console.log(`Hello, my name is ${this._name}, I am ${this._age} years old, and I work as a ${this._jobTitle}.`);
    }
}

const jane = new Employee('Jane', 28, 'Software Engineer');
jane.greet(); // Hello, my name is Jane and I am 28 years old.
jane.introduce(); // Hello, my name is Jane, I am 28 years old, and I work as a Software Engineer.

class Car {
    constructor(make, model) {
        this.make = make;   // public
        this.model = model; // public
    }

    getDetails() { // public method
        return `${this.make} ${this.model}`;
    }
}

const myCar = new Car('Toyota', 'Corolla');
console.log(myCar.make);   // Toyota
console.log(myCar.model);  // Corolla
console.log(myCar.getDetails()); // Toyota Corolla

class BankAccount {
    #accountNumber;  // private
    #balance;        // private

    constructor(accountNumber, initialBalance) {
        this.#accountNumber = accountNumber;
        this.#balance = initialBalance;
    }

    deposit(amount) { // public method
        if (amount > 0) {
            this.#balance += amount;
        }
    }

    getBalance() { // public method
        return this.#balance;
    }
}

const myAccount = new BankAccount('123456789', 1000);
console.log(myAccount.#accountNumber); // SyntaxError: Private field '#accountNumber' must be declared in an enclosing class
console.log(myAccount.getBalance()); // 1000
myAccount.deposit(500);
console.log(myAccount.getBalance()); // 1500

class Employee {
    constructor(name, salary) {
        this._name = name;   // protected
        this._salary = salary; // protected
    }

    getDetails() { // public method
        return `${this._name} earns ${this._salary}`;
    }
}

class Manager extends Employee {
    constructor(name, salary, department) {
        super(name, salary);
        this._department = department; // protected
    }

    getDetails() { // overridden public method
        return `${this._name} manages the ${this._department} department and earns ${this._salary}`;
    }
}

const emp = new Employee('Alice', 50000);
console.log(emp.getDetails()); // Alice earns 50000

const mgr = new Manager('Bob', 80000, 'Engineering');
console.log(mgr.getDetails()); // Bob manages the Engineering department and earns 80000

class User {
    #password;  // private

    constructor(username, password) {
        this.username = username; // public
        this.#password = password;
    }

    checkPassword(inputPassword) { // public method
        return this.#password === inputPassword;
    }
}

const user = new User('Alice', 'secret');
console.log(user.username); // Alice
console.log(user.#password); // SyntaxError: Private field '#password' must be declared in an enclosing class
console.log(user.checkPassword('secret')); // true

class Account {
    constructor(accountNumber, balance) {
        this._accountNumber = accountNumber; // protected
        this._balance = balance; // protected
    }

    getBalance() { // public method
        return this._balance;
    }
}

class SavingsAccount extends Account {
    constructor(accountNumber, balance, interestRate) {
        super(accountNumber, balance);
        this._interestRate = interestRate; // protected
    }

    calculateInterest() { // public method
        return this._balance * this._interestRate;
    }
}

const savings = new SavingsAccount('123456', 1000, 0.05);
console.log(savings.getBalance()); // 1000
console.log(savings.calculateInterest()); // 50
console.log(savings._accountNumber); // '123456' (should not be accessed directly)

class UserAccount {
    #username;  // private
    #password;  // private

    constructor(username, password) {
        this.#username = username;
        this.#password = password;
    }

    getUsername() { // public method
        return this.#username;
    }

    checkPassword(password) { // public method
        return this.#password === password;
    }
}

const account = new UserAccount('Alice', 'password123');
console.log(account.getUsername()); // Alice
console.log(account.checkPassword('password123')); // true
console.log(account.#password); // SyntaxError: Private field '#password' must be declared in an enclosing class

class Person {
    _name;  // protected
    _age;   // protected

    constructor(name, age) {
        this._name = name;
        this._age = age;
    }

    getDetails() { // public method
        return `${this._name}, ${this._age} years old`;
    }
}

class Employee extends Person {
    #employeeId;  // private

    constructor(name, age, employeeId) {
        super(name, age);
        this.#employeeId = employeeId;
    }

    getEmployeeDetails() { // public method
        return `${this.getDetails()}, Employee ID: ${this.#employeeId}`;
    }
}

const employee = new Employee('Bob', 35, 'E12345');
console.log(employee.getDetails()); // Bob, 35 years old
console.log(employee.getEmployeeDetails()); // Bob, 35 years old, Employee ID: E12345
console.log(employee.#employeeId); // SyntaxError: Private field '#employeeId' must be declared in an enclosing class

class BankAccount {
    #accountNumber;  // private
    #balance;        // private
    _accountType;    // protected

    constructor(accountNumber, initialBalance, accountType) {
        this.#accountNumber = accountNumber;
        this.#balance = initialBalance;
        this._accountType = accountType;
    }

    deposit(amount) { // public method
        if (amount > 0) {
            this.#balance += amount;
        }
    }

    withdraw(amount) { // public method
        if (amount > 0 && amount <= this.#balance) {
            this.#balance -= amount;
        }
    }

    getBalance() { // public method
        return this.#balance;
    }

    getAccountType() { // public method
        return this._accountType;
    }
}

class SavingsAccount extends BankAccount {
    constructor(accountNumber, initialBalance) {
        super(accountNumber, initialBalance, 'Savings');
    }

    addInterest(rate) { // public method
        const interest = this.getBalance() * rate;
        this.deposit(interest);
    }
}

const savings = new SavingsAccount('987654321', 1000);
console.log(savings.getAccountType()); // Savings
savings.deposit(500);
console.log(savings.getBalance()); // 1500
savings.addInterest(0.05);
console.log(savings.getBalance()); // 1575

// math.js
export function add(a, b) {
    return a + b;
}

export function subtract(a, b) {
    return a - b;
}

const PI = 3.14159; // モジュール内部の定数（公開しない）

// app.js
import { add, subtract } from './math.js';

console.log(add(2, 3)); // 5
console.log(subtract(5, 2)); // 3

// user.js
class User {
    #username;  // private
    #password;  // private

    constructor(username, password) {
        this.#username = username;
        this.#password = password;
    }

    getUsername() { // public method
        return this.#username;
    }

    checkPassword(password) { // public method
        return this.#password === password;
    }
}

export default User;

// main.js
import User from './user.js';

const user = new User('Alice', 'password123');
console.log(user.getUsername()); // Alice
console.log(user.checkPassword('password123')); // true

// calculator.js
export class Calculator {
    add(a, b) {
        return a + b;
    }

    subtract(a, b) {
        return a - b;
    }
}

// calculator.test.js
import { Calculator } from './calculator.js';

const calculator = new Calculator();

console.assert(calculator.add(2, 3) === 5, 'Addition test failed');
console.assert(calculator.subtract(5, 2) === 3, 'Subtraction test failed');
console.log('All tests passed');

// bankAccount.js
export class BankAccount {
    #balance; // private

    constructor(initialBalance) {
        this.#balance = initialBalance;
    }

    deposit(amount) {
        if (amount > 0) {
            this.#balance += amount;
        }
    }

    withdraw(amount) {
        if (amount > 0 && amount <= this.#balance) {
            this.#balance -= amount;
        }
    }

    getBalance() {
        return this.#balance;
    }
}

// bankAccount.test.js
import { BankAccount } from './bankAccount.js';

const account = new BankAccount(1000);

console.assert(account.getBalance() === 1000, 'Initial balance test failed');
account.deposit(500);
console.assert(account.getBalance() === 1500, 'Deposit test failed');
account.withdraw(200);
console.assert(account.getBalance() === 1300, 'Withdrawal test failed');
console.log('All tests passed');

// employee.js
export class Employee {
    constructor(name, salary) {
        this._name = name; // protected
        this._salary = salary; // protected
    }

    getSalary() {
        return this._salary;
    }
}

// employee.test.js
import { Employee } from './employee.js';

const employee = new Employee('John', 50000);

console.assert(employee.getSalary() === 50000, 'Salary test failed');
console.log('All tests passed');

// user.js
class User {
    #username;  // private
    #password;  // private

    constructor(username, password) {
        this.#username = username;
        this.#password = password;
    }

    getUsername() { // public method
        return this.#username;
    }

    checkPassword(password) { // public method
        return this.#password === password;
    }
}

export default User;

// テスト専用のエクスポート
export const _testUser = User;

// user.test.js
import { _testUser as User } from './user.js';

const user = new User('Alice', 'password123');

console.assert(user.getUsername() === 'Alice', 'Username test failed');
console.assert(user.checkPassword('password123') === true, 'Password test failed');
console.log('All tests passed');

// bankAccount.js
export class BankAccount {
    #accountNumber;  // private
    #balance;        // private

    constructor(accountNumber, initialBalance) {
        this.#accountNumber = accountNumber;
        this.#balance = initialBalance;
    }

    deposit(amount) {
        if (amount > 0) {
            this.#balance += amount;
        }
    }

    withdraw(amount) {
        if (amount > 0 && amount <= this.#balance) {
            this.#balance -= amount;
        }
    }

    getBalance() {
        return this.#balance;
    }

    getAccountNumber() {
        return this.#accountNumber;
    }
}

// savingsAccount.js
import { BankAccount } from './bankAccount.js';

export class SavingsAccount extends BankAccount {
    _interestRate;  // protected

    constructor(accountNumber, initialBalance, interestRate) {
        super(accountNumber, initialBalance);
        this._interestRate = interestRate;
    }

    addInterest() {
        const interest = this.getBalance() * this._interestRate;
        this.deposit(interest);
    }
}

// bank.js
import { BankAccount } from './bankAccount.js';
import { SavingsAccount } from './savingsAccount.js';

export class Bank {
    constructor() {
        this.accounts = [];
    }

    addAccount(account) {
        this.accounts.push(account);
    }

    getAccount(accountNumber) {
        return this.accounts.find(account => account.getAccountNumber() === accountNumber);
    }

    getTotalBalance() {
        return this.accounts.reduce((total, account) => total + account.getBalance(), 0);
    }
}

// bank.test.js
import { BankAccount } from './bankAccount.js';
import { SavingsAccount } from './savingsAccount.js';
import { Bank } from './bank.js';

// BankAccountのテスト
const account = new BankAccount('001', 1000);
console.assert(account.getBalance() === 1000, 'Initial balance test failed');
account.deposit(500);
console.assert(account.getBalance() === 1500, 'Deposit test failed');
account.withdraw(200);
console.assert(account.getBalance() === 1300, 'Withdrawal test failed');

// SavingsAccountのテスト
const savings = new SavingsAccount('002', 2000, 0.05);
console.assert(savings.getBalance() === 2000, 'Initial balance test failed');
savings.addInterest();
console.assert(savings.getBalance() === 2100, 'Interest test failed');

// Bankのテスト
const bank = new Bank();
bank.addAccount(account);
bank.addAccount(savings);
console.assert(bank.getTotalBalance() === 3400, 'Total balance test failed');

console.log('All tests passed');