python-类与类之间的关系

目录

• 类的关系

类的关系

• 依赖关系，关联关系，组合关系，继承关系

• 两个类之间的简单交互，只需要把另一个类的对象传递进去，调用其方法or属性

  # 我们先来写一个人狗大战，人打狗，狗咬人
  
  class Dog(object):
  
      def __init__(self, name, age, xueliang, gongjili):
          # 初始化方法，狗有自己的姓名，年龄，血量，狗的伤害值
          self.dog_name = name
          self.dog_age = age
          self.dog_xueliang = xueliang
          self.dog_gongjili = gongjili
  
      def bite_people(self, people):
          # 这里狗要咬一个人，需要传入一个人的对象，知道咬的人是谁
          people_surplus_xueliang = people.people_xueliang - self.dog_gongjili
          print("这只[{}]狗咬了人[{}]{}血,还剩下{}血".format(self.dog_name, people.people_name, self.dog_gongjili,
                                                  people_surplus_xueliang))
  
  
  class People1(object):
  
      def __init__(self, name, age, xueliang, gongjili):
          # 初始化方法，人有自己的姓名，年龄，血量，人的攻击力
          self.people_name = name
          self.people_age = age
          self.people_xueliang = xueliang
          self.people_gongjili = gongjili
  
      def beat_dog(self, dog):
          # 这里人咬打狗，需要传入一个狗的对象，知道是谁打了那只狗
          dog_suplus_xueliang = dog.dog_xueliang - self.people_gongjili
          print("这个人[{}]打了这只[{}]{}血，还剩下{}血".format(self.people_name, dog.dog_name, self.people_gongjili,
                                                   dog_suplus_xueliang))
  
  
  d = Dog("小黑", 18, 100, 50)  # 创建一个狗的对象
  p = People1('山山', 24, 100, 70)  #创建一个人的对象
  
  d.bite_people(p) # 狗的方法中传入人的对象，调用人的方法or私有属性，这样两个对象就有了简单的交互
  p.beat_dog(d)
  

• 依赖关系

  # 依赖关系是所有关系中紧密型最低，你中有我，但我中没有你
  
  class Dog(object):
  
      def __init__(self,name,age):
          self.name = name
          self.age = age
  
      def zhuren(self,p_obj):
          print("hi,大家好，我是{},今年{}岁，我的主人是{}".format(self.name,self.age,p_obj.name))
  
  class Person(object):
  
      def __init__(self,name):
          self.name = name
  
  d = Dog('小黑',12)
  p = Person('山山')
  
  d.zhuren(p)  # 传入人的对象，dog依赖于person这个类。这样才能知道狗的主人是谁，这就是依赖关系
  
  

• 组合关系：将一个类的对象封装到另一个对象的属性中去，就叫组合

  class Student():
  
      def __init__(self,name,age,clas,iphone,cls_obj):
          """
          学生类初始化方法
          :param name: 学生姓名
          :param age: 学生年龄
          :param clas: 学生班级
          :param iphone: 学生手机号
          """
          self.name = name
          self.age = age
          self.clas = clas
          self.iphone = iphone
          self.cla_obj = cls_obj
  
  
  class Clas():
  
      def __init__(self,teacher,begin_time):
          """
          初始化方法，
          :param teacher: 老师名
          :param begin_time: 开班时间
          """
          self.teacher = teacher
          self.begin_time = begin_time
  
  # s = Student('山山',24,'无聊班级',1300000000)
  # c = Clas('饭饭','2020-02-02')
  
  # 现在我想查询山山的开班时间，我该如何查看呢》？
  # 我是不是定义一个变量传入Clas的对象，再通过这个对象进行调用就可以了呢，哈哈哈
  c = Clas('饭饭','2020-02-02')
  s = Student('山山',24,'无聊班级',1300000000,c)
  print(s.cla_obj.teacher)
  print(s.cla_obj.begin_time)
  
  输出结果
  饭饭
  2020-02-02
  

• 继承关系

  继承（英语：inheritance）是面向对象软件技术当中的一个概念。如果一个类别A“继承自”另一个类别B，就把这个A称为“B的子类别”，而把B称为“A的父类别”也可以称“B是A的超类”。继承可以使得子类别具有父类别的各种属性和方法，而不需要再次编写相同的代码。在令子类别继承父类别的同时，可以重新定义某些属性，并重写某些方法，即覆盖父类别的原有属性和方法，使其获得与父类别不同的功能。另外，为子类别追加新的属性和方法也是常见的做法。

  • 子类无任何属性和方法时，此时用的是父类的属性和方法

  class Animal(object):
  
      def __init__(self, name, age, sex):
          self.name = name
          self.age = age
          self.sex = sex
  
      def eat(self):
          print("{}在吃饭".format(self.name))
  
  
  class Person(Animal):
      pass
  
  p = Person('山山', 18, '男')  # 此时Person类是没有定义任何东西，但是它直接可以使用父类的属性
  print(p.name)
  

  • 子类中有，但是父类没有的属性or方法时，优先使用子类的

  class Animal(object):
  
      def __init__(self, name, age, sex):
          self.name = name
          self.age = age
          self.sex = sex
  
      def eat(self):
          print("{}在吃饭".format(self.name))
          
  class Dog(Animal):
  
      def __init__(self, name, age, sex, breed):  # breed品种
          self.name = name
          self.age = age
          self.sex = sex
          self.breed = breed
  
      def run(self):
          print("这个{}品种的狗在跑".format(self.breed))
  
  d = Dog('小黑', 2, '公', '京巴')  # 此时父类中没有breed的属性，但是子类有，所以使用的是子类的属性
  print(d.breed)
  d.run()
  

  • 子类中有，父类中也有相同名称的属性or方法，优先使用子类的(方法的重写)

  class Animal(object):
  
      def __init__(self, name, age, sex):
          self.name = name
          self.age = age
          self.sex = sex
  
      def eat(self):
          print("{}在吃饭".format(self.name))
   
  class Pig(Animal): # 完全重写父类的方法，此时只会用子类的
      
      def __init__(self，breed) # 调用时只需要传入一个参数即可
      	self.breed = breed
  
  
  
  class Person(Animal):
  
      def eat(self):
          print('这是Person类的方法')
          
  pig = Pig('短尾猪')
  print(pig.breed)
  
  p = Person('山山', 18, '男')  # 此时Person类是没有定义任何东西，但是它直接可以使用父类的属性
  p.eat()
  
  

  • 不想完全重写父类的方法，在子类中也使用父类的方法

  # 此时想在子类中也应用父类的方法
  # 方法一
   class Pig(Animal):
  
       def eat(self):
           Animal.eat(self)
           print('这个事Pig类的eat方法')
  
  pig = Pig('猪猪',20,'公')
  pig.eat()
  
  # 方法二
  class Pig(Animal):
  
      def eat(self):
          super(Pig,self).eat()   #使用super，格式super(子类名，self).方法
          # super().eat()
          print('这个事Pig类的eat方法')
  
  pig = Pig('猪猪',20,'公')
  pig.eat()
  

  • 不想完全重写父类的属性，在子类中也使用父类的属性

  # 不完全重写父类的私有属性
  # 方法一
  class Pig(Animal):
      def __init__(self,name,age,sex,breed):
          Animal.__init__(self,name,age,sex)
          self.breed = breed
  
      def eat(self):
          super(Pig,self).eat()
          print('这个事Pig类的eat方法')
  
  
  方法二
  class Pig(Animal):
      def __init__(self,name,age,sex,breed):
          super(Pig,self).__init__(name,age,sex)
          # super().__init__(name,age,sex)
          self.breed = breed
  
      def eat(self):
          super(Pig,self).eat()
          print('这个事Pig类的eat方法')
  
  pig = Pig('猪猪',20,'公','短尾猪')
  print(pig.name)
  print(pig.breed)
  
  输出结果：
  猪猪
  短尾猪