12-继承和多态

继承的基本语法

class 类B(类A):
         pass

称为类B继承自类A

• 特点：B类的对象可以使用A类的属性和方法
• 优点：代码复用

名词：

• 类A：父类或基类
• 类B：子类或派生类

子类重写父类的同名方法

重写：子类定义和父类名字相同的方法
为什么重写：父类中的方法不能满足子类对象的需求，所以要重写
重写之后的特点：子类对象调用子类自己的方法，不再调用父类的方法，父类对象调用父类自己的方法

class Dog(object):

    def bark(self):
        print "汪汪叫"

class XTQ(Dog):

    def bark(self):
        print "嗷嗷叫"

dog = Dog();
xtq = XTQ();

dog.bark()
xtq.bark()

子类调用父类中的方法

子类中调用父类的同名方法

class XTQ(Dog):

    def bark(self):
        print "嗷嗷叫"

    def see_host(self):
        print "看见主人了"

        # 方法一：父类名.方法名(self, 其他参数)，如果是对象调用方法名，不用
        # 传递self 给形参
        # 如果是通过类名.方法名() 调用，需要手动把self传递给形参
        Dog.bark(self)

        # 方法二： super(当前类, self).方法名()
        super(XTQ,self).bark()

        # 方法三：是方法二的简写
        super().bark()

继承父类后的的init写法

class Dog(object):

    def __init__(self,name):
        self.age = 0.0
        self.name = name;

class XTQ(Dog):

    # 子类重写了父类的__init__方法，默认不再调用父类的__init__方法，需要手动
    # 调用父类的__init__方法
    # 如果子类重写了__init__方法，需要在子类中的init方法中添加从父类继承的属性
    `def __init__(self,name,color):`

        `super(XTQ, self).__init__(name)`
        self.color = color

多继承

如果一个类有两个以上的父类，就把这种关系称为多继承，子类在进行方法调用时如果两个父类存在相同的方法，会优先调用子类声明时排在前面的父类的方法

class Dog(object):

    def bark(self):
        print "汪汪叫"

    def eat(self):
        print "啃骨头"

class God(object):

    def play(self):
        print "在云中"

    def eat(self):
        print "吃仙丹"

class XTQ(God,Dog):
    pass

xqt = XTQ()
xqt.play()
xqt.bark()

# 两个父类中存在相同方法，那么在进行方法调用时会优先调用排在前面的类的方法
xqt.eat()

多继承中调用指定父类的方法

• 下面方法可以查看当前类的继承顺序链，也叫做方法的调用顺序

print(XTQ.__mro__)

子类有多个父类的时候，通过下面的方式指定调用哪个父类的方法：

class XTQ(God,Dog):

    def eat(self):
        print "子类重写eat方法，调用子类自己的方法"

        # 调用指定父类中的方法
        # 方法一
        Dog.eat(self)

私有属性

封装的意义：

1. 将属性和方法放到一起做为一个整体，然后通过实例化对象来处理
2. 隐藏内部实现细节，只需要和对象及其属性和方法交互就可以了
3. 对类的属性和方法增加 访问权限权限

私有权限

在属性名和方法名前面加上两个下划线

1. 类的私有属性和私有方法都不能通过对象直接访问，但是可以在本类内部访问
2. 类的私有属性和私有方法，都不会被子类继承，子类也无法访问
3. 私有属性和私有方法往往用来处理类的内部事情，不通过对象处理，起到安全作用
4. 如果想要访问和使用私有属性：定义一个公有的方法，通过这个方法使用
5. python中的私有本质是 修改属性的名字，在创建对象的时候，会自动修改属性名字，在属性名的前边加上 _类名称

通过 对象.__dict__ 可以查看对象具有的属性信息，类型是字典，字典的 key 是属性名，字典的 value 是属性值，类名.__dict__ 则可以查看类对象具有的属性

wang = People()
print wang.__dict__

私有属性示范：

class People(object):
    def __init__(self):
        self.__icbc_money = 0

    def get_money(self):
        return self.__icbc_money

    def set_money(self, money):
        self.__icbc_money += money

wang = People()
print wang.__dict__

# 通过这种方式其实是添加一个公有属性，不是添加私有属性
wang.__icbc_money = 1000;
print wang.__icbc_money

# 访问私有属性
print (wang.get_money())
# 修改私有属性
wang.set_money(-500)
print (wang.get_money())

私有方法

• 在方法的前边加上两个下划线，就为私有方法
• 不能在类外部访问
• 作用：一般作为类内部的方法使用，不让外部调用的时候去定义，保证业务逻辑不被破坏

class Sheep(object):

    def born(self):
        print "生了一只小羊"
        self.__sleep()

    def __sleep(self):
        print "休息一周"

sh = Sheep()
sh.born()

类属性

• 对象（实例对象）：通过 class 定义的类创建的，即通过类实例化来的，又称为实例，实例对象

• 类（类对象）：通过 class 定义的，又称为类对象，是 python 解释器在创建类的时候自动创建的

  • 作用
    • 1.通过类对象，去定义实例对象
    • 2. 类对象可以保存一些属性信息，称为类属性
    • 类属性的定义：在类内部，方法外部定义的变量就是类属性

• 如何确定是类属性还是实例属性？

  • 如果属性值变化时所有的实例属性值都要改变那就可以定义为类属性

• 访问类属性：类名.属性

• 如果不存在和实例属性名相同的类属性，则可以使用实例对象访问类属性的值

• 如果实例对象和类对象存在同名，则通过实例对象访问的一定是实例属性

class Cat(object):
    # 定义类属性，类名
    class_name = "狗类"
    def __init__(self,name,age):
        self.name = name
        self.age = age

print Cat.class_name
Cat.class_name = "猫类"
print Cat.class_name

类方法

• 实例方法：类中定义的方法，就是实例方法，第一个参数是 self，表示实例对象
• 类方法：使用 @classmethod 装饰的方法，称为类方法，第一个参数是 cls，代表的是类对象自己

什么情况定义为实例方法，什么情况定义为类方法？

• 1. 如果在方法中使用了实例属性，那么该方法只能定义为实例方法
• 2. 前提：不需要使用实例属性，需要使用类属性，可以将这个方法定义为类方法

类方法的定义和使用如下所示：

class Cat(object):
    # 定义类属性，类名
    class_name = "狗类"
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def play(self):
        print "小狗在快乐的玩耍"

    def getClassName(self):
        return Dog.class_name

    # cls是类方法的默认形参
    @classmethod
    def get_class_name(cls):
        return cls.class_name

# 类方法的调用，以下两种方式均可
cat = Cat("小猫", 5)
print cat.get_class_name()
print Cat.get_class_name()

静态方法

• 使用 @staticmethod 装饰的方法称为静态方法，对参数没有特殊要求，可以有，也可以没有
• 不需要使用实例属性，也不需要使用类属性的时候，可以将这个方法定义为静态方法

静态方法的定义和使用如下所示：

class Cat(object):
    # 定义类属性，类名
    class_name = "狗类"
    def __init__(self,name,age):
        self.name = name
        self.age = age

    @staticmethod
    def show_info():
        print "这是一个静态方法"

cat.show_info()
Cat.show_info()

多态

在需要使用父类对象的地方，也可以使用子类对象，这种情况就叫多态，比如，在函数中，需要调用第一个父类对象的方法，那么我们也可以在这个地方调用子类对象的方法，传入不同的参数表现为不同的结果

如何在程序中使用多态？

可以按照以下几个步骤来写代码：

1. 子类继承父类
2. 子类重写父类中的方法
3. 通过对象调用这个方法

class Dog(object):

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

    def play(self):
        print "愉快地玩耍"

class XTQ(Dog):

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

    def play(self):
        print "啸天太在玩耍"


# 定义一个共同的方法
def play_with_dog(obj_dog):
    obj_dog.play()

dog = Dog("大黄")
play_with_dog(dog)

xtq = XTQ("啸天犬")
play_with_dog(xtq)