python面向对象的三大特征：封装、继承、多态

python 是面向对象的语言，也支持面向对象编程的三大特性

1.封装

        隐藏对象的属性和实现细节，只对外提供必要的方法。相当于将“细节封装起来”， 只对外暴露“相关调用方法”，通过前面的“私有属性、私有方法”的方式,实现“封装”。

实现封装：（私有属性和方法）

Python对于类的成员没有严格的访问控制限制,这与其他面向对象语言有区别。关于私有属性和私有方法.有如下要点:

        1.通常我们约定,两个下划线开头的属性是私有的(private)。其他为公共的(public)。

        2.类内部可以访问私有属性(方法)

        3.类外部不能直接访问私有属性(方法)

        4.类外部可以通过”类名_私有属性(方法)名" 访问私有属性(方法)
 

#测试私有属性、私有方法
 
class Student:
 
    def __init__(self,name,age):
        self.name = name
        self.__age = age    #私有属性
 
    def __work(self):       #私有方法
        print("hardwork")
        print("age:{0}".format(self.__age))
 
e = Student("张三",18)
 
print(e.name)
#print(e.age)
print(e._Student__age)
e._Student__work()

@property装饰器

@property可以将一个方法的调用方式变成“属性调用”。不用在写方法名后面的（），下 面是一个简单的示例：

#测试@property的用法
 
class Employee:
    @property
    def salary(self):
        print("salary")
        return 10000
 
emp1 = Employee()
#emp1.salary()
print(emp1.salary)

2.继承

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

Python支持多重继承，一个子类可以继承多个父类。继承的语法格式如下:

                class子类类名(父类 1[，父类2，.. ]):

                        类体

        如果在类定义中没有指定父类,则默认父类是object类。也就是说, object是所有类的父类，里面定义了- -些所有类共有的默认实现,比如: _ new_ ().

        定义子类时,必须在其构造函数中调用父类的构造函数。调用格式如下:

                父类名_ jinit__ (self, 参数列表)

#测试继承的基本使用
 
class Person:
    def __init__(self,name,age):
        self.name = name
        self.__age = age    #私有属性
 
    def say_age(self):
        print("年龄18")
 
 
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("tony",18,100)
s.say_age()
print(s.name)
#print(s.age)
print(dir(s))
print(s._Person__age)   #调用父类私有属性
 

成员继承:子类继承了父类除构造方法之外的所有成员。

方法重写:子类可以重新定义父类中的方法q这样就会覆盖父类的方法,也称为“重写”

#测试方法的重写
 
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("tony",18,100)
s.say_age()
s.say_introduce()

dir()和mro()
        内置函数dir() ,他可以让我们方便的看到指定对象所有的属性

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

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

#测试重写object的__str__()
 
 
class Person:   #默认继承object类
    def __init__(self,name,):
        self.name = name
 
    def __str__(self):
        return "my name is :{0}".format(self.name)
 
 
 
p = Person("tony")
print(p)

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

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

3.多态

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

多态( 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())