python中面向对象编程的三大特性

Python是面向对象的语言，也支持面向对象编程的三大特性：继承、封装（隐藏）、多态。

·封装（隐藏）
隐藏对象的属性和实现细节，只对外提供必要的方法。相当于将“细节封装起来”，只对外暴露“相关调用方法”。
通过前面学习的“私有属性、私有方法”的方式，实现“封装”。Python追求简洁的语法，没有严格的语法级别的“访问控制符”，更多的是依靠程序员自觉实现。

·继承
继承可以让子类具有父类的特性，提高了代码的重用性。
从设计上是一种增量进化，原有父类设计不变的情况下，可以增加新的功能，或者改进已有的算法。

·多态
多态是指同一个方法调用由于对象不同会产生不同的行为。生活中这样的例子比比皆是：同样是休息方法，人不同休息方法不同。张三休息是睡觉，李四休息是玩游戏，程序员休息是“敲几行代码”。

继承

继承是面向对象程序设计的重要特征，也是实现“代码复用”的重要手段。如果一个新类继承自一个设计好的类，就直接具备了已有类的特征，就大大降低了工作难度。已有的类，我们称为“父类或者基类”，新的类，我们称为“子类或者派生类”。

语法格式:
Python支持多重继承，一个子类可以继承多个父类。继承的语法格式如下：
    class 子类类名(父类1[，父类2，…])：
        类体

如果在类定义中没有指定父类，则默认父类是object类。也就是说，object是所有类的父类，里面定义了一些所有类共有的默认实现，比如：__new__()。

定义子类时，必须在其构造函数中调用父类的构造函数。调用格式如下：
父类名.__init__(self,参数列表)

class Person:

    def __init__(self,name,age):
        self.name = name
        self.__age = age    #私有属性

    def say_age(self):
        print("年龄，年龄，我也不知道")


class Student(Person):

    def __init__(self,name,age,score):
        Person.__init__(self,name,age)  #必须显式的调用父类初始化方法，不然解释器不会去调用
        self.score = score


#Student-->Person-->object类
print(Student.mro())

s = Student("高淇",18,60)
s.say_age()
print(s.name)
#print(s.age，s.score)
print(dir(s))
print(s._Person__age)

执行结果

[<class '__main__.Student'>, <class '__main__.Person'>, <class 'object'>]
年龄，年龄，我也不知道
高淇 60
['_Person__age', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'name', 'say_age', 'score']
18

类成员的继承和重写

1.成员继承：子类继承了父类除构造方法之外的所有成员。
2.方法重写：子类可以重新定义父类中的方法，这样就会覆盖父类的方法，也称为“重写”

class Person:

    def __init__(self,name,age):
        self.name = name
        self.__age = age    #私有属性

    def say_age(self):
        print("我的年龄:",self.__age)

    def say_introduce(self):
        print("我的名字是{0}".format(self.name))


class Student(Person):

    def __init__(self,name,age,score):
        Person.__init__(self,name,age)  #必须显式的调用父类初始化方法，不然解释器不会去调用
        self.score = score

    def say_introduce(self):
        '''重写了父类的方法'''
        print("报告老师，我的名字是：{0}".format(self.name))


s = Student("高淇",18,80)
s.say_age()
s.say_introduce()

执行结果

我的年龄: 18
报告老师，我的名字是：高淇

查看类的继承层次结构

通过类的方法mro()或者类的属性__mro__可以输出这个类的继承层次结构。

class A:pass
class B(A):pass
class C(B):pass
print(C.mro())

执行结果

[<class '__main__.C'>, <class '__main__.B'>, <class '__main__.A'>, <class 'object'>]

object根类

object类是所有类的父类，因此所有的类都有object类的属性和方法。我们显然有必要深入研究一下object类的结构。对于我们继续深入学习Python很有好处。

dir()查看对象属性

查看对象所有属性以及和object进行比对

class Person:

    def __init__(self,name,age):
        self.name=name
        self.age=age
    def say_age(self):
        print(self.name,"的年龄是：",self.age)


obj=object()
print(dir(obj))
s2=Person("高淇",18)
print(dir(s2))

执行结果

['__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']

['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'age', 'name', 'say_age']

从上面我们可以发现这样几个要点：
1.Person对象增加了六个属性：
__dict__
__module__
__weakref__
age
name
say_age
2.object的所有属性，Person类作为object的子类，显然包含了所有的属性。
3.我们打印age、name、say_age，发现say_age虽然是方法，实际上也是属性。只不过，这个属性的类型是“method”而已。
age
name
say_age

重写__str__()方法

object有一个__str__()方法，用于返回一个对于“对象的描述”，对应于内置函数str()经常用于print()方法，帮助我们查看对象的信息。__str__()可以重写。

#测试重写object的__str__()

class Person:       #默认继承object类

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

    def __str__(self): 
        '''将对象转化成一个字符串，一般用于print方法'''
        return "名字是：{0}".format(self.name)

p = Person("高淇")
print(p)

执行结果

名字是：高淇

多重继承

Python支持多重继承，一个子类可以有多个“直接父类”。这样，就具备了“多个父类”的特点。但是由于，这样会被“类的整体层次”搞的异常复杂，尽量避免使用。

#测试mro()方法解析顺序
class A:
    def aa(self):
        print("aa")

    def say(self):
        print("say AAA!")

class B:
    def bb(self):
        print("bb")

    def say(self):
        print("say BBB!")
class C(B,A):
    def cc(self):
        print("cc")

c = C()
print(C.mro())          #打印类的层次结构
c.say()                 #解释器寻找方法是“从左到右”的方式寻找，此时会执行B类中的say()

执行结果

[<class '__main__.C'>, <class '__main__.B'>, <class '__main__.A'>, <class 'object'>]

say BBB!

MRO()

Python支持多继承，如果父类中有相同名字的方法，在子类没有指定父类名时，解释器将“从左向右”按顺序搜索。

MRO（MethodResolutionOrder）：方法解析顺序。我们可以通过mro()方法获得“类的层次结构”，方法解析顺序也是按照这个“类的层次结构”寻找的。如上例所示。

super()获得父类定义

在子类中，如果想要获得父类的方法时，我们可以通过super()来做。
super()代表父类的定义，不是父类对象。

#测试super()，代表父类的定义，而不是父类的对象

class A:

    def say(self):
        print("A:",self)


class B(A):

    def say(self):
        #A.say(self)
        super().say()
        print("B:",self)


B().say()

执行结果

A: <__main__.B object at 0x000001BEF6CB8A20>
B: <__main__.B object at 0x000001BEF6CB8A20>

多态

多态（polymorphism）是指同一个方法调用由于对象不同可能会产生不同的行为。

关于多态要注意以下2点：
1.多态是方法的多态，属性没有多态。
2.多态的存在有2个必要条件：继承、方法重写。

#多态

class Man:
    def eat(self):
        print("饿了，吃饭啦！")

class Chinese(Man):
    def eat(self):
        print("中国人用筷子吃饭")

class English(Man):
    def eat(self):
        print("英国人用叉子吃饭")

class Indian(Man):
    def eat(self):
        print("印度人用右手吃饭")


def manEat(m):
    if isinstance(m,Man):
        m.eat()                 #多态。一个方法调用，根据对象不同调用不同的方法！
    else:
        print("不能吃饭")


manEat(Chinese())

执行结果

中国人用筷子吃饭
英国人用叉子吃饭