~~核心编程（四）：面向对象——单继承&复写~~

进击のpython

*****

继承

---

继承的出现！就是一个作用！

为了节省代码！

为什么说节省代码？

你爸爸要是王健林

你是不是就不用愁怎么获得钱了？

为啥？

是不是钱已经有了！

直接拿来用就行了！

我们想一下奥

狗和人是不是都会吃东西？

那么吃东西这个东西是不是算是他俩的共有属性？

那我就可以把这个吃东西当作父类，让人和狗继承

# -*- coding: utf-8 -*-
# @Time    : 2019.07.16
# @Author  : 爪爪
# @Url     : https://www.cnblogs.com/jevious/

class Animals:

    def __init__(self, name, old):
        self.name = name
        self.old = old
        print(f"{name}，{old}岁")

class Dog(Animals):  # 是不是原先都是没写的？？现在就是有用的了！
    pass

class Person(Animals):
    pass

p = Person("zhangsan", 18)

d = Dog("ponny", 10)

以前Dog类后面不是没有括号嘛？

这回有了！括号里是他继承的父类

可以看出来，尽管Dog里面没有函数体

但是也看到了，执行了父类的代码

所以也就看到了继承了父类吧！

同时不光继承父类，也能够有自己的方法调用！

# -*- coding: utf-8 -*-
# @Time    : 2019.07.16
# @Author  : 爪爪
# @Url     : https://www.cnblogs.com/jevious/

class Animals:

    def __init__(self, name, old):
        self.name = name
        self.old = old
        print(f"{name}，{old}岁")

class Dog(Animals):
    pass

class Person(Animals):

    def info(self):
        print(f"{self.name}是个人！")

p = Person("zhangsan", 18)

d = Dog("ponny", 10)

p.info()

---

• 属性&方法重写

  比如说我们在刚才的父类里定义了动物类型是哺乳动物，因为哺乳动物占大多数嘛

  但是有些动物就不是哺乳动物，我们继承了父类，那这个哺乳动物的这个属性

  也就跟着过来了，我们想要修改他

  很容易，只需要在特殊动物上自己重新定义就行

  # -*- coding: utf-8 -*-
  # @Time    : 2019.07.16
  # @Author  : 爪爪
  # @Url     : https://www.cnblogs.com/jevious/
  
  class Animals:
      a_type = "哺乳"
  
      def __init__(self, name, old):
          self.name = name
          self.old = old
  
          print(f"{name}，{old}岁，是{self.a_type}动物")
  
  class Dog(Animals):
      pass
  
  class Person(Animals):
  
      def info(self):
          print(f"{self.name}是个人！")
  
  class Snack(Animals):
      a_type = "冷血动物"
      pass
  
  p = Person("zhangsan", 18)
  s = Snack("sheshe", 2)
  d = Dog("ponny", 10)
  

  zhangsan，18岁，是哺乳动物
  sheshe，2岁，是冷血动物动物
  ponny，10岁，是哺乳动物
  

  同理，方法也可以这样重写

  # -*- coding: utf-8 -*-
  # @Time    : 2019.07.16
  # @Author  : 爪爪
  # @Url     : https://www.cnblogs.com/jevious/
  
  class Animals:
      a_type = "哺乳"
  
      def __init__(self, name, old):
          self.name = name
          self.old = old
  
          print(f"{name}，{old}岁，是{self.a_type}动物")
  
      def info(self):
          print(f"{self.name}是个{self.a_type}动物！")
  
  class Dog(Animals):
      pass
  
  class Person(Animals):
  
      def info(self):
          print(f"{self.name}是个人！")
  
  class Snack(Animals):
      a_type = "冷血动物"
  
      def info(self):
          print(f"我是{self.name}的父类重写")
  
      pass
  
  p = Person("zhangsan", 18)
  s = Snack("sheshe", 2)
  d = Dog("ponny", 10)
  
  d.info()
  
  p.info()
  
  s.info()
  

  zhangsan，18岁，是哺乳动物
  sheshe，2岁，是冷血动物动物
  ponny，10岁，是哺乳动物
  ponny是个哺乳动物！
  zhangsan是个人！
  我是sheshe的父类重写
  

  我的Snack类觉得你父类里面的info方法写的不好

  我想自己重新写一个

  所以就在自己的类里重新写上这个方法

  重新定义（--init--也可以这么搞）

  也可以看出来

  当属性相同或者方法相同的时候

  以子类为准！

---

• 同时执行子类&父类方法

  那我有没有另外的一种情况

  我Snack觉得你父类的info方法写的挺好，但是还不够好

  我不修改你，我想在你的基础上再加点

  怎么做呢？

  # -*- coding: utf-8 -*-
  # @Time    : 2019.07.16
  # @Author  : 爪爪
  # @Url     : https://www.cnblogs.com/jevious/
  
  class Animals:
      a_type = "哺乳"
  
      def __init__(self, name, old):
          self.name = name
          self.old = old
  
          print(f"{name}，{old}岁，是{self.a_type}动物")
  
      def info(self):
          print(f"{self.name}是个{self.a_type}动物！")
  
  class Snack(Animals):
      a_type = "冷血动物"
  
      def info(self):
          Animals.info(self) # 在这呢！
          print(f"我是{self.name}的父类重写")
  
      pass
  
  s = Snack("sheshe", 2)
  
  s.info()
  

  sheshe，2岁，是冷血动物动物
  sheshe是个冷血动物动物！
  我是sheshe的父类重写
  

  办法就是我先调用一下你父类的这个方法

  然后我再继续写，这样就会先打印父类的，再打印你新加的东西

  注意奥，要把self参数传进去

  ---

  那好了，我又想起了他 --init--

  我要是想再加个参数怎么做呢？

  例如：

  这是原先父类的（self, name, old）

  我想在我的Snack里变成（self, name, old，sex）

  怎么搞（直接加的是可以的，不用说了）

  还是可以向上面一样，先调用父类，再继续

  # -*- coding: utf-8 -*-
  # @Time    : 2019.07.16
  # @Author  : 爪爪
  # @Url     : https://www.cnblogs.com/jevious/
  
  class Animals:
      a_type = "哺乳"
  
      def __init__(self, name, old):
          self.name = name
          self.old = old
  
          print(f"{name}，{old}岁，是{self.a_type}动物")
  
      def info(self):
          print(f"{self.name}是个{self.a_type}动物！")
  
  class Snack(Animals):
      a_type = "冷血动物"
  
      def __init__(self, name, old, sex):
          Animals.__init__(self, name, old)  # 看这里！！！
          self.sex = sex
  
      def info(self):
          Animals.info(self)
          print(f"我是{self.name}的父类重写")
          print(f"这是我的性别{self.sex}")
  
      pass
  
  s = Snack("sheshe", 2, "man")  # 这里就要传三个参数
  
  s.info()
  

  sheshe，2岁，是冷血动物动物
  sheshe是个冷血动物动物！
  我是sheshe的父类重写
  这是我的性别man
  

  当然，你也会发现，这么写，稍微有点笨

  所以在Py3中，我们可以用一个函数来解决这个问题！

  super（）（以前讲的，说面向对象再讲，有印象吧）

  怎么用呢？

  # -*- coding: utf-8 -*-
  # @Time    : 2019.07.16
  # @Author  : 爪爪
  # @Url     : https://www.cnblogs.com/jevious/
  
  class Animals:
      a_type = "哺乳"
  
      def __init__(self, name, old):
          self.name = name
          self.old = old
  
          print(f"{name}，{old}岁，是{self.a_type}动物")
  
      def info(self):
          print(f"{self.name}是个{self.a_type}动物！")
  
  class Snack(Animals):
      a_type = "冷血动物"
  
      def __init__(self, name, old, sex):
          # Animals.__init__(self, name, old)  # 看这里！！！
          super(Snack, self).__init__(name, old)  # 看这里！！！
          self.sex = sex
  
      def info(self):
          Animals.info(self)
          print(f"我是{self.name}的父类重写")
          print(f"这是我的性别{self.sex}")
  
      pass
  
  s = Snack("sheshe", 2, "man")  # 这里就要传三个参数
  
  s.info()
  

  super这里面啊应该写上你当前子类的名字（Snack）和 self

  然后 . 一下，后面是你要修改的方法，去掉self，只留下形参

  但是啊，这个人的记性啊，是真的差！怎么办呢？

  程序猿就为了能更简单一点！

  就有了如下的写法：

  # -*- coding: utf-8 -*-
  # @Time    : 2019.07.16
  # @Author  : 爪爪
  # @Url     : https://www.cnblogs.com/jevious/
  
  class Animals:
      a_type = "哺乳"
  
      def __init__(self, name, old):
          self.name = name
          self.old = old
  
          print(f"{name}，{old}岁，是{self.a_type}动物")
  
      def info(self):
          print(f"{self.name}是个{self.a_type}动物！")
  
  class Snack(Animals):
      a_type = "冷血动物"
  
      def __init__(self, name, old, sex):
          # Animals.__init__(self, name, old)  # 看这里！！！
          # super(Snack, self).__init__(name, old)  # 看这里！！！
          super().__init__(name, old)  # 看这里！
          self.sex = sex
  
      def info(self):
          Animals.info(self)
          print(f"我是{self.name}的父类重写")
          print(f"这是我的性别{self.sex}")
  
      pass
  
  s = Snack("sheshe", 2, "man")  # 这里就要传三个参数
  
  s.info()
  

  更简单了是吧！

  所以知道选哪个了吧！

  别跟我说是不是只有--init--能用super

  咋的啊？--init-- 多个啥啊？

  不是函数啊！

  这个函数都能用

  别的函数凭啥不能用？

---

*这是单继承*
*多继承在后面*