面向对象进阶

1. 访问权限

1.1 @property

前面讲到方法里，python 可以通过下划线来标识方法和属性的权限，name 公共,__name私有,_name保护

那么如果想访问属性可以通过属性的getter（访问器）和setter（修改器）方法进行对应的操作。如果要做到这点，就可以考虑使用@property包装器来包装getter和setter方法，使得对属性的访问既安全又方便，代码如下所示。
实例：

class safe:
    __test = 100
    def __init__(self,test):
        self.__test = test

    @property
    def test(self):
        return self.__test

    @test.getter
    def test(self):
        return self.__test

    @test.setter
    def test(self,test):
        self.__test = test

    def show(self):
        print('self.__test:', self.__test)


a = safe(1000)
a.show()
print(a.test)
print(a.test)
a.test = 1111
a.show()
try:
    print(a.__test)
except AttributeError as err1:
    print(err1)

结果：

self.__test: 1000
1000
1000
self.__test: 1111
'safe' object has no attribute '__test'

1.2 __slots__

前面说到属性是可以动态删减的，如果想保护起来，就得用__slots__ 保护起来
这个关键字声明了只有它限定得属性是可读可写的，不再元组里的只能读，不能写

看例子：

class test_private:
    'nothong'

    __slots__ = ('_name', '_age', '_high')
    test = 111
    def __init__(self,name,age,high):
        self._name = name
        self._age = age
        self._high = high

    @property
    def name(self):
        return self._name

    @property
    def age(self):
        return self._age

    @age.setter
    def age(self, age):
        self._age = age

    def play(self):
        if self._age <= 16:
            print('%s正在玩飞行棋.' % self._name)
        else:
            print('%s正在玩斗地主.' % self._name)


a = test_private('zhangsan', 18, 130)
a.play()
try:
    print('a.name : ', a.name)
except AttributeError as err1:
    print('err1: ',err1)
try:
    a.ability = 'aaa'
except AttributeError as err2:
    print('err2:',err2)

try:
    a.test = 1000
    print(a.test)
except AttributeError as err3:
    print('err3', err3)

a.age = 15
a.play()

结果：

zhangsan正在玩斗地主.
a.name :  zhangsan
err2: 'test_private' object has no attribute 'ability'
err3 'test_private' object attribute 'test' is read-only
zhangsan正在玩飞行棋.

2. 静态方法和类方法

之前，我们在类中定义的方法都是对象方法，也就是说这些方法都是发送给对象的消息。静态方法是可以发消息给类的，就是说，类和对象都可以执行，代码如下所示。

class test_static:

    @staticmethod
    def test_static(cls):
        print('you can do')

    @staticmethod
    def test_no_param():
        print('you cant')


cls = ''
test_static.test_static(cls=cls)
test_static.test_no_param()
a = test_static()
a.test_static(cls=cls)
a.test_no_param()

结果;

you can do
you cant
you can do
you cant

可以不用加cls

和静态方法比较类似，Python还可以在类中定义类方法，类方法的第一个参数约定名为cls，它代表的是当前类相关的信息的对象（类本身也是一个对象，有的地方也称之为类的元数据对象），通过这个参数我们可以获取和类相关的信息并且可以创建出类的对象，随便给自己初始化了，但是要通过静态方法，返回的也是个cls，就是自己，代码如下所示。

import os
from time import time, localtime, sleep


class Clock(object):
    """数字时钟"""

    def __init__(self, hour=0, minute=0, second=0):
        self._hour = hour
        self._minute = minute
        self._second = second

    @classmethod
    def now(cls):
        ctime = localtime(time())
        return cls(ctime.tm_hour, ctime.tm_min, ctime.tm_sec)

    def run(self):
        """走字"""
        self._second += 1
        if self._second == 60:
            self._second = 0
            self._minute += 1
            if self._minute == 60:
                self._minute = 0
                self._hour += 1
                if self._hour == 24:
                    self._hour = 0

    def show(self):
        """显示时间"""
        return '%02d:%02d:%02d' % \
               (self._hour, self._minute, self._second)

结果：

18:56:04

就是个1s一次的时间

3. 类之间的关系

这个完全用作者的了，主要是要理解
简单的说，类和类之间的关系有三种：is-a、has-a和use-a关系。

is-a关系也叫继承或泛化，比如学生和人的关系、手机和电子产品的关系都属于继承关系。
has-a关系通常称之为关联，比如部门和员工的关系，汽车和引擎的关系都属于关联关系；关联关系如果是整体和部分的关联，那么我们称之为聚合关系；如果整体进一步负责了部分的生命周期（整体和部分是不可分割的，同时同在也同时消亡），那么这种就是最强的关联关系，我们称之为合成关系。
use-a关系通常称之为依赖，比如司机有一个驾驶的行为（方法），其中（的参数）使用到了汽车，那么司机和汽车的关系就是依赖关系。