设为首页 加入收藏

TOP

python学习 day017打卡 类与类之间的关系(一)
2018-11-08 22:08:32 】 浏览:21
Tags:python 学习 day017 打卡 之间 关系

本节主要的内容:

1.依赖关系

2.关联关系,组合关系,聚合关系

3.继承关系,self到底是什么?

4.类中的特殊成员

 

一.类与类之间的依赖关系

在面向对象的世界中,类与类中存在以下关系:

1.依赖关系

2.关联关系

3.组合关系

4.聚合关系

5.继承关系

6.实现关系

由于python是一门弱类型编程语言,并且所有的对象之间其实都是多态关系,也就是说,所有的东西都可以当做对象来使用.

所以我们在写代码的时候很容易形成以上关系.首先我们先看第一种,也就是这些关系中紧密程度最低的一个,依赖关系.

class DaXiang:
    def open(self, bx): #  这里是依赖关系. 想执行这个动作. 必须传递一个bx
        print("大象高高兴兴走到了冰箱的面向前")
        bx.kai() # 传递来的对象执行kai()动作
        print("大象成功的打开了冰箱门")

    def zhuang(self):
        print("自己走进了冰箱")

    def close(self, bx):
        print("大象要关冰箱门了")
        bx.guan()


class BingXiang:
    def kai(self):
        print("我是冰箱. 我会开门 ")
    def guan(self):
        print("我是冰箱. 我会关门 ")


bx1 = BingXiang()
dx = DaXiang()

dx.open(bx1)
dx.zhuang()
dx.close(bx1)

 

依赖关系其实就是在方法中给方法的参数传递一个对象,此时类与类之间的关系就是依赖关系,但是关系是最轻的

二.关联关系,组合关系,聚合关系

这三种关系在代码上写法是一样的,但是,从含义上是不一样的.

1.关联关系:两种事物必须是互相关联的,但是在某些特殊情况下是可以更改和更换的.

2.聚合关系:属于关联关系中的一种特例,侧重点事xxx和xxx聚合成xxx.各自有各自的声明周期.比如电脑:电脑里有CPU,

硬盘,内存等等.电脑坏了,CPU还是好的,还是完整的个体

3.组合关系.属于关联关系中的一种特例.写法上差不多,组合关系比聚合关系还要紧密,比如人的大脑,心脏,各个器官,这些

器官组合成一个人.这时,这个人和他的器官是共同存在,共同消亡的.

 

关联关系:

ass Boy:
    def __init__(self, name, girlFriend = None):
        self.name = name
        self.girlFriend = girlFriend # 关联关系

    def chi(self): # b
        if self.girlFriend:
            self.girlFriend.happy()
            print("%s和%s在吃饭"  %  (self.name, self.girlFriend.name))
        else:
            print("没女朋友吃什么吃")

class Girl:
    def __init__(self, name):
        self.name = name

    def happy(self):
        print("有好吃的就开心")


b = Boy("王明")
g = Girl("肉丝")
# b对象的girlFriend赋值  g

b.girlFriend = g # 突然天降女朋友
b.chi()
b.girlFriend = None
b.c

 

关联关系其实就是把另个类的对象作为这个类的对象作为这个类的属性来传递和保存.

 

组合关系和聚合关系,其实代码上的差别不大,都是把另一个类的对象作为这个类的属性来传递和保存.只是含义上会有些许的不同而已.

 

三.继承关系

在面向对象的世界中存在着继承关系.我们现实中也存在着这样的关系.我们说过.x是一种y.这时理解层面上的.如果上升到代码层面.我们

可以这样认为.子类在不影响父类的程序运行的基础上对父类进行的扩充和扩展.这里我们可以把父类称为超类或者基类.子类被称为派生类.

 

类名和对象默认是可以作为字典的key,即可哈希的

class Foo:
     def __init__(self):
        pass
     def method(self):
        pass
    # 该类的对象就不可哈希了
    #  __hash__ = None


print(hash(Foo)) # 类和对象默认都是可哈希的
print(hash(Foo())) # unhashable type: 'Foo'

 

当在类中加入__hash__=None,对象就是不可哈希的了

 

接下来继续讲继承上的相关内容.

记住:不管方法之间如何进行调用,类与类之间是如何关系,默认的self都是访问这个方法的对象

class Base:
    def __init__(self, num):
        self.num = num

    def func1(self):
        print(self.num)
        self.func2()

    def func2(self):
        print(111, self.num)

class Foo(Base):
    def func2(self):
        print(222, self.num)

lst = [Base(1), Base(2), Foo(3)]
for obj in lst:
    obj.func2()
# 结果
# 111 1
# 111 2
# 222 3

 

 

 

总结:self在访问方法的顺序:永远是先找自己的.自己的找不到再找父类的.

结论:self就是你访问的那个对象.先找自己,然后在找父类的.

 

四.类中的特殊成员

特殊成员:类中方法名左右两边带双下划线的成员

1.类名()  会自动执行__init__()

2.对象()会自动执行__call__()

3.对象[key] 会自动执行__getitem__()

4.对象[key] = value 会自动 __setitem__()

5.del 对象[key] 会自动执行 __delitem__()

6.对象+对象 会自动执行 __add__()

7.with 对象 as 变量 :  进去的时候会自动执行__enter__()

出来的时候会执行__exit__()

8.打印对象的时候 会自动执行__str__()

9.干掉可哈希 __hash__ == None 对象就不可哈希了.

....

class Car:
    def __init__(self, color, pai):
        self.color = color
        self.pai = pai
    def __call__(self, *args, **kwargs):
        print("这里是call")

    def __getitem__(self, item):
        print("这里是getitem, item=", item)

    def __setitem__(self, key, value):
        print(key, value)

    def __delitem__(self
编程开发网
首页 上一页 1 2 下一页 尾页 1/2/2
】【打印繁体】【投稿】【收藏】 【推荐】【举报】【评论】 【关闭】 【返回顶部
上一篇类与类之间的关系 下一篇第十七天-面向对象03-类与类的关系

评论

帐  号: 密码: (新用户注册)
验 证 码:
表  情:
内  容:

最新文章

热门文章

C 语言

C++基础

windows编程基础

linux编程基础

C/C++面试题目