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, key):
        print(key)

    def __add__(self, other): # 在执行两个对象相加的时候自动调用
        print("证明我来过")
    def __enter__(self):
        print("进来的时候")
    def __exit__(self, exc_type, exc_val, exc_tb):
        print("这里是出去")

    def __str__(self): # 当前对象的字符串表示形式
        return "我的车很厉害"

    def __repr__(self):  #  一个对象的官方字符串表示形式
        return "我的车非常非常厉害"

    def __iter__(self):
        return (i for i in range(10))

    # def __hash__(self):
    #     return hash(self.pai) + hash(self.color)
    __hash__ = None


c = Car("红", "1.5T") # 在创建对象的时候会自动的调用__init__()  类名()  ==> init()
# c() # 对象()  => __call__()
# c["马化腾"] # 对象[任意参数] => __getitem__(item)
# c["胡辣汤"] = "河南开封"
# del c['上海小混沌大碗']

# c2 = Car("黑色", "1.8T")
# cc = c+c2

# with c as m: # 装饰器
#     print("哈哈哈")
#
# print("呵呵呵")
# print(c) # 当打印一个对象的时候. 默认的去执行__str__ 根据__str__返回的结果进行打印
# print(repr(c))

print("%s" % c) # %s __str__
print("%r" % c) # %r __repr__

# c > c2 # great than
# c< c2  # less than
# c >= c2 # greate and equals

for s in c:
    print(s)

创建对象的真正步骤:

首先,在执行类名()的时候.系统会自动先执行__new__()来开辟内存.此时新开辟出来的内存区域是空的.

紧随其后,系统自动调动__init__() 来完成对象的初始化工作.按照时间轴来算.

1.加载类

2.开辟内存(__new__)

3.初识化(__init__)

4.使用对象干xxx

class Car:
    def __init__(self, color, pai): # 初始化方法
        print("哪有地呀")
        self.color = color
        self.pai = pai

    # 这里才是真正的构造方法
    def __new__(cls, *args, **kwargs):
        print("我的天哪")
        # 固定的返回值
        return object.__new__(cls)

c = Car("红色", "京A66666") # 先执行__new__ 返回object.__new__(cls).把返回的空对象传递给 __init__()

print(c.color)