面向对象的三大特征 之封装 python版

面向对象有三大特点：封装 继承 多态
真的很像一个有钱人的生活，一个巨有钱的人的生活。
他追求的生活是 安全 继承权 通吃……
封装就是保证安全性，别人不能随意打扰他，要接触他需要有特殊的许可
继承：他继承了大笔的遗产或者非遗产，自己也会留下遗产给负二代
多态：多人运动了解一下……在不同人面前有不同的脸……当然不是啦，而是这个人随和，对所有人都通吃，许多人都可以靠他解决一个问题。

瞎扯到此结束，因为我不是有钱人，我理解的有钱人也就这水平。

• 封装：安全性，确保对象中的数据安全
• 继承：确保对象的可扩展性，可以继承父辈，也可以被子辈继承
• 多态：确保对象的灵活性 对各种类型的输入都有处理办法，不是限定一种 典型的是len，可以对列表 元组 字典 字符串起作用

封装：

• 引入：目前我们可以通过对象。属性的方式改变属性的值，导致对象中的属性值可以任意被修改，不安全
  #我们需要一种方式来增强数据的安全性。即属性不能随意改。只有我要求你改你才能改，不让改就改不了
  #属性不能随意改为任意值，这就需要引入封装
• 确保别人不能轻易的修改对象属性，但是并没有完全将修改权限禁止，而是从对象内部定义一个修改的入口，让别人不能轻易的修改。
  其实我觉得封装更多的是告诉自己的，让自己不会失误的修改某些参数
  不是告诉别人的，别人看到了不能修改，但是他看明白代码，还是能改的啊
  封装的两种方式：函数内部的属性名叫一个特殊的名字
  封装的第二种方式：
  命名对象属性时，以__开头，将其声明为内部属性，
  第二种方式：或者以_开头，将其声明为内部属性
  这样的方式表示：告诉开发者，这个是内部变量，不能随意改变；其实实际是可以改的，改起来没有那么麻烦，
• 在修改之后可以让修改者有更深一些的印象

但是封装并不是完全封死，封装更像是包装，比如快递外面的快递盒或者袋子，封死就是一个铁皮盒子，打不开的

• 我们在做封装之后需要提供一个修改的方法，限制修改的范围，输入不能是任意类型，当输入的类型与允许的类型不一时，需要给出提示

• 为了让输入受控，自己加一个定义的函数
  比如可以设置大于某值时才进行修改属性操作
  代码如下：

class Car:
    def __init__(self,name,value):
        #self.name = name
        #self.myName = name
        #self.__name = name
        self._name = name
        self._value = value
    def run(self):
        #print(self.myName,"开始跑了！")
        print(self._name, "开始跑了！")

    def getName(self):
        return self._name

    def setName(self,name):
        self._name = name

    def getValue(self):
        print(self._value)
        return self._value

    def setValue(self,value):
        if value>10000:
            self._value = value
a = Car('大奔',100000)
#a.name = 'tesila'
#a.
#p._Person__name = '1111'
#a.__Person__name = '1111'
#a.__name = '1111'   这样是不管用的，
#
#a._Person__name = '1111'  这样才管用
#a._name = '1111'
a.run()
a.getValue()
a.setValue(5000)
a.getValue()

输出结果：
大奔 开始跑了！
100000
100000

如果为20000时，则可以重新赋予价值

property 装饰器

• property 装饰器的作用：可以用来将一个方法转化为对象的属性，我们可以使⽤@property装饰器来创建只读属性，@property装饰器会将⽅法转换为相同名称的只读属性,可以与所定义的属性配合使⽤，这样可以防⽌属性被修改
• 例如：

class Person:
    def __init__(self,name):
        self._name = name

    #getter
    @property
    def name(self):
        print('get 方法执行了啊')
        return self._name

p = Person('葫芦娃')
#print(p.name())
print(p.name)

执行的结果是：可以通过p.name，通过调用方法的方式，将方法变成属性，调用的是getter方法
此时p.name表示的是p的一个属性了，这个属性是只读的
p.name='1111’这样是会报错的
但是p._name=‘1111’是不会报错的，而且是可以成功修改name值的
因为p._name 并不是P的属性，而p.name 是p的属性
所以说可以防止属性被修改的意思是防止属性通过p.name的方式被修改

那么我们想，如果把_name修改为name这样的话，是不是就可以彻底防止被修改了啊？
当然不是了啊，这样的话，因为name方法已经转化为属性了，目前在初始化中又定义了一个name属性，这样的程序当然是会报错的啊

property这个装饰器的作用就是可以把方法转化为同名的属性，这个就是真的属性，而且是只读属性

那么这个name的值，就不能直接修改了吗？其实我们可以通过在类中定义一个setter来实现将只读变为非只读
具体代码如下：

class Person:
    def __init__(self,name):
        self._name = name

    #getter
    @property
    def name(self):
        print('get 方法执行了啊')
        return self._name

    @name.setter
    def name(self,name):
        print('set 方法执行了啊')
        self._name = name

p = Person('葫芦娃')
#print(p.name())
print(p.name)
#p.name = '1111'
p.name = '1111'
#p.name = '1111'
print(p.name)

property装饰器，我想我明白了，这真的是个好用的工具啊！