【最详解面向对象编程2】——面向对象三大特征——如桃花来

这节我们要讲述的是面向对象的三大特征：继承、封装、多态。以及拓展知识点：私有权限。

无需惊慌，只是看起来比较复杂罢了

继承：

• 这里的继承跟生活中子女继承父辈的财产有共同的点。
• 代码继承指的是子类默认继承父类的属性和方法。
• 继承的好处是节省代码量，简洁高效
• 所有类都默认继承object基类，继承在所有类中都存在

实例演示：

冤有头，债有主。继承谁的就要在括号里面写出来，要清晰明了。

#定义一个父类
class Person(object):
    def __init__(self,height):
        self.height = height
        self.sex = "男"


    def run(self):
        print("我可以跑步")


class Boy(Person):
    # 括号里面的类，表示继承的是哪个类
    # 继承Person类之后，就拥有person类里面所有的属性和方法
    pass

if __name__ == '__main__':
#父类需要传入多少参数，这里对应的也要添加参数进去
    xiaoming = Boy(1.80)
    print(xiaoming.sex)
    xiaoming.run()

呈现效果：

继承的很顺利，属性和方法都可以正常调用。
你以为就这么简单？那我只能说你是too young too simple了。

重写方法：

原因：

试想一下如果，子类和父类的方法重名了该怎么办呢？我在调用的时候，到底是用子类的方法还是父类的方法？

• 注意： 当子类和父类拥有同一个方法的时候，

• 子类会优先的去继承自己本身类的方法（Python内部规定）也就是近水楼台先得月。

• 那我想用父类该怎么办呢？到手的财产不能没了呀。所以我们引入了重写的概念，让子类重新定义父类的方法，让一个方法具有不同的行为。

关键字： super()

#定义一个父类
class Person(object):
    def __init__(self):
        self.height = 1.80
        self.sex = "男"


    def run(self):
        print("我可以跑步")


class Boy(Person):
    # 括号里面的类，表示继承的是哪个类
    # 继承Person类之后，就拥有person类里面所有的属性和方法
    def run(self):
        #重写可以同时启用子类和父类的方法
        super().run()
        print("我是儿子，我也想跑步")

if __name__ == '__main__':
    xiaoming = Boy()
    xiaoming.run()

呈现效果：

子类和父类的方法同时生效。不重写就只生效子类的方法。

多继承：

人傻了吧，还可以多继承的？难不成你能有两个爹？不好意思，在代码界真的可以。

为了提高阅读效率，我们只写了改动和添加的代码块。

class Girl(Person):
    def run(self):
        print("我是女孩，我也想跑步")


class Child(Girl,Boy):
    def run(self):
        print("我是孙子，我也想跑步")

if __name__ == '__main__':
    xiaoming = Child()
    print(xiaoming.height)
    xiaoming.run()
    #1.8
	#我是孙子，我也想跑步

“孙子辈”重写：

#定义一个父类
class Person(object):
    def __init__(self):
        self.height = 1.80
        self.sex = "男"


    def run(self):
        print("我可以跑步")


class Boy(Person):
    # 括号里面的类，表示继承的是哪个类
    # 继承Person类之后，就拥有person类里面所有的属性和方法
    def run(self):
        #重写可以同时启用子类和父类的方法
        super().run()
        print("我是儿子，我也想跑步")


class Girl(Person):
    def run(self):
        print("我是女孩，我也想跑步")


class Child(Girl,Boy):
    def run(self):
        super().run()
        print("我是孙子，我也想跑步")

if __name__ == '__main__':
    xiaoming = Child()
    print(xiaoming.height)
    xiaoming.run()
    #1.8
	#我是女孩，我也想跑步
	#我是孙子，我也想跑步

它只重写了Girl类的run方法，这是因为多继承要遵循就近原则，注意注意，这里的就近指的是你括号内谁写在前头，谁就是近的。

class Child(Boy,Girl):

如果我们这么写，Boy比Girl就更近，这就是就近原则。再三提醒！！！就近不是指代码，而是指括号内谁近！

连续重写：

• 我想把包括爷爷辈的方法一同重写该怎么办呢？
• super()是按照继承顺序依次重写的，并不是直接选择一个父辈就直接向爷爷辈重写。而是把父辈都重写完了，才会向爷爷辈重写

#定义一个父类
class Person(object):
    def __init__(self):
        self.height = 1.80
        self.sex = "男"


    def run(self):
        print("我可以跑步")


class Girl(Person):
    def run(self):
        super().run()
        print("我是女孩，我也想跑步")


class Boy(Person):
    # 括号里面的类，表示继承的是哪个类
    # 继承Person类之后，就拥有person类里面所有的属性和方法
    def run(self):
        #重写可以同时启用子类和父类的方法
        super().run()
        print("我是儿子，我也想跑步")


class Child(Boy,Girl):
    def run(self):
        super().run()
        print("我是孙子，我也想跑步")

if __name__ == '__main__':
    xiaoming = Child()
    print(xiaoming.height)
    xiaoming.run()
    #该函数可以查看继承顺序
    print(Child.mro())

呈现效果：

继承顺序：Child\Boy\Girl\Person\object
1.重写方法跳转到Boy
2.Boy又重写跳转到Girl(一代完了才重写上一代，按继承顺序重写)
3.Girl又重写跳转到Person
4.Person执行完成后继续执行Girl内部代码然后依次往下
所以先打印的是Person类的方法，你也可以通过改变super()的顺序来控制输出顺序。

多属性问题：

如果你在子类里面输入了init方法来定义属性，那么实例化对象的时候以子类为准

#定义一个父类
class Person(object):
    def __init__(self):
        self.sex = "男"


    def run(self):
        print("我可以跑步")

class Boy(Person):
    # 括号里面的类，表示继承的是哪个类
    # 继承Person类之后，就拥有person类里面所有的属性和方法
    def __init__(self,name,height):
        self.name = name
        self.height = height

    def run(self):
        #重写可以同时启用子类和父类的方法
        super().run()
        print("我是儿子，我也想跑步")



if __name__ == '__main__':
    xiaoming = Boy("小明",1.80)
    print(xiaoming.name)
    print(xiaoming.height)
    print(xiaoming.sex)

呈现效果：

那如果我想调用父类的属性该怎么办呢？还是用重写

super().__init__()#重写父类属性
print(self.sex)
"""
#可以调用父类的属性，重名属性也可以这么写.但是要注意顺序，要写在super()之后，否则会被覆盖。
#注意子类是无法继承父类的父类的同名属性的，你要是想获取同名属性
"""

直接：

print(Person().sex)

封装：

概念：

这个就非常简单了，面向对象1里面也论述过。封装就是将属性和方法写到类里面的操作，没有什么特别需要讲解的地方。函数封装代码，类封装函数。