constructor函数--构造一个对象的函数<br />        特点:<br />        1.不允许以字面量的形式去原型对象上添加属性的

        class Person{
            constructor(name,age){
                this.name = name;
                this.age = age;
            }
            sayName(){
                console.log(this.name);
            }
        }
        /* 不允许以字面量的形式去添加属性的 */
        Person.prototype = {
            sayAge(){
                console.log(this.age)
            }
        }
        var p = new Person("cheng",20);
        p.sayAge()

1.Object-assign

Object.assign可以在原型上添加多个属性

         class Person{
            constructor(name,age){
                this.name = name;
                this.age = age;
            }
            sayName(){
                console.log(this.name);
            }
        }
        Object.assign(Person.prototype,{
            sayAge(){
                console.log(this.age)
            },
            show(){
                console.log("show")
            }
        })
        var p = new Person("cheng",18);
        console.log(p.constructor ==  Person)

2.Stack

栈的数据结构

        var arr = [0,1]
        arr.push(2);
        arr.pop();
        console.log(arr)
        /* peek获取处于 */
        function peek(){
        }

3.class-Stack

    栈数据结构的特点:后进先出  例子水杯,谷仓,米袋就是栈的数据结构<br />        1.push<br />        2.pop  //将栈顶的数据出栈<br />        3.peek 获取栈顶的数据<br />        4.isEmpty判断栈是否为空<br />        5.size返回栈的长度<br />location路由 是以栈的数据结构去保存路由的 

        class Stack{
            constructor(){
                this.items = [];
            }
            push(value){
                this.items.push(value)
            }
            pop(){
                return this.items.pop();
            }
            peek(){
                return this.items[this.items.length-1]
            }
            isEmpty(){
                return this.items.length==0;
            }
            size(){
                return this.items.length;
            }
        }
        var s = new Stack();
        s.push(8);
        s.push(9);
        console.log(s.isEmpty())

4.class-extends

继承
super 就是指父类

        class Person{
            constructor(name,age) {
                this.name = name;
                this.age = age;                
            }
            sayName(){
                console.log(this.name)
            }
        }
        class Teacher extends Person {
            /* 类继承之后,构造函数第一行必须写super关键字 去继承父类的属性*/
            constructor(name,age,skill){
                super(name,age);
                this.skill = skill;
            }
            /* 在子类的方法中调用父类的方法 可以通过this或super去调用 */
            show(){
                this.sayName();
                // super.sayName();
            }
        }
        var t = new Teacher("zhang",18,"js");
        console.log(t)

5.static

静态属性,静态方法
属于类所独有的
特点:通过类名去调用

        class Person{
            constructor(name,age){
                this.name = name;
                this.age = age;
            }
            static sayName(){
                console.log("name")
            }
        }
        var p = new Person("lisi",19);
        Person.sayName()

6.静态方法和普通方法

1.在普通方法中能调用静态方法
2.在静态方法中不能调用普通方法

        class Person{
            constructor(name,age){
                this.name = name;
                this.age = age;
            }
            sayAge(){
                Person.sayName();
                console.log(this.age);
            }
            static sayName(){
                this.sayAge();
                console.log("name")
            }
        }
        var p = new Person("name",18)
        Person.sayName();

7.static-this

静态方法:
1.静态方法是属于类所独有的,类创建的时候,就会在内存中存在。不用实例化,直接通过
类名直接调用,不会造成系统资源的格外浪费
2.不可以在静态方法中,调用普通方法
3.静态方法中的this,指调用静态方法的这个类
4.静态方法是可以被继承的
在静态方法中this指—>调用静态方法的类

        class Person{
            constructor(name,age){
                this.name = name;
                this.age = age;
            }
            sayAge(){
                Person.sayName();
                console.log(this.age);
            }
            static sayName(){
                console.log(this)
                console.log("name")
            }
        }
        Person.sayName();

8.静态方法和继承

    1.子类可以继承父类的静态方法<br />        2.在子类的静态方法中调用父类的静态方法,可以通过super/this去调用

        class Person{
            static baseUrl = "https://www.baidu.com"
            static sayName(){
                console.log("name")
            }
        }
        class Teacher extends Person{
            static sayAge(){
                super.sayName();
                console.log(super.baseUrl)
                console.log("age");
            }
        }
        Teacher.sayAge()
        console.log(Person.baseUrl)

9.总结

1.如何使用class去定义一个类
  eg:定义一个学生类,包含name-age两个属性,还包含sayName
2.如何给一个类的原型上去添加多个属性/方法
3.如何实现继承
4.如何定义一个静态方法  
5.静态方法的特点
   5-1 通过类名调用
   5-2 不可以在静态方法中调用普通方法
   5-3 this指向问题-->类
   5-4 静态方法是可以被继承的。