js面向对象与继承

　　　　 function Person(name,sex){
            // var this=new Object();//这里注释的代码 假想 new操作时系统内部帮我们做了这些

            this.name=name;
            this.sex=sex;
            //不建议方法写在构造函数里
            this.showSex=function(){
                console.log(this.sex);
            }

            // return this;
        }
        //建议面向对象对象的方法写在原型里，这样new出来的对象的所拥有的方法都是指向原型里的方法
        Person.prototype.showName=function(){
            console.log(this.name);
        }
        var p1=new Person('leo','MR');
        p1.showName();
        p1.showSex();
        var p2=new Person('jack','MR');
        p2.showName();
        p2.showSex();
        console.log(p1.showName==p2.showName);//true
        console.log(p1.showSex==p2.showSex);  //false  每次new出来的对象都有自已的showSex方法 这样浪费资源

        //继承
        function Worker(name,sex,job){
            Person.call(this,name,sex);//实现属性的继承
            this.job=job;
        }

        //实现方法的继承
        for(var i in Person.prototype){
            Worker.prototype[i]=Person.prototype[i];
        }
        //不建议以下写法，这样写会导致子类影响父类   因为prototype是引用类型 给Worker.prototype加showJob方法的同时，也会给Person.prototype加上；
        //Worker.prototype=Person.prototype;
        Worker.prototype.showJob=function() {
            console.log(this.job);
        }
        var w1=new Worker('penny','MS','programmer');
        w1.showJob();
        var p3=new Person('susan','MR');
        p3.showJob();//子类不会影响父类，子类没有showJob方法

 对比2种继承方式的好处与不足：

        var Person=function (name) {
            this.name=name;
        }
        Person.prototype.say=function(){
            alert('我的名字叫'+this.name);
        };

        var Chinese=function(color){
            this.color=color;
        }
        Chinese.prototype=new Person();//此种方式继承，父类的属性和方法都在原型链上。
        Chinese.prototype.name='penny';//此种继承的缺点  创建子类实例时，无法向父类构造函数传参  只能这样赋值
        Chinese.prototype.showColor = function(){
            alert('我的肤色是'+this.color);
        }
        var ch=new Chinese('黄色');//查看 ch 的原型链
        ch.say();
        ch.showColor();
        var p=new Person('susan');
        p.say();
        console.log('Chinese类是否有属性name：' + Chinese.hasOwnProperty('name'));



        function Person2(name){
            this.name=name;
        }
        Person2.prototype.showName=function(){
            console.log(this.name);
        }
        //继承
        function Worker(name,job){
            Person.call(this,name);//实现属性的继承
            this.job=job;
        }
        //实现方法的继承
        for(var i in Person2.prototype){
            Worker.prototype[i]=Person.prototype[i];
        }
        Worker.prototype.showJob=function() {
            console.log(this.job);
        }
        var w1=new Worker('penny','programmer');//查看 w1 的原型链 表面上是继承，实际上属性和方法都是自己的
        w1.showJob();
        var p2=new Person2('susan');
        p2.showName();
        console.log('Worker类是否有属性name：' + Chinese.hasOwnProperty('name'));

此文不错，分享一下：https://www.cnblogs.com/humin/p/4556820.html