精华内容
下载资源
问答
  • 那事物之间存在着相对应的关系. 类与类之间也同样如此. 在⾯向对象的世界中. 类与类中存在以下关系: 1. 依赖关系 2. 关联关系 3. 组合关系 4. 聚合关系 5. 继承关系 6. 实现关系 由于python是⼀门弱类型编程...

    类与类之间的关系


      ⼤千世界, 万物之间皆有规则和规律. 我们的类和对象是对⼤千世界中的所有事物进行归
    类. 那事物之间存在着相对应的关系. 类与类之间也同样如此. 在⾯向对象的世界中. 类与类
    中存在以下关系:
      1. 依赖关系
      2. 关联关系
      3. 组合关系
      4. 聚合关系
      5. 继承关系
      6. 实现关系
      由于python是⼀门弱类型编程语言. 并且所有的对象之间其实都是多态的关系. 也就是说,
    所有的东⻄都可以当做对象来使用. 所以我们在写代码的时候很容易形成以上关系. ⾸先. 我
    们先看第一种, 也是这些关系中紧密程度最低的一个, 依赖关系.

    # 写一个植物大战僵尸
    # 1. 植物
    #       打僵尸. 僵尸掉血
    # 2. 僵尸
    #       吃植物. 植物掉血
    
    class Plant:
        def __init__(self, name, hp, ad): # 200
            self.name = name
            self.hp = hp
            self.ad = ad
    
        def attack(self, js):
            print("植物攻击僵尸")
            js.hp -= self.ad
            print(f"僵尸掉血{self.ad}, 还剩下{js.hp}")
    
    class JiangShi:
        def __init__(self, name, hp, ad): # 1000  800
            self.name = name
            self.hp = hp
            self.ad = ad
    
        def attack(self, zw):
            print("僵尸咬植物")
            zw.hp -= self.ad
            print(f"植物掉血{self.ad}, 还剩{zw.hp}")
    
    
    # 植物
    wd = Plant("歪脖子豌豆", 10, 20)
    # 僵尸
    js = JiangShi("铁桶僵尸", 200, 1)
    wd.attack(js)
    wd.attack(js)
    wd.attack(js)
    wd.attack(js)
    wd.attack(js)
    
    js.attack(wd)
    js.attack(wd)
    js.attack(wd)
    js.attack(wd)
    # 攻击僵尸
    # 僵尸掉血20, 还剩下180
    # 植物攻击僵尸
    # 僵尸掉血20, 还剩下160
    # 植物攻击僵尸
    # 僵尸掉血20, 还剩下140
    # 植物攻击僵尸
    # 僵尸掉血20, 还剩下120
    # 植物攻击僵尸
    # 僵尸掉血20, 还剩下100
    # 僵尸咬植物
    # 植物掉血1, 还剩9
    # 僵尸咬植物
    # 植物掉血1, 还剩8
    # 僵尸咬植物
    # 植物掉血1, 还剩7
    # 僵尸咬植物
    # 植物掉血1, 还剩6

    我用着你. 但是你不属于我. 这种关系是最弱的.
    比如. 公司和雇员之间. 对于正式员⼯, 肯定要签订劳动合同. 还得⼩心伺候着. 但是如果是兼
    职. 那无所谓. 需要了你就来. 不需要你就可以拜拜了. 这里的兼职(临时工) 就属于依赖关系.
    我用你. 但是你不属于我.

     

    首先, 我们设计一个场景. 还是最初的那个例子. 要把大象装冰箱. 注意. 在这个场景中, 其
    实是存在了两种事物的. ⼀个是大象, ⼤象负责整个事件的掌控者, 还有⼀个是冰箱, 冰箱负
    责被大象操纵.
    ⾸先, 写出两个类, ⼀个是大象类, 一个是冰箱类.

    class Elphant:
        def __init__(self, name):
            self.name = name
        def open(self):
            '''
            开⻔
            return:
            '''
            pass
        def close(self):
            '''
            关⻔
            :retrrn:
           '''
            pass
    class Refrigerator:
        def open_door(self):
            print("冰箱⻔门被打开了了")
        def close_door(self):
            print("冰箱⻔门被关上了了")                

      冰箱的功能非常简单, 只要会开门, 关⻔就行了. 但是大象就没那么简单了. 想想. 大象开
    门和关⻔的时候是不是要先找个冰箱啊. 然后呢? 打开冰箱门. 是不是打开刚才找到的那个冰
    箱⻔. 然后装⾃己. 最后呢? 关冰箱门, 注意, 关的是刚才那个冰箱吧. 也就是说. 开门和关门
    用的是同⼀个冰箱. 并且. 大象有更换冰箱的权利, 想进那个冰箱就进那个冰箱. 这时, ⼤象类
    和冰箱类的关系并没有那么的紧密. 因为大象可以指定任何一个冰箱. 接下来. 我们把代码完
    善⼀下.

    此时, 我们说, ⼤象和冰箱之间就是依赖关系. 我用着你. 但是你不属于我. 这种关系是最弱的.
    比如. 公司和雇员之间. 对于正式员工, 肯定要签订劳动合同. 还得⼩心伺候着. 但是如果是兼
    职. 那无所谓. 需要了你就来. 不需要你就可以拜拜了. 这里的兼职(临时工) 就属于依赖关
    我用你. 但是你不属于我.

     

     

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


    其实这三个在代码上写法是一样的. 但是, 从含义上是不一样的.

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

     

      2. 聚合关系. 属于关联关系中的一种特例. 侧重点是xxx和xxx聚合成xxx. 各⾃有各自的
    生命周期. 比如电脑. 电脑里有CPU, 硬盘, 内存等等. 电脑挂了. CPU还是好的. 还是
    完整的个体

      3. 组合关系. 属于关联关系中的一种特例. 写法上差不多. 组合关系比聚合还要紧密. 比如⼈的⼤脑, ⼼脏, 各个器官. 这些器官组合成⼀个人. 这时. 人如果挂了. 其他的东⻄也跟着挂了

     

     

      首先我们看关联关系:

    这个最简单. 也是最常用的⼀种关系. 比如. 大家都有男女朋友. 男人

    关联着女朋友. 女人关联着男朋友. 这种关系可以是互相的, 也可以是单⽅的.

     

    class Boy:
    
        def __init__(self, name,  girlFriend=None):
            # 在初始化的时候可以给一个对象的属性设置成另一个类的对象
            self.girlFriend = girlFriend  # 一个男孩有一个女朋友
    
        def chi(self):
            if self.girlFriend:
                print(f"带着他的女朋友{self.girlFriend.name}去吃饭")
            else:
                print("单身狗, 吃什么吃? 滚去学习.")
    
        def movie(self):
            if self.girlFriend:
                print(f"带着他的女朋友{self.girlFriend.name}去看电影")
            else:
                print("单身狗, 看什么看? 滚去学习.")
    class Girl:
        def __init__(self, name):
            self.name = name
    
    b = Boy("宝浪")
    g = Girl("孙艺珍")
    b.chi()
    
    # alex给包浪介绍了一个女朋. 孙艺珍
    b.girlFriend = g
    b.chi()
    
    g2 = Girl("梁咏琪")
    b.girlFriend = g2 # 换了个女朋友
    b.chi()
    # 单身狗, 吃什么吃? 滚去学习.
    # 带着他的女朋友孙艺珍去吃饭
    # 带着他的女朋友梁咏琪去吃饭

      注意. 此时Boy和Girl两个类之间就是关联关系. 两个类的对象紧密练习着. 其中一个没有
    了. 另一个就孤单的不得了. 关联关系, 其实就是 我需要你. 你也属于我. 这就是关联关系. 像
    这样的关系有很多很多. 比如. 学校和老师之间的关系.
    School --- 学校
    Teacher--- 老师
    老师必然属于⼀个学校. 换句话说. 每个老师肯定有⼀个指定的工作机构. 就是学校. 那老师
    的属性中必然关联着学校.

     

    class School:
    
        def __init__(self, name):
            self.teach_list = [] # 这里要装多个老师
            self.name = name
    
        def zhaopin(self, teach):
            self.teach_list.append(teach)
    
        def shangke(self):
            for t in self.teach_list:
                t.work()
    
    class Teacher:
        def __init__(self, name):
            self.name = name
        def work(self):
            print(f"{self.name}在上课")
    
    lnh = School("老男孩")
    t1 = Teacher("武sir")
    t2 = Teacher("太白")
    t3 = Teacher("哪吒")
    t4 = Teacher("女神")
    t5 = Teacher("日天")
    t6 = Teacher("宝浪")
    
    lnh.zhaopin(t1)
    lnh.zhaopin(t2)
    lnh.zhaopin(t3)
    lnh.zhaopin(t4)
    lnh.zhaopin(t5)
    lnh.zhaopin(t6)
    
    lnh.shangke()
    # 武sir在上课
    # 太白在上课
    # 哪吒在上课
    # 女神在上课
    # 日天在上课
    # 宝浪在上课

      好了. 这就是关联关系. 当我们在逻辑上出现了. 我需要你. 你还得属于我. 这种逻辑 就是关
    联关系. 那注意. 这种关系的紧密程度比上面的依赖关系要紧密的多. 为什么呢? 想想吧
    至于组合关系和聚合关系. 其实代码上的差别不⼤大. 都是把另一个类的对象作为这个类的
    属性来传递和保存. 只是在含义上会有些许的不同而已.

     

    继承关系


      在⾯向对象的世界中存在着继承关系. 我们现实中也存在着这样的关系. 我们说过. x是一
    种y, 那x就可以继承y. 这时理解层面上的. 如果上升到代码层面. 我们可以这样认为. 子类在不
    影响父类的程序运行的基础上对父类进行的扩充和扩展. 这里.我们可以把父类被称为超类或
    者基类. 子类被称为派生类
    首先, 类名和对象默认是可以作为字典的key的

     

     

    class Foo:
        pass
    
    
    print(hash(Foo)) # 可哈希
    ##-9223371886657599443
    
    print(hash(Foo()))
    ##150199209592
    # 我们写好的类和创建的对象默认都是可哈希的
    
    
    # 去掉可哈希
    class Foo:
        __hash__ = None # 当前类的对象不可哈希
    
    
    print(hash(Foo)) # 可哈希
    # -9223371886657599384
    
    # print(hash(Foo())) # TypeError: unhashable type: 'Foo'不可哈希
    
    
    class Foo:
        def chi(self, food):
            print("我爱吃鱼和", food)
    
    class Bar:
        def chi(self, food):
            print("我爱吃肉和", food)
    
    dic = {Foo: "鸡蛋", Bar: "香肠"}
    
    for k, v in dic.items():
        k().chi(v)
    # 我爱吃鱼和 鸡蛋
    # 我爱吃肉和 香肠
    类名和对象默认是可以作为字典的key的

     

     

     

      接下来. 我们来继续研究继承上的相关内容. 在本节中主要研究一下self. 记住. 不管方法之
    间如何进行调用. 类与类之间是何关系. 默认的self都是访问这个⽅法的对象.

     

    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

     

    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
    # 

     

     

    class Base:
        def __init__(self, num):
            self.num = num
        def func1(self):
            print(self.num)
            self.func2()
        def func2(self):
            print("Base.func2")
    
    class Foo(Base):
        def func2(self):
            print("Foo.func2")
    obj = Foo(123)
    obj.func1()
    ##123

    总结. 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

     

     

     

    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就是你访问方法的那个对象. 先找⾃己, 然后在找父类的.

     类中的关系: 依赖关系是最轻的. 最重的是继承关系. 关联关系是比较微妙的.

    self到底是谁?
    self:谁调用的就是谁. 类型是根据调用方的对象来进行变换的
    super:表示的是父类

     

    类中的特殊成员


    什么是特殊成员呢? __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 对象就不可哈希了了.

     ...

    ......

    .........

     

    特殊成员:
    __init__() # 创建对象的时候初始化操作
    __call__() # 对象()
    __getitem__() # 对象[哈哈]
    __setitem__() # 对象[哈哈] = 值
    __new__() # 创建对象的时候.开辟内存
    __enter__() # with 对象
    __exit__() #结束with的时候
    __hash__() # 可哈希 hash()

     

     

    创建对象的真正步骤:
      首先, 在执行类名()的时候. 系统会自动先执行__new__()来开辟内存. 此时新开辟出来的内
    存区域是空的. 紧随其后, 系统⾃动调⽤__init__()来完成对象的初始化工作. 按照时间轴来算.
      1. 加载类
      2. 开辟内存(__new__)
      3. 初始化(__init__)
      4. 使⽤用对象⼲干xxxxxxxxx
    类似的操作还有很多很多. 我们不需要完全刻意的去把所有的特殊成员全都记住. 实战中也
    用不到那么多. 用到了查就是了.

     

    面向对象编程的执行流程 ->
      1. 加载类 -> 给类创建一个名称空间 -> 主要存放类变量.
      2. 创建对象 -> 先找类. -> 根据类来开辟内存 ->

      执行类中的__new__() -> 执行__init__() -> 返回对象

     

     

    class Foo:
        def __init__(self): # 初始化操作
            print("我是init,  我是老二")
            print("初始化操作. 在创建对象的时候自动调用这个方法")
    
        def __new__(cls, *args, **kwargs): # 创建, 它是真正的构造方法,  可以开辟内存
            print("我是new. 我是老大")
            return object.__new__(cls)
    
    
        # 为了 对象()
        def __call__(self, *args, **kwargs):
            print("我是对象()")
    
        # 对象[]
        def __getitem__(self, item):
            print("item=",item)
            print("你执行了__getitem__")
            return "哈哈"
    
        # 对象[key] = value
        def __setitem__(self, key, value):
            print("key, ", key)
            print("value, ", value)
    
        # del lst[1]
        def __delitem__(self, key):
            print("key=", key)
    
        # with 对象:
        def __enter__(self):
            print("我是enter")
    
        # with 对象: 代码执行完毕. 最后执行这里
        def __exit__(self, exc_type, exc_val, exc_tb):
            print("我叫exit")
    
        def __len__(self):
            print("我的天哪")
            return 3
    
    
    f = Foo()    # 自动执行__init__()
    f()     # 调用-> __call__()
    print(callable(f)) # 对象()
    
    print(f["李嘉诚"]) # 自动调用__getitem__()
    f['jay'] = "林俊杰"
    
    del f['哈哈']
    
    with f:
        print("我是哈哈哈哈")
    
    with open() :
    
    
    lst = ["孙艺珍", "李金珠", "井柏然"]
    
    lst[2] # =>自动的调用__getitem__()
    
    
    def func():
        pass
    func = 3
    print(callable(func)) # 判断xxx是否是可调用的
    
    
    f.__init__()  # 第一次这么写. 以后别这么写
    lst = [1,2,3,4]
    it = iter(lst)
    
    print(it.__next__())
    
    print(next(it)) # __next__()
    
    面试之前翻一番
    写出15个特殊成员, 并给出具体作用

     

    转载于:https://www.cnblogs.com/H1050676808/p/10145672.html

    展开全文
  • 主要内容: 1. 依赖关系 2. 关联关系, 组合关系, ...那事物之间存在着相对应的关系. 类与类之间也同样如此. 在面向对象的世界中. 类与类中存在以下关系:依赖关系 ,关联关系 ,组合关系 ,聚合关系 ,继承关系 ,实现...

    主要内容:

    • 1. 依赖关系
    • 2. 关联关系, 组合关系, 聚合关系
    • 3. 继承关系
    • 4. 类中的特殊成员

    引子

    • 大千世界, 万物之间皆有规则和规律,我们的类和对象是对大千世界中的所有事物进行归类.
    • 那事物之间存在着相对应的关系. 类与类之间也同样如此.
    • 在面向对象的世界中. 类与类中存在以下关系:依赖关系 ,关联关系 ,组合关系 ,聚合关系 ,继承关系 ,实现关系   
    • 由于python是一门弱类型编程语言,并且所有的对象之间其实都是多态的关系.也就是说,所有的东西都可以当做对象来使用. 所以我们在写代码的时候很容易形成以上关系

    1. 依赖关系

    关于大象进冰箱的问题:

     
    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 enter(self):
            print("进冰箱装自己")
    
    class Fridge:
        def __init__(self):
            pass
        def open_door(self):
            print("冰箱打开了门")
        def close_door(self):
            print("冰箱关上了门")
    
    E=Elephant("tony")
    F1=Fridge()
    E.open(F1)
    E.enter()
    E.close(F1)
     

    就是大象和冰箱之间的关系是一种依赖关系,大象可以选择任何一个冰箱(我们可以通过类来创造出很多个 冰箱),甚至作为大象我可以选择冰箱甚至可以进高压锅,可以说此时的大象有选择的权利.

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

     
    class Boy:
        def __init__(self,name,character,girlfriend=None):
            self.name = name
            self.character = character
            self.girlfriend = girlfriend
        def xiangqin(self,girl):
            self.girlfriend = girl
        def eat(self):
            if self.girlfriend:
                print("吃东西好难,吃啥都不对")
            else:
                print("单身狗,狗粮够吗")
    class Girl:
        def __init__(self,name,boyfriend):
            self.name = name
            self.boyfriend =boyfriend
        def eat(self):
            print ("%s在吃饭" % self.name)
    
    g = Girl("排骨精","八戒")
    b = Boy("猪八戒","呵呵")
    b.xiangqin(g)
    b.eat()
     

    这是典型的一对一的关联关系,两个类的对象紧密练习着,关联关系, 其实就是我需要你,你也属于我这就是关联关系

     
    class School:
        def __init__(self,name,address,phone):
            self.name = name
            self.address = address
            self.phone = phone
            self.__teach_list = []
        def zhaopin(self,t):
            self.__teach_list.append(t)
        def display(self):
            for el in self.__teach_list:
                print(el.name,el.hobby)
    
    class Teacher:
        def __init__(self,name,gender,salary,hobby,school):
            self.name = name
            self.gender = gender
            self.salary = salary
            self.hobby = hobby
            self.school = school
    
    oldboy_bj = School("北京老男孩", "美丽富饶的沙河", "10086")
    oldboy_sh = School("北京老男孩, 上海分校", "上海浦东", "10010")
    oldboy_sz = School("北京老男孩, 深圳分校(骑士计划)", "南山区", "10000")
    
    t1 = Teacher("配齐", "男", 200000, "上课", oldboy_bj)
    t2 = Teacher("太白", "男", 150000, "开车", oldboy_bj)
    t3 = Teacher("Eggon", "男", 123456, "钻研技术", oldboy_sh)
    t4 = Teacher("高鑫", "女", 45678, "相夫教子", oldboy_sz)
    t5 = Teacher("日天", "男", 666, "看天", oldboy_sz)
    
    oldboy_bj.zhaopin(t1)
    oldboy_bj.zhaopin(t2)
    oldboy_bj.display()
    
    oldboy_sh.zhaopin(t3)
    oldboy_sz.zhaopin(t4)
    oldboy_sz.zhaopin(t5)
    oldboy_sz.display()
     

    老师必然属于⼀个学校. 换句话说,每个老师肯定有⼀个指定的工作机构. 就是学校,那老师的属性中必然关联着学校(一对多的情况)

    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.func1()
     

    总结:

    • self在访问方法的顺序: 永远先找自己的,自己的找不到再找父类的. 
    • self就是你访问方法的那个对象,先找自己, 然后在找父类的. 

    4. 类中的特殊成员

    转载于:https://www.cnblogs.com/avit/p/10209909.html

    展开全文
  • 能使人发生联想的原因是事物之间确实存在着某些联系。 (7)消息通信:这一原则要求对象之间只能通过消息进行通信,而不允许在对象之外直接地存取对象内部的属性。通过消息进行通信是由于封装原则而引起的。在OOA中...
  • 那事物之间存在着相对应的关系. 类与类之间也同样如此. 在⾯向对象的世界中. 类与类 中存在以下关系: 依赖关系 关联关系 组合关系 聚合关系 继承关系 实现关系 依赖关系 可以简单的理解,就是一个类A使用到了另一...

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

    ⼤千世界, 万物之间皆有规则和规律. 我们的类和对象是对⼤千世界中的所有事物进⾏归类. 那事物之间存在着相对应的关系. 类与类之间也同样如此. 在⾯向对象的世界中. 类与类
    中存在以下关系:

    1. 依赖关系
    2. 关联关系
    3. 组合关系
    4. 聚合关系
    5. 继承关系
    6. 实现关系

    依赖关系

    可以简单的理解,就是一个类A使用到了另一个类B,而这种使用关系是具有偶然性的、临时性的、非常弱的,但是B类的变化会影响到A。表现在代码层面,类A当中使用了类B,其中类B是作为类A的方法参数、方法中的局部变量、或者静态方法调用。注意,要避免双向依赖。一般来说,不应该存在双向依赖。

    1513667-20181109102712674-2013842305.png

    class Person:
        def eat(self, food):
            print(f'我要吃{food.name}')
        
        def read(self, book):
            print(f'我在看{book.book_name}')
            
    
    class Food:
        def __init__(self, name):
            self.name = name
            
    class Book:
        def __init__(self, book_name):
            self.book_name = book_name
    
    apple = Food('苹果')
    book = Book('红楼梦')
    p = Person()
    p.eat(apple)            # apple对象以方法参数的形式传入到p对象中使用
    p.read(book)            # 可以说是Person类是依赖于Food类和Book类
    
    # 执行结果:
    # 我要吃苹果
    # 我在看红楼梦

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

    其实这三个在代码上写法是⼀样的. 但是, 从含义上是不⼀样的.

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

    2. 聚合关系. 属于关联关系中的⼀种特例. 侧重点是xxx和xxx聚合成xxx. 各⾃有各⾃的声明周期. 比如电脑. 电脑⾥有CPU, 硬盘, 内存等等. 电脑挂了. CPU还是好的. 还是完整的个体

    3. 组合关系. 属于关联关系中的⼀种特例. 写法上差不多. 组合关系比聚合还要紧密. 比如⼈的⼤脑, ⼼脏, 各个器官. 这些器官组合成⼀个⼈. 这时. ⼈如果挂了. 其他的东⻄也跟着挂了.

    1513667-20181109102747551-1240787364.png

    我们来看一个例子:

    class Boy:
        def __init__(self, name, grilFriend):
            self.name = name
            self.grilFriend = grilFriend            # grilFriend参数以变量的形式存储在Boy类中,这就形成了关联关系
            
        def sendGift(self):
            print(f'送给女朋友{self.grilFriend.name}一个礼物')
            
    class Girl:
        def __init__(self, name):
                self.name = name
    
            
    girl = Girl('小麻烦')
    boy = Boy('马脸', girl)                         # 此时在Boy对象初始化时把Girl对象当作传参数出入类中
    boy.sendGift()
    
    # 运行结果:
    # 送给女朋友小麻烦一个礼物

    上面例子就是一个关联关系,一般男女朋友都是固定的,不可能经常更换;Girl对象作为Boy的变量存在与Boy类中,如果缺失这个属性,Boy类可能无法正常工作。其实这样的关系在生活中还有很多,比如说学生和老师:

    # 老师和学生的关系,一对多的关系  反过来就是一对一
    
    class Tearcher:
        def __init__(self, name, stuList=None):
            self.name = name
            if stuList:
                self.stuList = stuList
            else:
                self.stuList = []
                
        def addStudent(self, student):
            self.stuList.append(student)
            
        def showStudent(self):
            for stu in self.stuList:
                print(stu.id, stu.name, stu.teacher)
                
    class Student:
        def __init__(self, sid, name, teacher=None):
            self.id = sid
            self.name = name
            if teacher:
                self.teacher = teacher.name
            else:
                self.teacher = None
                
    t = Tearcher('大张伟')
    s1 = Student(1, '郭德纲')
    s2 = Student(2, '小沈阳', t)
    s3 = Student(3, '宋小宝')
    s4 = Student(4, '岳云鹏', t)
    
    t.addStudent(s1)
    t.addStudent(s2)
    t.addStudent(s3)
    t.addStudent(s4)
    
    t.showStudent()
    
    # 运行结果:
    # 1 郭德纲 None
    # 2 小沈阳 大张伟
    # 3 宋小宝 None
    # 4 岳云鹏 大张伟

    一个老师可以有多个学生,这就是一对多的关系了;如果反过来,一个学生只有一个老师,那就是一对一的关系,好了. 这就是关联关系。当我们在逻辑上出现了:我需要你,你还得属于我,这种逻辑就是关联关系,那注意这种关系的紧密程度比上⾯的依赖关系要紧密的多

    • 组合关系和聚合关系. 其实代码上的差别不⼤. 都是把另⼀个类的对象作为这个类的属性来传递和保存. 只是在含义上会有些许的不同⽽已
    • 继承关系和实现关系的内容后期再学习到继承的时候再补上

    二、类中的特殊成员

    什么是特殊成员呢?__init_()就是⼀个特殊的成员. 说⽩了. 带双下划线的那⼀坨. 这些⽅
    法在特殊的场景的时候会被⾃动的执⾏。比如:

    __init__()              # 使用 class_name() 会自动执行初始化函数__init__()
    __call__()              # 使用 instance() 会自动执行__call__()
    __getitem__()           # 执行 instance[key] 时会⾃动触发
    __setitem__()           # 执⾏ instance[key] = value 时会⾃动触发
    __delitem__()           # 执⾏del instance[key] 时会⾃动触发
    __add__()               # 当执行 instance1 + instance2 时会自动触发
    __enter__()             # 当执行with instance 时会触发,先执行__enter__函数
    __exit__()              # 执行完with语句退出时执行(with open ...)
    __str__()               # 打印一个对象时返回的时对象的__str__方法
    __repr__()              # 与repr差不多,返回的格式更为正式(比较偏底层,接近解释器)
    __hash__ = None         # 设置对象为不可hash
    __hash__()              # 自己定制hash计算方法
    __len__()               # len()调用的就是__len__
    __gt__()                # 大于或等于
    __ge__()                # 大于
    __lt__()                # 小于或等于
    __le__()                # 小于
    __eq__()                # 等于

    转载于:https://www.cnblogs.com/zpzhue1/p/9933665.html

    展开全文
  • 本节主要内容: 1. 依赖关系 2. 关联关系, 组合关系, 聚合关系 3. 继承关系, self到底是什鬼... 那事物之间存在着相对应的关系. 类与类之间也同样如此. 在面向对象的世界中. 类与类 中存在以下关系: 1. 依赖关系 ...

    本节主要内容:

    1. 依赖关系

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

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

    4. 类中的特殊成员

    ⼀. 类与类之间的依赖关系    大千世界, 万物之间皆有规则和规律. 我们的类和对象是对大千世界中的所有事物进⾏归 类. 那事物之间存在着相对应的关系. 类与类之间也同样如此. 在面向对象的世界中. 类与类 中存在以下关系:

    1. 依赖关系

    2. 关联关系

    3. 组合关系

    4. 聚合关系

    5. 继承关系

    6. 实现关系

    # 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("我是冰箱. 我会关门 ")
    #
    # class DianFanGuo:
    #     def kai(self):
    #         print("我是电饭锅 我能开 ")
    #     def guan(self):
    #         print("我是电饭锅, 我能关 ")
    #
    # # bx1 = BingXiang()
    # # bx2 = BingXiang()
    # dx = DaXiang()
    # dfg = DianFanGuo()
    #
    # dx.open(dfg)
    # dx.zhuang()
    # dx.close(dfg)

     

    # class ZhiWu:
    #     def __init__(self, name, attack, hp):
    #         self.name = name
    #         self.attack = attack
    #         self.hp = hp
    #
    #     def fight(self, js):
    #         js.hp -= self.attack
    #
    # class JiangShi:
    #     def __init__(self, name, hp, attack):
    #         self.name = name
    #         self.hp = hp
    #         self.attack = attack
    #
    #     def chi(self, zhiwu):
    #         zhiwu.hp -= self.attack
    #
    # lvluo = ZhiWu("绿萝", 20, 10)
    # js1 = JiangShi("僵尸一号", 100, 5)
    # lvluo.fight(js1)
    # lvluo.fight(js1)
    # lvluo.fight(js1)
    #
    # js1.chi(lvluo)
    # js1.chi(lvluo)
    # js1.chi(lvluo)
    # print(lvluo.hp)
    # print(js1.hp)
    二、关联关系
    1. 关联关系. 两种事物必须是互相关联的. 但是在某些特殊情况下是可以更更改和更更换的.
    2. 聚合关系. 属于关联关系中的⼀一种特例. 侧重点是xxx和xxx聚合成xxx.  各自有各自的 声明周期. 比如电脑. 电脑⾥里里有CPU, 硬盘, 内存等等. 电脑挂了了. CPU还是好的. 还是 完整的个体
    3. 组合关系. 属于关联关系中的⼀一种特例. 写法上差不多. 组合关系比聚合还要紧密. 比 如⼈人的⼤大脑, ⼼心脏, 各个器官. 这些器官组合成⼀一个⼈人. 这时. 人如果挂了了. 其他的东西 也跟着挂了.
     
    # class 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.chi()
    #
    # 老师和学生的关系. 一对多的关系  反过来就是一对一
    # class Teacher:
    #     def __init__(self, name, lst=None):
    #         self.name = name
    #         if lst == None: # 判断传递过来的参数是否是空
    #             self.lst = []
    #         else: # 传递过来的是一个列表
    #             self.lst = lst
    #
    #     # 添加学生
    #     def tianjia(self, student):
    #         self.lst.append(student)
    #
    #     def display(self):
    #         for s in self.lst: # s 是老师的学生
    #             print(s.name)
    #
    #
    # class Student:
    #     def __init__(self, num, name, teacher=None):
    #         self.name = name
    #         self.num = num
    #         self.teacher = teacher
    #
    # t = Teacher("大张伟")
    # s1 = Student(1, "郭德纲")
    # s2 = Student(2, "岳云鹏")
    # s3 = Student(3, "张鹤伦")
    # s4 = Student(4, "朱云峰")
    #
    # t.tianjia(s1) # 把学生添加给老师
    # t.tianjia(s2)
    # t.tianjia(s4)
    #
    # t.display()
    三. 继承关系.    
    在面向对象的世界中存在着继承关系. 我们现实中也存在着这样的关系. 我们说过. x是⼀一 种y, 那x就可以继承y. 这时理理解层⾯面上的. 如果上升到代码层⾯面. 我们可以这样认为. ⼦子类在不 影响父类的程序运行的基础上对父类进行的扩充和扩展. 这里.我们可以把⽗父类被称为超类或 者基类. ⼦子类被称为派⽣生类.     ⾸首先, 类名和对象默认是可以作为字典的key的
    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  对象就不可哈希了了.
     

    转载于:https://www.cnblogs.com/DanielYang11/p/9931371.html

    展开全文
  • 类与类之间关系

    2018-09-27 16:56:00
    主要内容: 1. 依赖关系 ...那事物之间存在着相对应的关系. 类与类之间也同样如此. 在面向对象的世界中. 类与类中存在以下关系:依赖关系 ,关联关系 ,组合关系 ,聚合关系 ,继承关系 ,实现关系...
  •  大千世界, 万物之间皆有规则规律,我们的类和对象是对大千世界中的所有事物进行归类,那事物之间存在着相对应的关系,类与类之间也同样如此,在面向对象的世界中. 类与类中存在以下关系:  1. 依赖关系  2. 关联...
  • 大千世界, 万物之间皆有规则规律,我们的类和对象是对大千世界中的所有事物进行归类,那事物之间存在着相对应的关系,类与类之间也同样如此,在面向对象的世界中. 类与类中存在以下关系: 1. 依赖关系 2. 关联关系 3. ...
  • 我们的类和对象是对⼤千世界中的所有事物进⾏归类, 那事物之间存在着相对应的关系。 类与类之间也同样如此,在⾯向对象的世界中类与类中存在以下关系: 1. 依赖关系 2. 关联关系 3. 组合关系 ...
  • 那事物之间存在着相对应的关系. 类与类之间也同样如此. ⼆. 关联关系.组合关系, 聚合关系其实这三个在代码上写法是⼀一样的. 但是, 从含义上是不⼀样的.1. 关联关系. 两种事物必须是互相关联的. 但是在某些...
  • 类之间的关系有五种:继承、依赖、关联、聚合、组合....关联可分为一对一、一对多多对多关联 案例:Customer(客户)对象与Orders(订单)对象之间就存在着一对多的关联关系,一个Customer(客户)可以有多个
  • java对象之间关系

    2014-02-28 20:41:03
     只要中结合了对象的实例,无论个数多少都存在 聚合的关系,   聚合是关联的一种特殊形式,它意味一种整体 / 部分( whole/part )的关系。   白色菱形直线代表聚合的关系 表示Whole 使用了Part   ...
  •  定义:聚合关系是关联关系的一种,耦合度强于关联,他们的代码表现是相同的,仅仅是在语义上有所区别:关联关系对象间是相互独立的,而聚合关系的对象之间存在着包容关系,他们之间是“整体-个体”的相互关系。...
  • 从而找出一些组成类,该整体类组成类之间就形成了聚合关系。例如一个航母编队包括海空母舰、驱护舰艇、舰载飞机及核动力攻击潜艇等。需求描述中“包含”、“组成”、“分为…部分”等词常意味聚合关系。 组合...
  • 关联关系存在着以下几种类型:一对一关系;一对多多对一关系;多对多关系 一对一关系: 对象A和对象B一一对应,最直观的例子:人和身份证的关系,一个人只拥有一张身份证,而一张身份证只会属于一个人 一对多多...
  • 如self.name self.age等1.2对象和类之间存在一个关联关系 所以对象能够找到类 但是 类不能找到对象1.3使用类名.属性 只会寻找类中的静态变量名字 使用对象.属性 会现在对象自己的命名空间中找名字。如果找不到 再到...
  • java对象间的关系

    2010-10-06 21:53:00
    白色菱形直线代表聚合的关系 表示Whole 使用了Part类中访问控制 +代表 public的属性或者方法 -代表 private的属性方法 #代表 protected的属性方法2 关联 类之间关联大多用来表示变量实例持有对其他对象...
  • 浅谈MyBatis的关联映射

    2020-06-12 12:23:39
    在关系型数据库中,多表之间存在着三种关联关系,分别为一对一、一对多多对多: 一对一 :在任意一方引入对方主键作为外键;在本中定义对方类型的对象,如A中定义B类型的属性b,B中定义A类型的属性a; ...
  • 继承关系两个类之间存在三种关系:依赖,uses-a,如果一个类的方法操纵另一个对象,我们就说一个类依赖于另一个类。聚合(关联),has-a,一个对象包含另外一个对象,聚合关系意味类A的对象包含类B的对象。继承,is-...
  • UML六大关系

    2016-06-24 09:35:40
    关联关系(Association) 定义 关联关系是类与类之间最常用的一种关系,它是一种结构化关系,用于表示一类对象与另一类对象之间有联系。...Person类与Bicycle类之间存在关联关系,这意味在Person类中需要定义一个
  • MyBatis学习 关联映射

    2020-12-13 17:38:41
    在关系型数据库中,多表之间存在着三种关联关系,分别为一对一、一对多多对多,如下图所示:一对一 一对一 在任意一方引入对方主键作为外键; 一对多 在“多”的一方,添加“一”的一方的主键作为外键; 多对多...
  • 两个类之间存在三种关系: 依赖,uses-a,如果一个类的方法操纵另一个对象,我们就说一个类依赖于另一个类。聚合(关联),has-a,一个对象包含另外一个对象,聚合关系意味类A的对象包含类B的对象。继承,is-...
  • 今天阅读了面向对象分析与设计第三章类与对象,在我们学习c++java的时候就学过类与对象,类与类之间存在联系,对象与类也存在着联系。从书中了解到,对象的本质就是一个具有状态、行为标识符的实体,结构行为...
  • # 类与类之间的关系# 1、以来关系# 2、关联关系、组合关系、聚合关系# 3、继承关系,self到底是什么鬼?# 4、类中的特殊成员# 一、类与类之间的以来关系# ⼤千世界, 万物之间皆有规则规律. 我们的类和对象是对⼤千...
  • 概述:在真正的对象化开发项目中,我们通常会将常用的业务实体抽象为特定的类,如Employee、Customer、Contact等,而多数的类之间存在着相应的关联或依存关系,如EmployeeCustomer通过Contact而产生关联、...

空空如也

空空如也

1 2 3 4 5 6
收藏数 105
精华内容 42
关键字:

对象和类之间存在着关联关系