• Python 16 类与类之间的关系


    类与类之间的关系

    类与类之间的关系
    类与类中存在的关系:
    1.依赖关系
    2.关联关系
    3.组合关系
    4.聚合关系
    5.继承关系
    6.实现关系

    python是一门弱类型编程语言,并且所有的对象之间其实都是多态关系,所有的东西都可以当做对象来使用。
    一.依赖关系
    依赖关系:我需要用你,但你不属于我,这种关系是最弱的。

    例:把大象装进冰箱,创建大象、冰箱两个类
    class Elephant:
    def init(self,name):
    self.name = name

    def open(self,ref):
        print('大象说:开门吧')
        ref.open_door()
    
    def close(self,ref):
        print('大象说:关门吧')
        ref.close_door()
    
    def take(self):
        print('大象走进冰箱')
    

    class BingXiang:
    def open_door(self):
    print('冰箱:门开了')

    def close_door(self):
        print('冰箱:关好了')
    

    r = BingXiang() # 造冰箱

    el = Elephant('独立自主的大象') # 造大象
    el.open(r) # 把冰箱当作参数传递进大象的类中,大象可以指定任何一个冰箱去进行操作
    el.take()
    el.close(r)
    二.关联关系、组合关系、聚合关系
    1.关联关系:两种事物必须是相互关联的,但是在某些特殊情况下是可以更改的和更换的。

    2.聚合关系:属于关联关系中的一种特例,重点是xxx和xxx聚合城了xxx,各自有各自的声明周期,主体完蛋了,个体依然存在。

    3.组合关系:属于关联关系中的一种特例,写法上差不多,组合关系比聚合关系还要紧密,主体完蛋了,个体跟着一起完蛋。

    例:
    男女朋友关系,可以是相互的也可以是单方面的
    class Boy:
    def init(self,name,girlFriend = None):
    self.name = name
    self.girlFriend = girlFriend

        def yujian(self):
            if self.girlFriend:
                print('%s 和 %s 在一起吃饭' % (self.name,self.girlFriend.name))
            else:
                print('单身狗吃什么饭')
    
    class Girl:
        def __init__(self,name):
            self.name = name
    
    b = Boy('alex')
    b.yujian()
    
    g = Girl('王婆')
    b.girlFriend = g  # 有女朋友了
    b.yujian()        # 两个人一起吃饭
    

    注:关联关系在逻辑上出现了,我需要你,你还要属于我,这种逻辑就是关联关系。
    组合关系和聚合关系,代码上的差别不大,都是把另一类的对象作为这个类的属性来传递和保存,只是在含以上有不同。
    三:继承关系
    继承关系:子类在不影响父类的程序运行的基础上对父类进行扩充和扩展,我们可以父类成为超类或者基类,子类被称为派生类。

    例:类名和对象默认是可以作为字典的key的

        class Foo:
            def __init__(self):
                pass
            def method(self):
                pass
        
        print(hash(Foo))
        print(hash(Foo()))
         # 既然可hash,那就说明字典的key可以是对象或者类
        
        dic = {}
        dic[Foo] = 123
        dic[Foo()] = 456
        print(dic)  # {<class '__main__.Foo'>: 123, <__main__.Foo object at 0x00000000021D82E8>: 456}
    

    四:self
    接下来研究继承上的相关内容,主要研究self(不关方法之间如何进行调用,类与类之间是何关系,
    默认的self都是访问这个方法的对象)

    例1:

        class Base:
            def __init__(self, num):
                self.num = num
            def func1(self):
                 print(self.num)
        class Foo(Base):
             pass
             
        obj = Foo(123)
        obj.func1()    # 123 运行的Base中的func1
    

    例2:

        class Base:
            def __init__(self, num):
                self.num = num
                
            def func1(self):
                 print(self.num)
    
        class Foo(Base):
            def func1(self):
             print("Foo. func1", self.num)
    
        obj = Foo(123)
        obj.func1() # Foo. func1 123 运⾏的是Foo中的func1
    

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

    例3:

        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
    

    例4:

        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.func1()  # 1  111  1  |  2  111  2  |  3  222  3
    

    总结:self就是你访问方法的那个对象,先找自己的,然后在找父类的。
    五:类中的特殊成员
    像__init__()这样,带上下划线的方法就属于特殊成员,在特殊的场景会被自动执行。

    例:

    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 对象就不可哈希了.

    创建对象的真正步骤:
    首先, 在执行类名()的时候,系统会自动先执⾏__new__()来开辟内存,此时新开辟出来的内存区域是空的。
    紧随其后系统⾃自动调用__init__()来完成对象的初始化操作,按照时间轴来算。
    1.加载类
    2.开辟内存(new)
    3.初始化(init)
    4.使用对象去执行什么

  • 相关阅读:
    Beta冲刺 第二天
    Beta冲刺 第一天
    实验十一 团队项目设计完善&编码测试
    实验十 软件系统详细设计与概要设计的改进
    实验九 FBG 团队项目需求改进与系统设计
    实验八 <FBG> 基于原型的团队项目需求调研与分析
    实验七 《FBG》—-小学生课后习题答案原型设计
    实验五 <FBG>团队亮相
    Windows zip版本安装MySQL
    redis安装与简单实用
  • 原文地址:https://www.cnblogs.com/NATO/p/9949010.html
Copyright © 2020-2023  润新知