快捷搜索:
您的位置:AG真人平台下注 > 宠物资讯 > 我们可以设计按行为功能分类的类层次图,通过

我们可以设计按行为功能分类的类层次图,通过

2019-12-12 08:20

#鸟儿:包括会跑的鸟儿和平构和会议飞的鸟儿。

原型世袭与品质拷贝的插花使用

原型世襲和拷贝世袭混用的办法,能将八个父对象的属性用分化的点子继续下来
先创造多少个对象 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);//["金钱", "权利"]

实现了


图片 1

多种世襲

实则,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 将有所父级对象属性保存下来,需求时再去得到。

图片 2

深拷贝

上面三种情势纵然都能调用函数,但是生机勃勃旦改动对象的值,是直接校订父级对象的值,原本父级的性质就被替换了

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);//["金钱", "权利"]

浓度拷贝的法则

图片 3

浓度拷贝.png

t 假设不变 description 属性暗许世襲父级属性,同不时间,t更正数组,对 per 的数组值未有影响


 

指标之间的接轨

到当前的话。我们都以透过布局函数实现的一而再

实则,大家全然能够不行使结构函数就贯彻延续关系,直接动用对象完结后续关系的创设

函数代码如下:

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());

贯彻了子级世襲父级的意义,同一时间,大家还可以经过此函数直接创立子级对象


 

天性拷贝

三番若干次不单单能通过原型链完成,也能因而任何方法达成,属性拷贝正是此中大器晚成种办法。

由此品质拷贝也能实现一连
子对象会世襲父对象原型链上全体的自家性质

函数代码在那:

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 的习性

如图所示:

图片 4

属性拷贝2.png

在乎:该措施只针对于基本数据类型有效,JS中目的的传递大繁多都是援用传递,仅仅是传递对象的地点,子对象修正,父对象中也相应地会退换


图片 5

#假定依据哺乳动物和鸟类分类,大家得以设计按哺乳动物分了的类档期的顺序图,如图1。假设依据“会跑”和“会飞”分类,大家能够铺排按行为成效分类的类档案的次序图,如图2。

 

#三番两次今后面包车型大巴Animal类为例,即便要完毕4种动物:Dog(狗卡塔尔、Bat(蝙蝠卡塔尔(قطر‎、Parrot(鹦鹉卡塔尔国、ostrich(鸵鸟卡塔尔(英语:State of Qatar)。

#对要求Flyable效能的动物增添对Flyable的世袭,如Bat:

 

#能够观望,多重世襲就是有五个基类(父类或超类)。

 

#亟待注意圆括号中父类的次第,若父类中有相符的方法名,在子类使用时未钦赐,Python会从左到右寻找。若方法在子类中未找到,则从左到右查找父类中是还是不是包蕴方法。

#假诺要把上边的三种分类都满含进来,就得酌量越多档案的次序:

#实施如下语句:

 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
1 class Bat(Manmmal,Flyable):
2         pass
1 class DerivedClassName(Base1,Base2,Base3):
2          <statement-1>
3         .
4         .
5         . 
6          <statement-N>
1 D:Pythonworkspace>python class_多重继承.py
2 Is Running...

#眼下讲的是单继承,Python还援助多种世襲。多种继承的类定义如下:

 

#科学的做法是利用多种世袭。首先,首要的类等级次序仍遵照哺乳类的飞禽设计,设计代码如下:

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

 

1 class Dog(Mammal,Runnable):    
2         pass

 

#实施结果如下:

#如此,通过上边的种类继承,四个子类就足以持续八个父类,同一时间获取多个父类全数非私有功用。

#哺乳类:包蕴会跑的哺乳类和平商谈会议飞的哺乳类。

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

1 dog=Dog
2 dog.run
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...')

#设若还要扩展“宠物类”和“非宠物类”,类的多寡就能够呈指数进步,鲜明那样设计是不可行的。

本文由AG真人平台下注发布于宠物资讯,转载请注明出处:我们可以设计按行为功能分类的类层次图,通过

关键词: ag真人游戏 日记本