python的继承多态以及异常处理

1.单继承

 # 动物类
 class Animal(object):

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

     def run(self):
         print("%s 喜欢跑步" % self.__name)

     def sleep(self):
         print("%s 喜欢睡觉" % self.__name)

     def getName(self):
         return self.__name

 # 猫类
 class Cat(Animal):

     def __init__(self, name, type):
         # 调用父类构造
         # 采用super
         super(Cat, self).__init__(name)
         # 采用超类
         # Cat.__init__(name)

         self.type = type

     def bark(self):
         print("%s 喜欢叫" % self.getName())

 # 大黄猫
 class BigYellowCat(Cat):

     def __init__(self, name):
         # super（）可以查找父类以及父类的父类的方法,但是构造访问上一个父类
         # super（A，self），表示查找A类的父类以及父类的父类方法
         super(Cat, self).__init__(name)
         self.color = "黄"

     def __str__(self):
         return ("%s 是一只大%s 猫" % (self.getName(), self.color))

 cat = BigYellowCat("TOM")

 print(cat)
 cat.run()
 cat.sleep()
 cat.bark()

单继承，只需要在创建类是增加（）添加继承的类名，即class A(B):....
上面可以看到，Cat类继承了Animal类，那么将获取Animal中所有公有的属性和方法，私有的属性和方法不继承
在创建对象时会默认调用构造方法，在继承中只会调用当前类的构造方法，有些属性定义在父类中，那么如何进行初始化呢？
这里采用两种方法，一种是采用超类，即类名.__init__()，但这里不推荐，这种格式一般是用来访问类属性的，
第二种方式是采用super()，通过super就能访问父类的所有方法，如果其父类有重写了父类的父类方法，那么会优先访问父类方法
当然需要定位访问某一个父类的方法，需要采用super(A, self)，表示A类的父类（包括其父类的父类）

2.类方法和类属性

 # 动物类
 class Animal(object):

     # 定义类属性
     __count = 0

     # 定义类方法
     @classmethod
     def getCount(cls):
         return cls.__count

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

     def __new__(cls, *args, **kwargs):
         # 记录创建了多少个对象
         cls.__count += 1
         return super(Animal, cls).__new__(cls)

 print(Animal.getCount())

 cat = Animal("猫")
 dog = Animal("狗")

 print(Animal.getCount())

定义类属性比较简单，定义类方法需要关键字@classmethod，cls就表示当前类，与self的作用类似，调用时直接用类名.进行访问

3.静态方法

class Tool(object):

    @staticmethod
    def function():
        print("我是静态方法！")

Tool.function()

静态方法与类本身没有任何关系，Tool类可以将它理解为将多个函数聚集在一起的工具类，通常将能够全局用的方法封装在这里

4.多继承

 class Ear(object):

     def getEars(self):

         return " 耳朵"

     def fun(self):
         print("Ear")

 class Nose(object):

     def getNose(self):

         return " 鼻子"

     def fun(self):
         print("Nose")

 class Eyes(object):

     def getEyes(self):

         return " 眼睛"

     def fun(self):
         print("Eyes")

 class  Face (Nose, Eyes, Ear):

     def getFace(self):

         print("我有:", end="")

         # 能够调用所有继承的方法
         print(self.getEars() + self.getEyes() + self.getNose())

 face = Face()
 face.getFace()
 face.fun()

多继承能够将所有父类的方法进行调用，但如果父类方法出现相同方法名时，根据继承的先后次序，优先运行最先加载的

5.多态

 class Person(object):

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

     def fun(self):
         print(self.name)

 class Student(Person):

     def __init__(self, name, score):
         super(Student, self).__init__(name)
         self.score = score

     def fun(self):
         print("%s : %.2f分 " % (self.name, self.score))

 s1  = Person("ssss")
 s1.fun()

 s2 = Student("xxxx", 80.2)
 s2.fun()

python的多态比较简单，只是简单的涉及方法重写的问题，如需要深入了解可学习一下其他语言（如java）的多态