面向对象----继承

面向对象三大特性

1.封装：根据职责将属性和方法封装到一个抽象的类中

2.继承：实现代码的重用，相同的代码不需要重复的写

3.多态：不同类的对象调用相同的方法，产生不同的结果，增加代码的灵活度

现在我们讲继承，继承分为单继承和多继承。

1.继承的概念：子类拥有父类的所有方法和属性(子类只需封装自己特有的方法)

2.继承的语法

class 类名(父类)

        def 子类特有的方法

子类继承自父类，可以直接享受父类中已经封装好的方法

子类中应该根据自己的职责，封装子类特有的属性和方法

实例演练：

class Animal():

    def eat(self):

        print '吃'

    def drink(self):

        print '喝'

    def run(self):

        print '跑'

    def sleep(self):

        print '睡'

class Cat(Animal):

    # 子类拥有父类的所有属性和方法

    def call(self):

        print '喵喵～'

fentiao = Cat()

fentiao.eat()

fentiao.drink()

fentiao.run()

fentiao.sleep()

fentiao.call()

继承的传递性：（爷爷 父亲 儿子）

1.C类从B类继承，B类又从A类继承

2.那么C类就具有B类和A类的所有属性和方法

子类拥有父类以及父类的父类中封装的所有属性和方法

实例演练：

class Animal():

    def eat(self):

        print '吃'

    def drink(self):

        print '喝'

    def run(self):

        print '跑'

    def sleep(self):

        print '睡'

class Cat(Animal):

    # 子类拥有父类的所有属性和方法

    def call(self):

        print '喵喵～'

class Hellokitty(Cat):

    def speak(self):

        print '我可以说日语'

class Dog(Animal):

    def bark(self):

        print '旺旺～'

# 创建一个hellokitty对象

kt = Hellokitty()

kt.speak()

# 子类可以继承自父类的所有属性和方法

kt.call()

# 继承的传递性，子类拥有父类和父类的父类的属性和方法

kt.eat()

kt.drink()

kt.run()

kt.sleep()

dog = Dog()

dog.sleep()

dog.drink()

dog.call()

重写父类方法有两种情况：

1.覆盖父类的方法

2.对父类方法进行扩展

 

1.覆盖父类的方法

如果在开发中，父类的方法的实现和子类方法的实现完全不同，就可以使用覆盖的方式，在

子类中重新编写父类的方法。

具体实现方式，就相当于在子类中定义了一个和父类同名的方法并且实现重写之后，在运行

时，只会调用子类的重写方法，而不会再调用父类封装的方法。

实例演练：

class Animal():

    def eat(self):

        print '吃'

    def drink(self):

        print '喝'

    def run(self):

        print '跑'

    def sleep(self):

        print '睡'

class Cat(Animal):

    # 子类拥有父类的所有属性和方法

    def call(self):

        print '喵喵～'

class Hellokitty(Cat):

    def speak(self):

        print '我可以说日语'

    def call(self):

        print '偶哈呦 空你起哇'

kt = Hellokitty()

# 如果子类中，重写了父类的方法

# 在运行中，只会调用子类中重写的方法，不会调用父类的方法

kt.call()

2.对父类的方法进行扩展

如果在开发中，子类的方法实现包含有父类的方法实现

(父类原本封装的方法实现是子类方法的一部分

就可以使用扩展方法)

1.在子类中重写父类的方法

2.在需要的位置使用父类名.方法(self) 来调用父类方法的执行

(使用父类名称调用父类方法)

3.代码其他的位置针对子类的需求，编写子类特有的代码实现

实例演示：

class Animal():

    def eat(self):

        print '吃'

    def drink(self):

        print '喝'

    def run(self):

        print '跑'

    def sleep(self):

        print '睡'

class Cat(Animal):

    # 子类拥有父类的所有属性和方法

    def call(self):

        print '喵喵～'

class Hellokitty(Cat):

    def speak(self):

        print '我可以说日语'

    def call(self):

        print '偶哈呦 空你起哇'

        # 调用原本在父类中封装的方法

        Cat.call(self)

        print '#@!#@!#@!'

kt = Hellokitty()

# 如果子类中，重写了父类的方法

# 在运行中，只会调用子类中重写的方法，不会调用父类

kt.call()

 

实例演练（初始化函数也会被覆盖，因此也需要重写或者扩展）：

class Bird():

    def __init__(self):

        self.hungry = True

    def eat(self):

        if self.hungry:

            print 'Aaaaaa...'

            self.hungry = False

        else:

            print 'no Thanks!'

class SongBird(Bird):

    def __init__(self):

        self.sound = 'Squawk!'

        Bird.__init__(self)

    def sing(self):

        print self.sound

# bird = Bird()

# bird.eat()

littlebird = SongBird()

littlebird.eat()

littlebird.sing()

多继承

子类拥有一个父类叫做单继承

子类可以拥有多个父类，并且具有所有父类的属性和方法

例如：孩子会继承自己父亲和母亲的特性

语法：

calss 子类名（父类名1，父类名2...）

pass

class A(object):

    def test(self):

        print 'A----test 方法'

    def demo(self):

        print 'A----demo方法'

class B:

    def demo(self):

        print 'B-----demo 方法'

    def test(self):

        print 'B-----test 方法'

class C(B,A):       ----那个父类写在前面就调用那个类

    """多继承可以让子类对象，同时具有多个父类的属性和方法"""

    pass

c = C()

c.test()

c.demo()