类的空间问题与类和类之间的关系

一、类的空间问题

• 对象的属性不仅可以在__init__里面添加，还可以在类的其他方法或者类的外面添加。

  class Person:
      def __init__(self, name, sex):
          self.name = name
          self.sex = sex
  
  
      def ponder_over(self, count):
          print(self.name, '正在思考:', count)
  
  
  Bob = Person('鲍勃', '男')  # 实例化一个对象
  print(Bob.__dict__)        # 对象的原有内容
  # 在类外面可以添加：
  Bob.job = '攻城狮'
  print(Bob.__dict__ )
  
  # 类的内部也可以：
  Bob.age = 18
  print(Bob.__dict__)
  # 输出
  {'name': '鲍勃', 'sex': '男'}
  {'name': '鲍勃', 'sex': '男', 'job': '攻城狮'}
  {'name': '鲍勃', 'sex': '男', 'job': '攻城狮', 'age': 18}
  

• 类的属性不仅可以在类内部添加，还可以在类的外部添加。

  class Person:
      attribute_1 = '站立行走'
      def __init__(self, name, sex):
          self.name = name
          self.sex = sex
  
      def add(self):
          Person.attribute_3 = '会劳动'
  
  
  print(Person.__dict__)
  # 类的外部添加：
  Person.attribute_2 = '会思考'
  print(Person.__dict__)
  # 类的内部添加：
  Person.add(0)
  print(Person.__dict__)
  # 输出
  {..., 'attribute_1': '站立行走',...}
  {..., 'attribute_1': '站立行走', 'attribute_2': '会思考'...}
  {..., 'attribute_1': '站立行走', 'attribute_2': '会思考','attribute_3':'会劳动'...}
  
  

• 对象如何找到类的属性

  对象之所以可以找到类，是因为对象空间中有类对象指针这个东西

  • 对象查找属性的顺序：先从对象空间找——>类空间找——>父类空间找——>.........
  • 类名查找属性的顺序：先从本类空间找——>父类空间找——>.........
  • 上面的顺序都是单向不可逆的，类名不可能找到对象的属性。

二、类与类之间的关系

• 在⾯向对象的世界中. 类与类中存在以下关系:
  1. 依赖关系
  2. 关联关系
  3. 组合关联
  4. 聚合关联
  5. 实现关系
  6. 继承关系（类的三大特性之一：继承）

依赖关系

将一个类的对象或者类名传到另一个类的方法使用，我用你，但是你不属于我，这种关系是最弱的。

比如：

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

以看书为场景，场景中出现了人和书两种事物，人负责整个事件的掌控者，书负责被人操控。

• 首先，写出两个类，一个人类，一个书类
• 其次，人打开书或者关上书要先找到一本书
• 然后，人打开的书也是刚才找到的那本书
• 也就是说，人打开的书或者关闭的书都是同一个书
• 并且，人有换书的权利，想打开那本就打开那本书，可以有多本书

class Person:

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

    def open_book(self, b_name):
        print(f'{self.name}打开了一本名为{b_name}的书')

    def cloes_book(self, b_name):
        print(f'{self.name}合上了一本名为{b_name}的书')


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

    def open():
        print('书被打开了')

    def close():
        print('书被打开了')


Bob = Person('鲍勃')
literature_book = Book('语文')
math_book = Book('数学')
Bob.open_book(literature_book.name) # 鲍勃选择打开的是语文书
# 输出
鲍勃打开了一本名为语文的书

关联，聚合，组合关系

这三个在代码上写法是一样的，但是，从含义上是不一样的。

1. 关联关系：两种事物必须是互相关联的，但是在某些特殊情况下是可以更改和跟换的。其实就是 我需要你. 你也属于我
2. 聚合关系：属于关联关系中的一种特列，侧重点事xxx和xxx聚合成xxx，各自有各自的声明周期，比如电脑，电脑里有CPU，硬盘，内存等等，电脑挂了，CPU还是好的，还是完整的个体
3. 组合关系：也是属于关联关系中的一种特列，写法上差不多，组合关系比聚合还要紧密，比如人的大脑，心脏，各个器官，这些器官组合成一个人，这时，人如果挂了，其他东西也跟着挂了

• 关联关系

  • 例如：学校和老师之间的关系，老师属于学校，必须有学校才可以工作，但是学校也是依赖于老师的，所以老师学校应该相互依赖的。就是我用你，你还得是属于我的。

  class School:
      def __init__(self, name):
          self.name = name
          self.teacher_list = []
  
      def add_teacher(self, teacher):
          self.teacher_list.append(teacher)
  
  
  class Teacher:
      def __init__(self, name, school):
          self.name = name
          self.school = school
  
  
  s1 = School('清华大学')
  s2 = School('南京大学')
  s3 = School('哈弗大学')
  
  # 老师选择了学校
  t1 = Teacher('艾伦', s1)
  t2 = Teacher('鲍勃', s2)
  t3 = Teacher('阿比', s3)
  
  # 学校也选择了老师
  s1.add_teacher(t1.name)
  s2.add_teacher(t2.name)
  s3.add_teacher(t3.name)
  
  # 就属于我需要你，你也属于我
  print('清华大学的老师有：', s1.teacher_list)
  print('艾伦所在的学校是：', t1.school.name)
  
  # 输出
  清华大学的老师有： ['艾伦']
  艾伦所在的学校是： 清华大学
  

• 组合关系和聚合关系

  其实组合关系和聚合关系代码差别不大，

  • 组合：将一个类的对象封装到另一个类对象的属性中，就叫组合
    • 例如：通过学生查班级名字两个类：班级、学生

  class Student:
      def __init__(self, name, age, sex, number, clas):
          self.name = name
          self.age = age
          self.sex = sex
          self.number = number
          self.clas = clas
  
  
  class Class_:
      def __init__(self, cname, begin, teacher):
          self.cname = cname
          self.begin = begin
          self.teacher = teacher
  
  
  first_grade = Class_('一年级', '2018-9-10', '小杨')
  second_grade = Class_('二年级', '2019-9-10', '小名')
  
  Bob = Student('鲍勃', '8', '男', 10, first_grade)
  Ada = Student('艾达', '9', '男', 10, second_grade)
  
  print(Bob.clas.cname)  # 查Bob所在班级的名字
  # 输出
  一年级