若父类中有相同的方法名,子对象会继承父对象

#日前讲的是单世袭,Python还扶助多种世襲。多种世袭的类定义如下:

品质拷贝

后续不单单能通过原型链完结,也能由此任何方法落实,属性拷贝就是当中生机勃勃种方法。

通过品质拷贝也能兑现持续
子对象会世袭父对象原型链上全部的自家性质

函数代码在那:

function extend2(Child,Parent) {
            var c = Child.prototype;
            var p = Parent.prototype;

            // 循环遍历 Parent 中的属性,复制给 Child
            for (var i in p){
                c[i] = p [i];
            };
            // uber 属性实现子级能找到父级的属性
            Child.uber = Parent.prototype;
        }

那会儿创造父级子级的布局函数及对象,调用函数变成持续关系

function Person(){}
        Person.prototype.description = "人类";
        Person.prototype.age = 0;
        Person.prototype.hobby = ["权利","金钱"]
        Person.prototype.say = function(){
            return "我的年龄:"  this.age;
        }

        function Student(){}
        // 实现继承关系,调用函数
        extend2(Student,Person);
        // 此时不需要更改 construtor 属性
        Student.prototype.description = "学生";
        Student.prototype.age= 18;

        var stu = new Student();
        console.log(stu.description);//学生
        console.log(stu.say());//我的年龄:18
        stu.hobby.pop()
        console.log(stu.hobby);//["权利"]

        var per = new Person();
        console.log(per.description);//人类
        console.log(per.say());//我的年龄:0
        console.log(per.hobby);//["权利"]

那个时候落到实处了三番一回的效用,stu 能访谈 per 的属性

如图所示:

图片 1

属性拷贝2.png

留意:该办法只针对于基本数据类型有效,JS中指标的传递大超多都以援用传递,仅仅是传递对象的地址,子对象改过,父对象中也呼应地会改造


1 class DerivedClassName(Base1,Base2,Base3):
2          <statement-1>
3         .
4         .
5         . 
6          <statement-N>

指标之间的存在延续

到当前以来。大家都以透过布局函数落成的接续

实质上,大家完全能够不使用布局函数就落实持续关系,直接利用对象实现后续关系的构建

函数代码如下:

function extend3(parent,child) {
            // 如果child参数传进来,就是外面有已知对象给 child 赋值,
            //如果没有 Child 参数传进来,函数会创建一个空对象并返回,此空对象继承自 parent
            child = child || {};
            for (var i in parent){
                child[i] = parent[i];
            }
            child.uber = parent;
            return child;
        }

最近我们一向开立父级子级对象,调用函数完结三番三回,代码如下:

var  per = { 
            description:"人类",
            age:0,
            hobby:["金钱","权利"],
            say:function(){
                return "我的年龄是:"  this.age;
            },
        }

        function Student(){}

        var stu = new Student();
        // 建立继承关系(让一个已知的对象继承自 per)
        extend3(per,stu);
        stu.description = "学生";
        console.log(stu.description);//学生
        console.log(stu.age);//0
        stu.hobby.pop();
        console.log(stu.hobby);//["金钱"]
        console.log(stu.say());//我的年龄是:0
        console.log(per.hobby);//["金钱"]
        // 子对象访问父对象属性
        console.log(stu.uber.description);//人类


        // 创建一个继承自 per的对象

        var t = extend3(per);
        console.log(t.description);
        console.log(t.say());

兑现了子级世襲父级的功用,同有的时候候,我们还是能由此此函数直接创设子级对象


#能够见见,多种世袭正是有多个基类(父类或超类)。

深拷贝

地点二种形式即使都能调用函数,不过如果改过对象的值,是平素改变父级对象的值,原本父级的属性就被轮换了

extend2 和 extend3 都以浅拷贝

深拷贝:内部存款和储蓄器拷贝,将内部存储器完整的正片风流洒脱份

浅拷贝:援引拷贝,只复制对象的地点

若是想实现深拷贝

1.我们会用hasOwnProperty() 方法判断该属性是否需要复制的
2.子对象不会影响到父对象中的属性值

得以完毕深拷贝的函数代码如下:

function deepCopy(parent,child){
            child = child || {};
            // 遍历父对象属性
            for(var i in parent){
                // 判断自身属性
                if(parent.hasOwnProperty(i)){
                    // 判断自身属性
                    if(/*对象类型*/typeof parent[i] === "object"){
                        // 判断属性是否是数组
                        child[i] = Array.isArray(parent[i]) ? [] : {};
                        // 把 parent[i]里的属性赋值给child[i]里面去
                        deepCopy(parent[i],child[i]);
                    }else{
                    // 基本数据类型
                    child[i] = parent[i];
                    }
                }
            }
            // child.uber = parent;
            return child;
        }

这一次直接成立对象看看效果

var  per = { 
            description:"人类",
            age:0,
            hobby:["金钱","权利"],
            say:function(){
                return "我的年龄是:"  this.age;
            },
        }

        //  t 继承自 per
        var t = deepCopy(per);
        // t.description = "学生";
        console.log(t.description);//人类
        console.log(per.description);//人类
        t.hobby.pop();
        console.log(t.hobby);//["金钱"]
        console.log(per.hobby);//["金钱", "权利"]

浓度拷贝的原理

图片 2

浓度拷贝.png

t 如若不改进 description 属性暗中认可世袭父级属性,同不平时候,t改良数组,对 per 的数组值没有影响


#急需注意圆括号中父类的逐黄金年代,若父类中有黄金时代致的秘技名,在子类使用时未钦点,Python会从左到右搜索。若方法在子类中未找到,则从左到右查找父类中是或不是包括方法。

原型世袭与天性拷贝的混合使用

原型继承和拷贝世袭混用的主意,能将多个父对象的习性用分歧的章程一连下来
先创设三个对象 per 和 base ,作为父对象
代码如下:

var  per = { 
            description:"人类",
            age:0,
            hobby:["金钱","权利"],
            say:function(){
                return "我的年龄是:"  this.age;
            },
        }

        var base = {
            name:"二雷",height:180,weight:100,
        }

混用函数代码如下:

function extend(p1,p2) {
            var child;
            var F = function(){};
            F.prototype = p1;
            child =  new F();

            for(var i in p2){
                child[i] = p2[i];
            }
            return child;
        }

创造子级,看一下功力:

var t = extend(per,base);
        console.log(t.name);//二雷
        console.log(t.hobby);//["金钱", "权利"]

实现了


#后续从前边的Animal类为例,倘若要完毕4种动物:Dog(狗卡塔尔(英语:State of Qatar)、Bat(蝙蝠卡塔尔、Parrot(鹦鹉卡塔尔(英语:State of Qatar)、ostrich(鸵鸟卡塔尔(英语:State of Qatar)。

多种世襲

事实上,n个对象的质量也能够通过函数达成再三再四于1体态对象中,也等于一个子指标能一连到充足目的的习性

要促成这一个措施,要求使用函数的 arguments 属性

父级对象的创立:

// 能继承多个对象的属性,创建多个对象
        var per1 = {
            name:"二雷",
        }
        var per3 = {
            age:20,
        }
        var per5 = {
            height:180,name:"雷",
        }
        var per6 = {
            weight:100,
        }

一而再函数的始建:

// arguments类似数组,它的属性是当前函数所街搜到的所有参数
        function muli(){
            var child = {};
            for(var i = 0;i<arguments.length;i  ) {
                for(var j in arguments[i]){
                    child[j] = arguments[i][j];
                }
            }
            return child;
        }
        // 注意:如果父对象中存在相同的属性,参数后面对象中的属性会覆盖前面对象中的属性
        var t = muli(per1,per3,per5,per6);
        console.log(t)//Object age: 20 height: 180 name: "雷" weight: 100 __proto__: Object

那样新建的t对象就有其抱有父级成分的特性了,集大成者

只是要专心的是,借使父级成分中有风流洒脱致的性质,什么人在前面输出何人的习性,不过前面包车型地铁属性值就被覆盖了,在现阶段函数下,无法找回前边的同名属性值,能够通过安装 uber 将装有父级对象属性保存下来,需求时再去获得。

#若是依照哺乳动物和鸟类分类,大家能够铺排按哺乳动物分了的类档期的顺序图,如图1。要是依据“会跑”和“会飞”分类,大家得以设计按行为效用分类的类等级次序图,如图2。

#要是要把下面的三种分类都带有进来,就得准备更加多档案的次序:

#哺乳类:满含会跑的哺乳类和平会谈会议飞的哺乳类。

#鸟儿:包蕴会跑的小鸟和平构和会议飞的飞禽。

图片 3

图片 4

图片 5

#万一还要加进“宠物类”和“非宠物类”,类的多寡就能呈指数增加,明显那样设计是不可行的。

#是的的做法是运用多重世袭。首先,首要的类档期的顺序仍固守哺乳类的飞禽设计,设计代码如下:

 1 #! /usr/bin/python
 2 #-*-coding:UTF-8-*-
 3 #class_多重继承
 4 
 5 class Animal(object):
 6     pass
 7 
 8 #大类:
 9 class Mammal(Animal):
10     pass
11 
12 class Bird(Animal):
13     pass
14 
15 #各种动物:
16 class Dog(Mammal):
17     pass
18 
19 class Bat(Mammal):
20     pass
21 
22 class Parrot(Mammal):
23     pass
24 
25 class Ostrich(Mammal):
26     pass

#接下去,给动物加上Runnable和Flyable效能。大家先定义好Runnable和Flyable类:

1 class Runnable(object):
2     def run(self):
3         print('Is Running...')
4 
5 class Flyable(object):
6     def fly(self):
7         print('Is Flying...')

#大类定义好后,对急需Runnable功用的动物对Runnable的一而再,如Dog:

1 class Dog(Mammal,Runnable):    
2         pass

#对亟待Flyable作用的动物加多对Flyable的后续,如Bat:

1 class Bat(Manmmal,Flyable):
2         pass

#推行如下语句:

1 dog=Dog
2 dog.run

#实行结果如下:

1 D:Pythonworkspace>python class_多重继承.py
2 Is Running...

#这么,通过地点的各种世襲,一个子类就能够持续多少个父类,同时获得多少个父类所有非私有功效。

 

 

 

 

 

 

 

 

本文由云顶娱乐发布于宠物频道,转载请注明出处:若父类中有相同的方法名,子对象会继承父对象