class类

hasOwnProperty查看自己本身有没有某个属性
p1.hasOwnProperty('name')
in查看原型链上有没有有某个属性
'name' in p1

class Person {
  // 实例属性
  name
  age
  //静态属性和方法：只能用类名调用
  static props='我是静态属性'
  static fn(){
    console.log('我是静态方法')
  }
  // 私有属性和方法：只能在类内部使用this调用
  #siyou='私有属性'
  #siyouFn(){
    console.log('我是私有方法')
  }
  // 静态私有属性和方法：只能在类内部使用类名调用
  static #staticSiyou='静态私有属性'
  static #staticSiyouFn(){
    console.log('我是静态私有方法')
  }
  // get和set
  #xingwei='行为：私有属性'
  get xingwei(){
    console.log('你在访问私有属性#xingwei')
    return this.#xingwei
  }
  set xingwei(val){
    console.log(`你在设置私有属性#xingwei，值为:${val}`)
    this.#xingwei=val
  }
  
  // 构造函数
  constructor(name,age){
    this.name=name
    this.age=age
    Person.prototype.publicName='publicNamezhao'
    this.techang=()=>{
      console.log('我是实例的特长')
    }
    // console.log(this.#siyou)
    // this.#siyouFn()
    // console.log(Person.#staticSiyou)
    // Person.#staticSiyouFn()
  }
  // 实例方法：定义在prototype上
  sayName(){
    console.log('我的名字是'+this.name)
  }
}
let p1 = new Person('zhao',18)
// p1.sayName()
// p1.techang()
// console.log(Person.props)
// Person.fn()
p1.xingwei
p1.xingwei='举止优雅'
/*
//默认：属性在实例对象上，方法在类的prototype原型对象上
//1、属性
//name
console.log(p1.name)//zhao
console.log(p1.hasOwnProperty('name'))//true
//publicName
console.log(p1.publicName)//publicNamezhao
console.log(p1.hasOwnProperty('publicName'))//false
console.log(p1.__proto__.hasOwnProperty('publicName'))//true
console.log(Person.prototype.hasOwnProperty('publicName'))//true
//2、方法
//sayName
console.log(p1.hasOwnProperty('sayName'))//false
console.log(Person.prototype.hasOwnProperty('sayName'))//true
//techang
console.log(p1.hasOwnProperty('techang'))//true
console.log(Person.prototype.hasOwnProperty('techang'))//false
*/
console.log(p1)

程序2

class Point{
  constructor(x,y){
    this.x=x
    this.y=y
  }
  toString(){
    console.log('我的名字是'+this.name)
  }
}
let p1=new Point(1,2)
let p2=new Point(3,4)
/*
//1、x和y都是实例对象p1自身的属性（因为定义在this对象上），所以hasOwnProperty()方法返回true，
//而toString()是原型对象的属性（因为定义在Point类上），所以hasOwnProperty()方法返回false
console.log(p1.hasOwnProperty('name'),p1.hasOwnProperty('toString'))//true,false
console.log(p1.__proto__.hasOwnProperty('name'),p1.__proto__.hasOwnProperty('toString'))//false,true
console.log(Point.prototype.hasOwnProperty('name'),Point.prototype.hasOwnProperty('toString'))//false,true
//2、类的所有实例共享一个原型对象。p1和p2都是Point的实例，它们的原型都是Point.prototype，所以__proto__属性是相等的
console.log(p1.__proto__===p2.__proto__===Point.prototype)//true
console.log(p1.__proto__===Point.prototype)//true
console.log(p2.__proto__===Point.prototype)//true
*/

方法bar前有static关键字，表明该方法是一个静态方法，可以直接在Foo类上调用（Foo.bar()），而不是在Foo类的实例上调用。如果在实例上调用静态方法，会抛出一个错误，表示不存在该方法。

注意，如果静态方法包含this关键字，这个this指的是类，而不是实例。
父类的静态方法，可以被子类继承。

class Foo {
  static bar() {
    this.baz();
  }
  static baz() {
    console.log('static baz');
  }
  baz() {
    console.log('baz');
  }
}

Foo.bar() // static baz

静态方法也是可以从super对象上调用的。

class Foo {
  static classMethod() {
    return 'hello';
  }
}

class Bar extends Foo {
  static classMethod() {
    return super.classMethod() + ', too';
  }
}

Bar.classMethod() // "hello, too"

继承的时候，子类调用父类并传参，可以用super关键字
super 除了在 constructor 里直接调用外还可以使用 super.xxx(…) 来调用父类上的某个原型方法，这同样是一种限定语法。

//父类
class Person{
  constructor(name){
    this.name=name
  }
  sayName(){
    console.log('我的名字是'+this.name)
  }
}

//子类
class Student extends Person{
  constructor(name,score){
    super(name)
    this.score=score
  }
  sayScore(){
    console.log('我的名字是：'+this.name+'我的成绩是：'+this.score)
  }
  sayNewName(){
    console.log('调用sayName'+super.sayName())
  }
}

//子类
class Teacher extends Person{
  constructor(name,subject){
    super(name)
    this.subject=subject
  }
  saySubject(){
    console.log('我的名字是：'+this.name+'我教的科目是：'+this.subject)
  }
}
let s1=new Student('sang',100)
let t1=new Teacher('zhao','yuwen')
s1.sayScore()
t1.saySubject()
s1.sayNewName()

console.log(s1,t1)

原型链，原型
函数都有prototype:{}属性
对象都有proto:{}属性
对象的proto存的是构造这个对象的函数的prototype属性
下面例子说明：
构造函数Test.prototype=实例对象t1. proto
Test.prototype.__proto=Object.prototype
Object.prototype.proro=null

function Test(){}
let t1=new Test()
t1.a=1
Test.prototype.b=2
Object.prototype.c=3
/*
t1{
  a=1
  __proto__ : Test.ptototype={
    b=2
    __proto__ : Object.prototype={
      c:3
    }
  }
}
*/

console.log(Test.__proto__===Function.prototype)
console.log(Function.__proto__===Function.prototype)

const obj=new Object()//function
console.log(typeof Object)
console.log(Object.__proto__===Function.prototype)
console.log(Object.__proto__===Function.__proto__)