前端学习：构造函数，原型对象，类，成员变量，类的继承

1.构造函数：

通过new关键字实例化对象的函数就是构造函数，在定义构造函数时首字母要大写，用来构件对象。

  // new + 构造函数
  var array = new Array(1, 2, 3, 4, 5);

2.原型对象

如果把所有的方法全部定义在构造器中，新建对象中都会包含构造函数中的方法 会浪费内存

prototype  原型本身就是一个对象，    用来  ：共享方法，节省内存

每一个构造函数都有一个原型对象

原型对象中的方法可以新建的实例对象直接调用，因为每一个对象中都拥有一个属性叫__proto__

而__proto__指向原型对象，实例化对象调用原型对象中的方法时可以省略__proto__

constructor 构造器就是看原型对象是由哪个构造器构建出来的，找到它的源头

给构造函数的原型对象赋值属性时，构造器的指向还是原来的构造函数，

Person.prototype.sayHi = function () {
            console.log(" hi ");
        }
        Person.prototype.play = function () {
            console.log(" play ");
        }

当给构造函数的原型对象赋值一个对象时，会改变原型对象的constructor指向，需要在对象里添加  constructor:构造函数名,让其指向原来的构造器

   // 改变了 Person.prototype.constructor的指向
        Person.prototype = {
            // 指向原来的构造器
            constructor: Person,
            sayHi: function () {
                console.log("say hi");
            },
            play() {
                console.log("打篮球");
            },
            toString(){
                console.log(123);
            }
        }

原型链：即成员查找机制    调用方法

                1.找自身构造函数，

                2.自身原型对象

                3.找父类的构造函数

                4,找父类的原型对象

                ...3,4步骤

                直到null     没有就报错

3.es6类

解决es5继承复杂的一种替代方式，   

                用class声明，类名首字母要大写，

                将属性存放在constructor构造器中，也就是初始化属性

                方法写构造器下面

然后通过new创建类的对象，创建出来的对象就可以用类的属性和方法

  // 解决 ES5 继承复杂的一种替代方式
        // class 类  类名首字母要大写  
        class Person {
            // constructor   构造器   初始化属性
            // 主要存放属性
            constructor(name,age){
                this.name = name;
                this.age = age;
            }
            play(){
                console.log("打篮球");
            }
            sayHi(){
                console.log("sayHi");
            }
        }
        // 创建类的对象
        var p1 =  new Person("ZHANGSAN",20);
        p1.play();
        console.log(" p1  = ",p1);

        var p2 =  new Person("LISI",10);
        console.log(" p2  = ",p2);
        p2.play();
        console.log(p1.__proto__ === p2.__proto__)
        console.log(p1.__proto__)

4.成员变量

          分为静态成员变量和实例成员变量  

静态（静态变量 和 静态方法）是被类名打点调用的

实例（实例变量 和 实例方法）是被对象打点调用的

       // 成员变量 
        // 静态的 （静态变量 和 静态方法)  都是被类名打点调用的
        // 实例的 (实例变量 和 实例方法)  都是被对象打点调用的  一般情况都是

        // Math.PI;
        // Math.random();
        class Person{
            constructor(name,age){
                this.name = name;
                this.age = age;
            }
            play(){
                console.log(" =====  ==== ");
            }
            //static 静态的
            static money = 20000;
            static sayHi(){
                console.log("静态方法  类名调用");
            }
        }

        var obj = new Person("张三",290);
        console.log(obj.name);
        console.log(obj.age);
        obj.play();

        // 公共的属性
        // 静态属性  类调用
        console.log(Person.money);

        // 静态方法 类调用
        Person.sayHi();

 5.类的继承 

面向对象编程：类的三大特性： 封装、继承、多态

多态：同一个事件根据不同的对象进行调用  满足三个条件：继承 重写 父类指针指向子类对象

继承：1.子类可以使用父类的属性和方法 2.并且拥有特有的属性和方法

通过class定义子类并通过extends关键字继承父类内容结构和类一样，将属性放在constructor构造器中，在访问this之前，需要调用super()函数来继承父类，还可以写自己特有的属性和方法，方法要继承父类的方法也要用super调要继承的方法，然后还可以叠加新功能

  // 面向对象编程语言  
        // 类的三大特性  1.封装  2.继承   3.多态
        // 多态  同一个事件根据不同的对象进行调用  满足三个条件1.继承  2.重写  3.父类的指针指向子类的对象 (了解)
        // 继承: 1子类可以使用父类的属性和方法  2 并且拥有特有的属性和方法 
        class Person {
            constructor(name,age){
                this.name = name;
                this.age = age;
            }
            play(){
                console.log("乒乓球  父类的方法")
            }
            static num = 0;
            static haHaHa(){
                console.log("父类的静态方法")
            }
        }

        // extends 继承 
        class Man extends Person {
            constructor(name,age,cool){
                // 在访问this之前必须调用super函数
                super(name,age);
                // 特有的属性
                this.cool = cool;
            }
            smoke(){
                console.log("抽烟 ---- ");
            }

            play(){
                // super 超级的 指的是父类的对象
                // 用super调用的好处是   保留了父类的功能  又叠加了新功能
                super.play();
                console.log("打篮球  ==== ");
            }
        }

        var man = new Man("张三",20,"cool");

        // 1.
        console.log(man.name);
        console.log(man.age);
        // man.play();

        console.log(Man.num)// 父类静态属性
        Man.haHaHa();
        // 2.
        console.log(man.cool);
        man.smoke();

        man.play();