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）的多态