静态变量

# 静态变量

// 只有类才可以调用,实例无法调用
function Phone() {}
Phone.name = "手机";
Phone.change = function () {
  console.log("我可以改变世界");
};
Phone.prototype.size = "5.5inch";

let nokia = new Phone();

console.log(nokia.name); // 报错,实例无法访问静态变量
nokia.change(); // 报错
console.log(nokia.size); // 没问题

class Phone {
  //静态属性
  static name = "手机";
  static change() {
    console.log("我可以改变世界");
  }
}

# ES5 实现继承

function Phone(brand, price) {
  this.brand = brand;
  this.price = price;
}

Phone.prototype.call = function () {
  console.log("我可以打电话");
};

function SmartPhone(brand, price, color, size) {
  Phone.call(this, brand, price);
  this.color = color;
  this.size = size;
}
SmartPhone.prototype = new Phone();
// 这里做一步矫正,不做也可以
SmartPhone.prototype.constructor = SmartPhone;

// 声名子类的方法
SmartPhone.prototype.photo = function () {
  console.log("我可以拍照");
};

const chuizi = new SmartPhone("锤子", 2499, "黑色", "5.5inch");

# ES6 实现继承

class SmartPhone extends Phone {
  constructor(brand, price, color, size) {
    super(brand, price);
    this.color = color;
    this.size = size;
  }

  photo() {
    console.log("拍照");
  }

  // 重写父类call方法
  call() {
    console.log("我可以进行视频通话");
  }
}

# get 和 set

class Phone{
  this._price = 0
  get price(){
    console.log('价格属性被读取了')
    return this._price
  }

  // set方法必须有一个参数
  set price(newVal){
    console.log('价格属性被修改了')
    this._price = newVal
  }
}

let s = new Phone()
console.log(s.price)
s.price = 1

# 私有属性

class Person {
  // 公有属性
  name;
  // 私有属性,只能在类内部使用
  #age;
  #weight;
  constructor(name, age, weight) {
    this.name = name;
    this.#age = age;
    this.#weight = weight;
  }

  intro() {
    console.log(this.name);
    console.log(this.#age);
    console.log(this.#weight);
  }
}

const girl = new Person("xiaohong", 18, "45kg");

console.log(girl.name);
console.log(girl.#age); // 报错,无法访问
console.log(girl.#weight); // 报错

girl.intro(); // 可以访问

# 严格模式

  1. 类内部开启了严格模式

  2. 其它东西引用他的方法,this 也不是 window,只会是 undefined