面向对象

面向对象，继承、封装(封装构造函数)、多态。

​ 面向对象是一个编程思想，支撑面向对象编程思想的语法是类(ECMA6之前没有类这个概念)和对象，构造函数充当类的角色。

​ 构造函数和对象实现面向对象程序的时候，体现出 继承、 封装、 多态的特点。

	function Dog({name, type, age}){
                //this = new Object();
                //添加属性
                this.name = name;
                this.type = type;
                this.age = age;
            }
            /* 
                通过构造函数的原型添加方法
             */
             Dog.prototype = {
                 run: function(){
                     alert(this.name + "会飞快的奔跑");
                 },
                 showSelf: function(){
                     alert(`这是一个${this.type}的，${this.age}岁的，叫${this.name}的小狗`);
                 }
             }
             /* 
                分类更加细分的构造函数。继承
              */
            function Teddy({name, type, age, color}){
                //this = new Object();
                //1、继承父一级构造函数所有的属性
                //构造函数的伪装
                Dog.call(this, {
                    name: name,
                    type: type,
                    age: age
                })
                //添加自己的属性
                this.color = color;

                //return this;
            }

            /* 
                原型链继承
             */
            // Teddy.prototype = Dog.prototype;  非常错误的写法
            for(var funcName in Dog.prototype){
                Teddy.prototype[funcName] = Dog.prototype[funcName];
            }

            //在子一级构造函数重写showSelf方法
            /* 
                只会在子一级生效，并不会影响父一级构造函数的方法。

                继承和多态同一件事情的两种完全不同的侧重：
                继承：侧重是从父一级构造函数，继承到的属性和方法。
                多态：侧重是，子一级，自己重写和新增的属性和方法。
             */
            Teddy.prototype.showSelf = function(){
                alert(`这是一个${this.type}的，${this.age}岁的，是${this.color}的，叫${this.name}的小狗`);
            }


            Teddy.prototype.showColor = function(){
                alert(this.color);
            }


            var xiaohong = new Teddy({
                name: "小红",
                type: "泰迪",
                age: 10,
                color: "红色"
            })

            xiaohong.showSelf();
          

            var xiaohei = new Dog({
                name: "小黑",
                type: "拉布拉多",
                age: 5
            });
            xiaohei.showSelf();

继承的写法：

	function Teddy({name, type, age, color}){
                //this = new Object();
                //1、继承父一级构造函数所有的属性
                //构造函数的伪装
                Dog.call(this, {
                    name: name,
                    type: type,
                    age: age
                })
                //添加自己的属性
                this.color = color;

                //return this;
            }

方法的继承：

/* 
  原型链继承
 */
//通过for...in遍历继承
    for(var funcName in Dog.prototype){
        Teddy.prototype[funcName] = Dog.prototype[funcName];
     }
//Object.creat继承
Teddy.prototype = Object.create(Dog.prototype);
//调用构造函数继承
Teddy.prototype = new Dog();

重写父类方法：

Teddy.prototype.showSelf = function(){
                alert(`这是一个${this.type}的，${this.age}岁的，是${this.color}的，叫${this.name}的小狗`);
            }

子类自己的方法：

Teddy.prototype.showColor = function(){
                alert(this.color);
            }

__proto__

构造函数构造出来的对象，有一个属性__proto__，指向构造出这个对象的构造函数的原型。

instanceof 关键字

功能：判断某一个对象是否是这个构造函数构造出来的。