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

面向对象三大特征——封装、继承、多态

一、封装

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

封装：把功能代码 ，数据封装到某个地方 ， 需要的时候进行调用，提高程序的安全性。

即把属性以及方法放到类中，通过类来操作数据或者调用一些功能。

通过封装。可以将一些不想给用户看到的功能可以进行隐藏，用户只能访问我们公开的功能，这样提高了数据的安全性，也对后期的维护降低了维护成本。

进行封装的好处：便于分工，便于复用 ， 可扩展性强。

class Dog:
    '''
    类文档
    这个类的说明，这个类的用途 ， 大体有什么方法
    '''
    # 类属性
    name = '哈士奇'
    sex = '女'

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

    def sleep(self):
        print(f'{self.name}在大门口呼呼睡')

    def eat(self):
        print(f'{self.name}想要吃饭 ， 体重{self.weight}，过重不让吃')

erha = Dog('二哈',1.5 , 30)
print(erha.name)
print(erha.sex)
# erha.sleep()
# erha.eat()

# print(Dog.__dict__)
# 获取类的类文档内容
# print(Dog.__doc__)

1、属性、方法隐藏

在类中定义了一些数据或者功能不希望被外部访问或者操作的时候，可以将数据或者功能进行隐藏

将属性或者方法名前面加上两个下划线 ， 隐藏属性只能在类内部访问

python中没有绝对的隐藏 ， 改变一个访问方式就可以进行访问了

class People:

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

    def __eat(self):
        print('狼吞虎咽')

cx = People('初雪',25)
# print(cx.name)
# # print(cx.__age)
#
# print(cx.__dict__)
#
# # 访问隐藏的属性或者方法
# # 对象名._类名__属性名/方法名
# print(cx._People__age)
# cx._People__eat()


class Bank:

    def __get(self):
        print('取钱')

    def __set(self):
        print('存钱')

    # 通过另一个方法进行访问 ， 而不直接访问功能方法
    def money(self):
        self.__get()
        self.__set()

a = Bank()
a.money()

2、属性权限设置

class People:

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

    # 可以访问name属性的函数
    def getname(self):
        return self.__name

    # 可以修改name属性的函数
    def setname(self , name):
        self.__name = name


cx = People('初雪')

print(cx._People__name)
print(cx.getname())
cx.setname('cx')
print(cx.getname())

property()函数

property可以设置、获取、删除对象属性，也可以限制用户对属性的获取（访问）与设置（修改）

property(fget = None , fset = None , fdel = None)

# fget 是获取属性值的方法
# fset 是设置属性值的方法
# fdel 是删除属性值的方法

class A:

    def __init__(self):
        self.name = '初雪'
        self.__age = 18

    # 获取age属性值的方法
    def get_age(self):
        return self.__age

    # 设置（修改）age属性值
    def set_age(self , value):
        self.__age = value


    # property属性代理
    # 这里的变量名要跟隐藏的属性名一致 ， 方便属性使用访问
    age = property(fget=get_age , fset=set_age)

c = A()
print(c.name)
print(c.age)
c.age = 24
print(c.age)

property装饰器

@property是property提供的比较简洁的写法

@property  装饰的方法是获取属性值的方法，被装饰方法的名称会被作为属性名，跟隐藏的属性名一致 ， 方便属性使用访问
@属性名.setter 装饰的方法是设置属性值的方法
@属性名.deleter 装饰的方法是删除属性值的方法

class A:

    def __init__(self):
        self.name = '初雪'
        self.__age = 18

    # 设置访问age属性值的方法
    @property
    def age(self):
        return self.__age

    @age.setter
    def age(self , value):
        self.__age = value

    @age.deleter
    def age(self):
        del self.__age


c = A()
# print(c.age)
# c.age = 24
# print(c.age)
del c.age

二、继承

继承：生活中，儿子继承父亲的财产（我要回去继承皇位了），在python中是在多个类中一个所属关系，被继承的类称为父类 ， 接收继承的类称为子类；在继承中子类是默认继承父类中的属性与方法。

继承可以解决类与类之间代码的冗余

在python中所有类都有一个父类就是object ， object就是基类，超类

在python3中都是默认继承了object类

1.1 单继承

一个子类继承一个父类

父类中的隐藏属性或者方法 ， 子类是无法继承的

class Father:

    def __init__(self):
        self.name = '雍正'
        self.clothes = '龙袍'

    def eat(self):
        print('吃满汉全席')
        

class Son(Father):
    pass

ql = Son()
print(ql.clothes)
ql.eat()

1.2 重写父类中的属性与方法

在子类中如果重新定义了init初始化方法的化 ， 实例化对象会默认访问自身的属性不会访问父类中的实例属性；

class Father:

    def __init__(self , name ):
        self.name = name
        self.__clothes = '龙袍'

    def eat(self):
        print('吃满汉全席')


class Son(Father):

    def __init__(self,age , name):
        self.age = age
        # 指名道姓 ， 类名.方法名(self)
        # Father.__init__(self , name)

        # 使用super
        # 在super中会自动的定位与绑定对象
        super(Son , self).__init__(name)
        super().__init__(name)

    def run(self):
        print('游山玩水')

        # Father.eat(self)
        super().eat()


ql = Son(86 ,'乾隆')
# ql.eat()
ql.run()
# print(ql.age)
# print(ql.name)

1.3 属性查找

对象在寻找属性的时候，——> 自身属性查找 ——>所在的类中查找 ——> 父类中

对象在寻找方法 ——>所在的类中查找 ——> 父类中

1.4 多层继承

多层继承即子类继承父类 ， 父类继承对应的父类（爷爷类）……

class A:
    def __init__(self):
        self.money = 10

    def eat(self):
        print('吃鲍鱼')


class B(A):
    def __init__(self):
        self.money = 100

class C(B):

    def eat(self):
        print('吃海参')
        super().eat()

cx= B()
# print(cx.money)

ltl = C()
# print(ltl.money)
ltl.eat()

1.5 多继承

多继承：一个儿子有多个父亲（到处认爹），一个子类继承多个父类

当继承中出现相同的方法则继承顺序是从左到右

class Horse:
    def body(self):
        print('体型健壮')

class Donkey:

    def body(self):
        print('体型娇小')

class Mule(Horse , Donkey):
    pass

class Mule_2(Donkey , Horse):
    pass

m = Mule()
# m.body()


# 查看继承顺序的
print(Mule.__mro__)
print(Horse.__mro__)

# 查看父类 , 不会出现object ， 以元组的形式放回，没有继承类返回object
print(Mule.__bases__)
print(Horse.__bases__)

# 返回得到一个父类，多个父类返回最左边的 ， 没有继承类返回object
print(Mule.__base__)
print(Horse.__base__)

三、多态

不同的对象 ， 调用同一个方法，表现出不同的形式

多态的实现：1、必须要有类的继承；2、子类重写父类的方法

class Bus:
    def ticket(self):
        print('票价单价5')

class Car(Bus):

    def ticket(self):
        print('票价单价50')

class Train(Car):

    def ticket(self):
        print('票价单价90')

class People:

    def money(self , c):
        c.ticket()


b = Bus()
c = Car()
t = Train()
b.ticket()
c.ticket()
t.ticket()

cx = People()
cx.money(b)
cx.money(t)
cx.money(c)