Python 面向对象的三大属性---封装、继承、多态

面向对象语言的三大特征:封装, 继承, 多态

封装：

广义的封装: 类和函数定义本身就是封装的体现

狭义的封装:一个类的某些属性,不希望外界直接访问,而是把这个属性私有化[只有当前类持有],然后暴露给外界一个访问的方法即可.

封装的本质:就是属性私有化的过程

封装的好处:提供了数据的复用性,保证了数据的安全性

在class内部可以有属性和方法，而外部的代码可以通过直接调用实例变量的方法来操作数据，这样就隐藏了内部的复杂逻辑。

但是从我们之前定义的class来看，外部代码还是可以自由的修改一个实例的name等属性。

封装的使用：
如果要让内部的属性不被外部访问，可以把属性名前加两个下划线，在python中以双下划线开头的变量就变成了一个私有的变量，只有内部可以访问，而外部不能访问。

class Person(object):
    def __init__(self, name, age, height, money):
        self.name = name
        self.__money = money

per = Person("hanmeimei", 20, 170, 10000)
print(per.__money)
>>>结果报错，访问不了

我们可以通过getMoney与setMoney的方法来操作被封装数据：

class Person(object):
    def run(self):
        print(self.__money)
    def eat(self):
        print("eat",food)
    def __init__(self, name, age, height, weight, money):
        self.name = name
        self.__age__=age
        self.weight = weight
        self.__money = money
        
    #通过内部方法,去修改私有属性
    #通过自定义的方法实现对私有属性的赋值与取值
    #set方法:setxxx
    def setMoney(self, money):
        #数据的过滤
        if money < 0:
            money = 0
        self.__money = money
     
    #get方法:getXXX
    def getMoney(self):
        return self.__money

per = Person("hanmeimei", 20, 170, 55, 10000)
per.setMoney(10)
print(per.getMoney())
>>>10

 

语法糖--@property

class Person(object):
    def run(self):
        print(self.__money)
        
    def eat(self):
        print("eat",food)
    def __init__(self, name, age, height, weight, money):
        self.name = name
        self.age=age
        self.weight = weight
        self.__money = money
     
    #相当于setter方法
    @money.setter                                 #变量名.setter
    def money(self, money):
        #数据的过滤
        if money < 0:
            money = 0
        self.__money = money
    
    #相当于getter方法
    @property
    def money(self):
        return self.__money

 

 

#不能直接访问per.__money是因为python解释器把__money变成了_Person__money
#仍然可以使用_Person__money去访问,但是强烈不建议这么干,不同的解释器可能存在解释的变量名不一致

单下划线，双下划线，头尾下划线的说明:

头尾下划线__foo__()：定义特殊的方法，一般是系统定义名字，类似于__init__()

单下划线：_foo:以单下划线开头的表示是protected类型的变量，即保护类型的变量只允许本身与子类访问，不能用于from module import *

双下划线：__foo:双下划线的表示的是私有类型(private)的变量，只能允许这个类的本身进行访问。

 

继承：

如果两个或者两个以上的类具有相同的属性和方法,我们可以抽取一个类出来。

在抽取的类中声明公共的部分

被抽取出来的类 ——父类  超类  基类
    
其他类   — 子类  派生类

PS：若一个类没有继承其他类，则它默认继承object类，换句话说，object是一切类的基类。

单继承
一个子类只能有一个父类,被称为单继承

class Animal(object)：
    def run(self):
        print("Animal is running....")

class Dog(Animal):
    pass

对子类增加一些方法：

class Dog(Animal):    
    def eat(self):
        print("Eating meat....")

对子类增加一些方法：

class Person(object):
    def __init__(self, name, age, money):
        self.name = name
        self.age = age
        self.__money = money

class Student(Person):
    def __init__(self, name, age, money, stuId):
    Person.__init__(self, name, age, money)       #或：super（）.__init__(name, age, money)
    self.stuId = stuId

总结:

object是一切类的基类，也可以省略不写。

继承的特点:

a. 子类对象可以直接访问父类中未私有的属性

b. 子类对象可以调用父类中的方法

c. 父类对象不能访问子类中特有的属性或者方法

优点:

1.可以简化代码,减少冗余

2.提高代码的维护性

3.提高了代码的安全性

缺点:

耦合和内聚被用来描述类与类之间的关系,耦合性越低,内聚性越高,说明代码越好,

但是,在继承关系中,耦合性相对比较高,如果修改父类,子类也会随着变化

多继承：
一个子类中可以有多个父类

1. 子类可以从多个父类中继承属性和方法
2. 一个父类可以有多个子类
3. 一个子类可以有多个父类

PS：当父类1和父类2的方法同名时，调用写在子类参数列表中前面的那个

多态--鸭子模型【依赖于继承】

在python中不存在真正的多态，因为python是一个动态数据类型的语言。
鸭子模型：如果有一只鸟，走路像鸭子，叫声像鸭子，那么我们就称这只鸟叫鸭子。
我们不关心它的数据类型，我们只关心它的使用。

class Animal(object)：
    def run(self):
        print("Animal is running....")

class Dog(Animal):
    def run(self):
        print("Dog is running...")
    
    def eat(self):
        print("Eating meat....")

当子类与父类都存在相同的run()方法的时候，子类中的run()覆盖了父类中的run(),在代码运行的时候，总会调用子类中的run().

这时候我们就获取了继承的另外一个好处：多态。

若要理解多态，我们首先要对数据类型再进行说明，我们定义一个class的时候，其实就是定义了一种数据类型。

拓展：
使用dir（）函数可以获取一个对象的所有的属性和方法，它返回一个包含字符串的list，如dir(a)