面向对象之组合

面对对象精髓：将数据和处理数据的方法绑定成一个对象

　　　　　　　获得了对象就同时获得了数据和方法

组合：多个对象放在一起，也可以降低代码冗余。

　　　程序中一个对象将另一个对象作为自己的属性

继承和组合的区别：

　　　　　　　　继承：是一种类之间的包含关系（学生是人类）

　　　　　　　　组合：是一种拥有的关系（学生类拥有手机类）

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

class Teacher(Person):  # 继承关系
    def __init__(self,name,age,sex,salary,level):
        super().__init__(name,age,sex)
        self.salary = salary
        self.level = level


    def set_score(self):
        print('%s 正在为学生打分。。。'% self.name)

class Student(Person): # 继承关系
    def __init__(self,name,age,sex,number):
        super().__init__(name,age,sex)
        self.number = number

    def get_info(self):
        print(self.__dict__)

    def select_course(self):
        print('%s 正在选课。。。'%self.name)

# 为学生添加各种新属性，比如手机，电脑，Student 中增加大量的属性和方法
# 解决办法为组合（程序中一个对象将另一个对象作为自己的属性

# 添加手机
class Phone:
    def __init__(self,phone,operator,address):
        self.phone = phone
        self.operator = operator
        self.address = address
    def call(self):
        print('%s 正在拨号。。。' % self.phone)

stu = Student('egon','man',38,'007')
p1 = Phone('18745632456','移动','shanghai')

stu.phone = p1   # 组合
stu.phone.call()

　生成一个学生类： stu = Student(' 属性') 生成一个手机类： p1 = Phone('属性')

　　　　　　　　　　　为学生增加(手机）属性: stu.phone = p1

　　　　　　　　　　　然后可以通过stu调用p1中的方法：stu.phone.call

封装：将内容（即属性或方法）隐藏起来，但不是单纯的隐藏

　　　隐藏内部实现细节，对外提供接口

为什么封装：提高安全性（cpu频率，缓冲区大小）

　　　　　　明确区分外部和内部

　　　对封装属性而言：给访问和修改增加额外的逻辑判断

　　　对封装方法而言：为了隔离复杂度

什么时候用：

　　　　当一个类中有某些属性或方法不应该让外界直接访问，应该将其封装

如何使用封装：

　　　在python中权限分为两种：一种公开和私有的

　　　在属性或方法名前加两个下划线例： self.__idcard = idcard -----> 将该属性设置为私有

私有的特性：只能在类内部访问（对象.__idcard），外部无法进行访问

封装的实现原理： 1.本质python并没有强行限制访问，而是通过语法转换来实现封装

　　　　　　　　2. p.__dict__ 可以发现，私有属性前自动加上了__类名（实现封装的原理）（self.__name）-->(_People__name)

　　　　　　　　所以外部通过 self.__name 无法进行访问（本质变成了_People__name）

　　　　　　　 3. 只有类的内部的双下线才会被自动转换，转换过程只执行一次，在类之外再定义双下划线开头的名称不会自动转换

　　　外部调用方法来访问和修改被隐藏的属性，需要提供相应的设置器和访问器

　　　　get( 访问器）：用于获取

　　　　set(设置器）用于设置

class Student:
    def __init__(self,name,sex,age,idcard):
        self.name = name
        self.sex = sex
        self.age = age
        self.__idcard = idcard # 应该设置成私有的

    def sayhi(self):
        print('hello I am %s ,my age is %s,sex is %s'%(self.name,self.age,self.sex))
    # 除idcard属性外其他都是公开的，可以在外部任意调用

    def test(self):
        print(self.__idcard)   # 内部可以访问
　　
　　def get_idcard(self):   # 可以使用方法将内部封装的方法返回出去(问题：如果可以直接返回，就不需要封装了，get_idcard2()
　　　　return self.__idcard

　　# 封装的用法，即实现了隐藏，又提供了访问接口（即密码）
　　def get_idcard2(self，pwd):  # 密码验证身份
　　　　if  pwd == '123'
　　　　　　return self.__idcard
　　　　else:
　　　　　　print(' 没权限！)

　　def set_idcard(self,pwd,new_id):  #get 用来获取， set用来设置
　　　　if pwd == '123':
　　　　　　self.__idcard = new_id
　　　　else:
　　　　　　print('没权限')

stu = Student('egon','man',20,'7930r47097070')
stu.sayhi()
stu.test()
stu.get_idcard()
结果：

hello I am egon ,my age is 20,sex is man
7930r47097070

封装方法：给方法名字前面加双下划线

　　好处：提高安全性

　　　　　隔离复杂度（将复杂的内容隔离到内部，外部只留下简单接口）