// 类表达式
let User = class {
  sayHi() {
    alert("Hello");
  }
};

// 返回类
function makeClass(phrase) {
  // 声明一个类并返回它
  return class {
    sayHi() {
      alert(phrase);
    };
  };
}

// 创建一个新的类
let User = makeClass("Hello");
// 使用关键字 new 实例化
new User().sayHi(); // Hello

// “命名类表达式（Named Class Expression）”
// (规范中没有这样的术语，但是它和命名函数表达式类似)
let User = class MyClass {
  sayHi() {
    alert(MyClass); // MyClass 这个名字仅在类内部可见
  }
};

new User().sayHi(); // 正常运行，显示 MyClass 中定义的内容

alert(MyClass); // error，MyClass 在外部不可见

class User {
  // 静态方法
  static staticMethod() {
    alert(this === User);
  }
}

User.staticMethod();   // true，直接访问静态方法

/*---------- 分割线 ----------*/
// 等价用法
// 类（函数对象）属性
User.staticMethod = function() {
  alert(this === User);
};

User.staticMethod(); // true

class Article {
  constructor(title, date) {
    this.title = title;
    this.date = date;
  }

  // 静态方法
  static createTodays() {
    // 记住 this = Article
    return new this("Today's digest", new Date());   // 返回该类的实例
  }
}

let article = Article.createTodays();
alert( article.title );   // Today's digest

class Article {
  static publisher = "Ben";
}

alert( Article.publisher );   // Ben

/*---------- 分割线 ----------*/
// 等价用法
Article.publisher = "Ben";

class CoffeeMachine {
  _waterAmount = 0;

  set waterAmount(value) {
    if (value < 0) throw new Error("Negative water");
    this._waterAmount = value;
  }

  get waterAmount() {
    return this._waterAmount;
  }

  constructor(power) {
    this._power = power;
  }

}

// 创建咖啡机
let coffeeMachine = new CoffeeMachine(100);

// 加水
coffeeMachine.waterAmount = -10; // Error: Negative water，通过 getter/setter 对内部的属性 _waterAmout 进行访问

class CoffeeMachine {
  #waterLimit = 200;

  #checkWater(value) {
    if (value < 0) throw new Error("Negative water");
    if (value > this.#waterLimit) throw new Error("Too much water");
  }

}

let coffeeMachine = new CoffeeMachine();

// 不能从类的外部访问类的私有属性和方法
coffeeMachine.#checkWater(); // Error
coffeeMachine.#waterLimit = 1000; // Error

// 父类构造函数
function Tree(size, leaves) {
  this.size = size || 10;
  this.leaves = leaves || {spring: 'green', summer: 'green', fall: 'orange', winter: null};
  this.leafColor;
}

// 父类的原型（方法容器）
Tree.prototype.changeSeason = function(season) {
  this.leafColor = this.leaves[season];
  if (season === 'spring') {
    this.size += 1;
  }
}

// 子类构造函数
function Maple (syrupQty, size, leaves) {
  Tree.call(this, size, leaves);   // 引用（继承）父类
  this.syrupQty = syrupQty || 15;   // 子类特有的属性
}

// 子类的原型（方法容器）继承自父类的原型
Maple.prototype = Object.create(Tree.prototype);
Maple.prototype.constructor = Maple;   // 重新设置原型的 constructor 属性，绑定会子类的构造函数

// 子类的原型添加特有的方法
Maple.prototype.changeSeason = function(season) {
  Tree.prototype.changeSeason.call(this, season);
  if (season === 'spring') {
    this.syrupQty += 1;
  }
}

Maple.prototype.gatherSyrup = function() {
  this.syrupQty -= 3;
}

// 实例化子类
let myMaple = new Maple(15, 5);
myMaple.changeSeason('fall');
myMaple.gatherSyrup();
myMaple.changeSeason('spring');

// 父类
class Animal {
  constructor(name) {
    this.speed = 0;
    this.name = name;
  }
  run(speed) {
    this.speed = speed;
    alert(`${this.name} runs with speed ${this.speed}.`);
  }
  stop() {
    this.speed = 0;
    alert(`${this.name} stands still.`);
  }
}

// 子类继承自父类
class Rabbit extends Animal {
  hide() {
    alert(`${this.name} hides!`);
  }
}

let rabbit = new Rabbit("White Rabbit");

rabbit.run(5); // White Rabbit runs with speed 5.
rabbit.hide(); // White Rabbit hides!

// 继承自原生类 Array 的子类 PowerArray
class PowerArray extends Array {
  // 给 PowerArray 新增了一个方法
  isEmpty() {
    return this.length === 0;
  }
}

// 实例化子类
let arr = new PowerArray(1, 2, 5, 10, 50);
alert(arr.isEmpty()); // false

let filteredArr = arr.filter(item => item >= 10);   // 具有父类（原生类）方法 filter，返回的对象是子类的一个实例
alert(filteredArr); // 10, 50
alert(filteredArr.isEmpty()); // false，返回的对象是子类的一个实例，因此可以调用子类特有的方法

obj instanceof Class

class Rabbit {}
let rabbit = new Rabbit();

// rabbit 是 Rabbit class 的对象吗？
alert( rabbit instanceof Rabbit ); // true

// mixin
let sayHiMixin = {
  sayHi() {
    alert(`Hello ${this.name}`);
  },
  sayBye() {
    alert(`Bye ${this.name}`);
  }
};

// 类
class User {
  constructor(name) {
    this.name = name;
  }
}

// 拷贝方法
Object.assign(User.prototype, sayHiMixin);   // 将 mixin 中多种方法添加到类（原型）中

// 现在 User 可以打招呼了
new User("Dude").sayHi(); // Hello Dude!

let sayMixin = {
  say(phrase) {
    alert(phrase);
  }
};

let sayHiMixin = {
  __proto__: sayMixin, // (或者，我们可以在这儿使用 Object.create 来设置原型)

  sayHi() {
    // 调用父类方法
    super.say(`Hello ${this.name}`); // (*)
  },
  sayBye() {
    super.say(`Bye ${this.name}`); // (*)
  }
};

class User {
  constructor(name) {
    this.name = name;
  }
}

// 拷贝方法
Object.assign(User.prototype, sayHiMixin);

// 现在 User 可以打招呼了
new User("Dude").sayHi(); // Hello Dude!