# 面向对象---继承  八大继承  枚举 #
```


1.原型链继承
            //父类
            function Person(){
                this.name ="曹德申";
                this.age="41";
                this.sex ="男"；
            }
           Person.prototype.running=function(){
                console.log("跑得快")
            }
            //子类
            function Children(){
                this.score=100;
            }
           //通过原型链  实现继承关系
            //父类的实例化对象  赋值给  子类的原型
             Children.prototype =new Person();

             var  Children1 =new Children();
             console.log(Children1.age);
             Children1.running();
           //动物类
             function  Animal(){
                this.name="大象";
                this.age="0.3";
                var wifi="abc";  //私有属性 外界无法访问
                this.running=function(){
                    console.log("干净跑");
                    return wifi;//在共有方法中   返回私有属性，宫外界获取
                }
             }
            //原型链继承 :  本质  重新子类的原型
             xiaoke.prototype=new Animal()
             //猫类
             function xiaoke(){
                this.name="小可";
                this.color="黑白";
                this.eatting=function(){
                    console.log("还不知道鱼的味道");

                }
             }

             var miao=new xiaoke();
//           console.log(miao.name);
             var a =miao.running();

             //原型链继承中，父类的私有属性只要能被外界访问的，同样可以继承过来
             console.log(a);//接受共有方法的私有属性，并使用
             console.log(miao.wifi)

             //原型链继承：子类能够继承父类所有的属性和方法（包括原型中的）
             //在继承过程中: 1.如果父类和子类有相同，优先子类的为准
             //              2.子类可以使用父类的方法和属性，但父类无法使用子类的
             var xiang =new Animal();
//           console.log(xiang.color);
//           console.log(xiang.name)
//           console.log(xiang.wifi);

2.类式继承
            //类式继承：也叫构造函数继承
            function Person(name,sex){
                this.name=name;
                this.sex=sex;
                this.lala=function(){
                    console.log("2222")
                }
            }

            Person.prototype.stu=function(){
                console.log("早上好~~起来")
            }

            function ThisMe(name,sex){
               this.color="yellow";
              //被调用者。call（调用者，所需要的参数）;
                //call():谁调用这个方法，将谁借过来；
                //参数1：借过来的方法 的  使用者
                //参数2：借过来的方法  所需要的参数（没有即不写）
//              Person.call(this,name,sex);

                //被调用者，apply（调用者，所需要的参数）;
                Person.apply(this,[name,sex]);
            }
          var per=new Person("老王","男")
          console.log(per)
          var me=new ThisMe("小王","女");
          console.log(me);



3.组合继承
       //组合继承  是原型链继承和类式继承的结合使用
        //既可以通过类式继承给父类传参，也可以通过原型链继承来获取父类原型的内容
        //是js中  较为常用的继承方式
        function  Father(name,age){
            this.name=name;
            this.age=age;
            this.hobby="玩";
        }
         Father.prototype.money=function(){
            console.log("我也不知道")
         }
        function my(name,age){
            this.name=name;
            this.job="累成狗";

            //使用类式继承，调用父类的构造函数
            //父类所需的参数，可以在这里传递
             Father.apply(this,[name,age]);
        }

            //原型链继承。可以继承到父类原型中的内容
            my.prototype =new  Father();

            //子类实力化对象
            var me=new my("曹**","41");
            console.log(me);

4.拷贝继承
          //拷贝继承:他的本质意义就是将一个对象的所有属性/方法，赋值给另一个对象的原型，以此来达到继承的效果
          //优点：支持多继承
          //缺点：1.效率较低，内存占用高（因为要拷贝父类的属性）
          //     2.无法获取父类的不可枚举的方法（不可枚举的方法，不能使用for in 访问到）
            //父类（超类）
            function Animal(name){
                //属性
                this.name= name || "Animal";
              //实例方法
                this.sleep =function(){
                    console.log(this.name +"正在睡觉")
                }
          }
            Animal.prototype.eat=function(food){
                console.log(this.name+"正在吃"+food)
            }

            //开始拷贝继承
            function Cat(name,sex){
                //实力化父类
                var animal =new Animal(sex);
               for (var k in animal) {
                    Cat.prototype[k] = animal[k];
                }
                Cat.prototype.sex = name || "Tom";
            }
            var cat =new Cat("小辉","瘦子");
            console.log(cat.name)

  //新的父类
            function Xing(ooo){
                this.name=ooo || "曹瑞";
            }
            Xing.prototype.xxxx=function(){
                console.log("就哈哈哈哈");
            }

            function Zi(name,yy){
              var hua=new Xing(name);
                var animal =new Animal(yy);

                for(var x in hua){
                    Zi.prototype[x] = hua[x];
                }
                for (var k in animal) {
                    Zi.prototype[k] = animal[k];
                }

                Zi.prototype.han=function(){
                    console.log("我来了");
                }
            }

            var s=new Zi("名字","哈哈哈");
            console.log(s.name);





5.实例继承
            //实例j继承：为父类实例添加新特性，作为子类实例返回
            function Animal(){
                this.nema="join";
            }
            Animal.prototype.eat=function(){
                console.log("我能在从好吃的")
            }
           //子类
            function Cat(){
                var animal=new Animal();
                animal.age=19;
                animal.sex="男";

                return animal;
            }

            function Bat(){
                var cat=new Cat();

                for(var k in cat){
                    console.log(cat[k])
                }
                return cat;
            }

            var c=new Bat();
            console.log(c.nema)；





6.原型式继承
            //父类（超类）
            function Animal(){
                this.name="小辉";
                this.age=18;
            }
            Animal.prototype.eat=function(){
                console.log("小猴爱吃香蕉")
            }
          //原型式继承：用一个函数包装一个对象，然后返回这个函数的调用
            //           这个函数就变成一个可以随意增添的属性/方法对象

            //特点：类似一个复制了一个对象，用函数来包装
            //缺点：1.所有实例都会继承原型上的属性
            //     2.无法实现复用（因为所有的新属性都是后面添加的）

            function content(obj){
                function F(){};
                F.prototype =obj; //继承传入的参数

                return F(); //返回函数的执行的结果
            }

            var sup=new Animal();

            //content():这个是自定义的函数
            //作用： 1.它可以返回一个对象
            //       2.将谁作为参数传入该方法，谁将会被新的对象继承
            var son =content(sup);//把父类传参
7.寄生式继承
            //父类（超类）
            function Animal(){
                this.name="小辉";
                this.age=18;
            }
            Animal.prototype.eat=function(){
                console.log("小猴爱吃香蕉")
            }

            function content(obj){
                function F(){};
                F.prototype =obj; //继承传入的参数

                return  new F(); //返回函数的执行的结果
            }

            var sup=new Animal();

//          var son =content(sup);//把父类传参
//          son.name="llll";
//          console.log(son.name);
            //以上是原型继承

            //给原型式继承在套个壳子传递参数，便是寄生式继承
            function shell(obj){
                var sub=content(obj);
                sub.a="gir";
                return sub;
            }

            var hehe=shell(sup);
            console.log(typeof shell);
            console.log(typeof hehe);



8.寄生式组合继承

操作符
            //1.instanceof：判断一个实例对象  是否是某个函数的实例
            // 对象名 instanceof 函数名
            function Animal(){
                this.nema="join";
            }
            Animal.prototype.eat=function(){
                console.log("我能在从好吃的")
            }

            function Son(){
//              this.a=10;
//              var ss=new Animal();
//
//              return ss;
//
//           var animal =new Animal();
//
//              for (var k in animal) {
//                  Son.prototype[k] = animal[k];
//              }
//         Animal.apply(this,);
            }
//          Son.prototype=new Animal();
            var s1=new Son();
            console.log(s1 instanceof Son);
            console.log(s1 instanceof Animal);

            //2.isprototypeof(); 只要是原型链中出现过的原型，都可以说是该原型链产生的原型

            //原型名。isprototypeof（对象名）
            //简述：会从s1开始沿着原型链逐层向上找，看看有没一个叫Son.prototype的
            console.log(Son.prototype.isPrototypeOf(s1))

枚举
     //枚举：  是由一个或一组叫做 元素，成员，属性值组成的数据类型
            //      枚举成员的名字，在编程中通常充当标识符直接使用。同时它也可以被任意的属性所赋值

            //可枚举性(enumerable)： 用来控制所描述的属性，是否将被包括在for...in之中；
            //                         如果一个属性的enumerable值为false，下面的三个操作无法取到该属性
            //                       for...in循环
            //                       Obejct.keys()方法
            //                       JSON.stringify()方法
            var o = {};
            o.a = 1;
            o.b = 2;
            o.c = 3;
          //给Object的原型中添加指定的对象，给该对象添加指定的属性，指定的属性值
            //参数 1： 对象名
            //参数 2： 属性名
            //参数 3： 属性值
            // enumerable :  布尔值      控制该属性是否为可枚举类型
            Object.defineProperty(o,"d",{
                value : 4,
                enumerable : false
            });
            console.log(o.d);
            for(var k in o){
                console.log(o[k]);
            }








```