js 类的封装

class CoffeeMachine {
  constructor(power) {
    this._power = power; // _power 是一个“私有”属性
  }

  _heat() { // _heat 是一个“私有”方法
    console.log('Heating water...');
  }

  makeCoffee() {
    this._heat();
    console.log('Coffee is ready!');
  }
}

let coffeeMachine = new CoffeeMachine(100);
coffeeMachine.makeCoffee(); // 正确使用公有方法

// 尽管不推荐，但从外部依然可以访问
console.log(coffeeMachine._power); // 输出: 100
coffeeMachine._heat();             // 输出: 'Heating water...'

class CoffeeMachine {
  #waterLimit = 200; // 私有字段

  #checkWater() { // 私有方法
    if (this.#waterLimit < 50) {
      console.log('Water level is too low!');
      return false;
    }
    return true;
  }

  makeCoffee() {
    if (this.#checkWater()) {
      console.log('Making coffee...');
      this.#waterLimit -= 50;
    }
  }
}

let machine = new CoffeeMachine();
machine.makeCoffee(); // 输出: 'Making coffee...'

// 尝试从外部访问会报错
// console.log(machine.#waterLimit); // 抛出 SyntaxError
// machine.#checkWater();           // 抛出 SyntaxError

class Machine {
  constructor(name) {
    this._name = name; // “受保护”的属性
  }

  _start() { // “受保护”的方法
    console.log(`${this._name} is starting...`);
  }
}

class CoffeeMachine extends Machine {
  makeCoffee() {
    // 可以在子类中访问父类的“受保护”成员
    this._start();
    console.log('Coffee is brewing.');
  }
}

let coffeeMachine = new CoffeeMachine('My Coffee Machine');
coffeeMachine.makeCoffee();
// 输出:
// My Coffee Machine is starting...
// Coffee is brewing.

// 同样的，这种方式并不能阻止外部访问
console.log(coffeeMachine._name); // 输出: 'My Coffee Machine'

class User {
  // 错误示范！会造成无限递归
  set name(value) {
    this.name = value; // 这里调用了 set name()，导致无限循环
  }
}

class User {
  constructor(name) {
    // _name 是实际存储数据的后端字段
    this._name = name;
  }

  // Getter: 用于读取属性
  // 当你访问 user.name 时，这个方法会被调用
  get name() {
    console.log('正在读取 name...');
    return this._name;
  }

  // Setter: 用于写入属性
  // 当你执行 user.name = 'new value' 时，这个方法会被调用
  set name(value) {
    console.log('正在写入 name...');
    if (value && value.length > 0) {
      this._name = value; // 验证通过后，更新后端字段
    } else {
      console.error('名字不能为空！');
    }
  }
}

let user = new User('Alice');

// 读取属性（触发 getter）
console.log(user.name);
// 输出:
// 正在读取 name...
// Alice

// 写入属性（触发 setter）
user.name = 'Bob';
console.log(user.name);
// 输出:
// 正在写入 name...
// 正在读取 name...
// Bob

// 尝试写入无效值（触发 setter 的验证逻辑）
user.name = '';
console.log(user.name);
// 输出:
// 正在写入 name...
// 名字不能为空！
// 正在读取 name...
// Bob (值没有被改变)

class SecureUser {
  // #name 是一个真正的私有字段，作为后端存储
  #name;

  constructor(name) {
    // 在构造函数内部，可以通过 this.#name 访问
    this.#name = name;
  }

  // 公共的 getter，用于读取 #name
  get name() {
    return this.#name;
  }

  // 公共的 setter，用于验证并写入 #name
  set name(value) {
    if (value && value.trim().length > 0) {
      this.#name = value;
    } else {
      console.error('名字不能为空！');
    }
  }
}

let secureUser = new SecureUser('Charlie');

// 读取，通过公共 getter
console.log(secureUser.name); // 输出: Charlie

// 写入，通过公共 setter
secureUser.name = 'David';
console.log(secureUser.name); // 输出: David

// 尝试从外部直接访问私有字段，会报错
// console.log(secureUser.#name); // SyntaxError: Private field '#name' must be declared in an enclosing class

class Circle {
  #radius;

  constructor(radius) {
    this.#radius = radius;
  }

  // area 是一个只读的计算属性
  get area() {
    return Math.PI * this.#radius * this.#radius;
  }
}

const c = new Circle(10);
console.log(c.area); // 输出: 314.159...

// 尝试写入只读属性
c.area = 100; // 在非严格模式下，这个操作会被静默忽略；在严格模式下会报错。
console.log(c.area); // 仍然输出 314.159...

class TemporaryPassword {
    #password;

    // 只写
    set password(p) {
        if(p.length >= 8) {
            this.#password = `hashed_${p}`;
            console.log('密码已设置（并已哈希处理）');
        } else {
            console.log('密码太短');
        }
    }
}

let pwd = new TemporaryPassword();
pwd.password = 'mysecret123'; // 输出: 密码已设置（并已哈希处理）

// 尝试读取，会返回 undefined，因为没有 getter
console.log(pwd.password); // 输出: undefined