<script>
    // 定義人類
    function People(name,age){
        this.name = name
        this.age = age
    }
    // 添加方法
    People.prototype.say = function (){
        console.log('hello world');
    }
    // 實例化方法
    let person = new People('張三',18)
    person.say()//hello world
    console.log(person);//People {name: '張三', age: 18}
</script>

<script>
    // class
    class People {
        // 構造方法 名字是固定格式不能修改
        constructor(name,age){
            this.name = name
            this.age = age
        }
        // 方法必須使用該語法，不能使用 ES5 的對象完整形式
        say(){
            console.log('hello world');
        }
    }
    // 實例化對象
    let person = new People('張三',18)
    person.say()//hello world
    console.log(person);//People {name: '張三', age: 18}
</script>

<script>
    class People {
        get name(){
            console.log('我是張三');
            return '這是我的名字'//如果不寫return，默認是undefined
        }
        set name(Name){//形參必須有
            console.log('我的名字被修改了');
        }
    }
    // 實例化對象
    let p = new People()
    // 只要讀取 p 的實例化屬性，就會執(zhí)行 get 關鍵字函數里面代碼，而且這個函數的返回值就是屬性的一個值
    console.log(p.name);
    // 只要對 name 屬性進行一個修改，如果有set關鍵字函數，就會執(zhí)行該函數
    p.name = 'f'
</script>

<script>
    const myClass = class Me {
        getClass(){
            return Me.name//返回類名
        }
    }
    let c = new myClass()
    console.log(c.getClass())//Me
    Me.name//Me is not defined 
    // 如果類的內部沒用到的話，可以省略Me，也就是可以寫成下面的形式
    const MyClass = class {};
</script>

<script>
    function People(){
    }
    // 函數屬性和方法
    People.name = '張三'
    People.say = function(){
        console.log('hello world');
    }
    // 原型對象屬性和方法
    People.prototype.age = 18
    // 實例化對象
    let p = new People()
    console.log(People.name,People.say());
    console.log(p.age);
    console.log(p.name,p.say());
</script>

<script>
    class People {
        // 靜態(tài)屬性
        static name = '張三'
        static say(){
            console.log('hello world');
        }
    }
    let p = new People()
    console.log(p.name);//undefined
    console.log(People.name);//張三
</script>

<script>
    class person {
        // 私有屬性
        #name
        constructor(name){
            this.#name = name
        }
        // 私有方法
        #sayName(){
            return this.#name
        }
        result(){
            console.log(this.#name);
        }
    }
    let p = new person()
    p.result = '張三'
    console.log(p);//person {result: '張三', #sayName: ?, #name: undefined}
    p.#name//報錯
</script>

<script>
    class A {
        #foo = 0;
        m() {
            console.log(#foo in this); // true
            console.log(#bar in this); // Private field '#bar' must be declared in an enclosing class(提示我們：私有字段“#bar”必須在封閉類中聲明)
        }
    }
    let a = new A()
    a.m()
</script>

<script>
    // 動物
    function Animals(name,age){
        this.name = name
        this.age = age
    }
    Animals.prototype.call = function(){
        console.log('我是動物');
    }
    // 狗
    function Dog(name,age,color,gender){
        // 改變this的指向，繼承父類
        Animals.call(this,name,age)
        this.color = color
        this.gender = gender
    }
    // 設置子類構造函數的原型
    Dog.prototype = new Animals //此時子類的實例對象就會繼承父類上面的方法
    Dog.prototype.constructor = Dog
 
    // 聲明子類的方法
    Dog.prototype.say = function(){
        console.log('汪汪汪?。?！');
    }
    // 子類對象進行實例化
    const d = new Dog('小明',3,'棕色','雄')
    console.log(d);
</script>

<script>
    class Animals {
        // 構造方法
        constructor(name,age){
            this.name = name
            this.age = age
        }
        // 父類成員的屬性
        call(){
            console.log('我是動物');
        }
    }
    class Dog extends Animals {
        // 構造方法
        constructor(name,age,color,gender){
            // 調用父類方法，需要用super(),super()就是父類的constructor()方法
            super(name,age)
            this.color = color
            this.gender = gender
        }
        // 子類獨有的方法
        say(){
            console.log('汪汪汪?。。?);
        }
        // 當子類和父類重名時，優(yōu)先調用的是子類的方法
        call(){
            console.log('我也是動物');
            // 如果想調用父類方法,使用如下語句:super.父類方法()
            super.call()
        }
    }
    // 實例化子類對象
    const d = new Dog('小明',3,'棕色','雄')
    console.log(d);
    d.call()
    d.say()
</script>

<script>
    class people {}
    class boy extends people {}
    console.log(Object.getPrototypeOf(boy) === people);//true
</script>

<script>
    class people {
        // 父類靜態(tài)屬性 屬性為數值
        static age = 18
        // 父類靜態(tài)屬性 屬性為對象
        static h = {height:180}
        // 父類靜態(tài)方法
        static say(){
            console.log('hello world');
        }
    }
    // 子類繼承父類
    class boy extends people {
        constructor(){
            // 調用父類的構造函數
            super()
            // boy類繼承靜態(tài)屬性時，會采用淺拷貝，拷貝父類靜態(tài)屬性的值，因此people.age和boy.age是兩個彼此獨立的屬性。
            boy.age--
            // 如果父類的靜態(tài)屬性的值是一個對象，那么子類的靜態(tài)屬性也會指向這個對象，因為淺拷貝只會拷貝對象的內存地址所以，子類修改這個對象的屬性值，會影響到父類。
            boy.h.height--
        }
    }
    // 實例化子類
    let b = new boy()
    boy.say()
    console.log(people.age);
    console.log(boy.age);
    console.log(boy.h.height);
    console.log(people.h.height);
    console.log(b);
</script>

<script>
    class people {
        #name = '張三'
        // 定義用來讀取私有屬性和方法的函數
        getName(){
            return this.#name
        }
    }
    class boy extends people {
        constructor(){
            // 調用父類的構造函數
            super()
            console.log(this.getName());//張三
        }
    }
    let b = new boy()
</script>

<script>
    class people {}
    class boy extends people{}
    // 子類的__proto__屬性，表示構造函數的繼承，總是指向父類。
    console.log(boy.__proto__ === people); // true
    // 子類prototype屬性的__proto__屬性，表示方法的繼承，總是指向父類的prototype屬性。
    console.log(boy.prototype.__proto__ === people.prototype); // true
</script>