day24 面向对象三大特性之封装

本周内容

组合 封装
多态
面向对象高级
异常处理
网络协议
    通讯原理
    互联网协议
    TCP/UDP
    基于TCP协议的套接字

上周回顾
1.xml,os,os.path
2.ATM+购物车
    三层结构
3.面向对象与面向过程编程的对比

今日内容

1.面向对象的精髓

精髓是将数据和处理数据的代码绑定成了一个对象
只要获取到对象,相应的数据和方法都有了
class Mysql:

def __init__(self,host,port,db,charset):
    self.host = host
    self.port = port
    self.db = db
    self.charset = charset

def exc2(self,proc_name):
    conn=connect(self.host,self.port,self.db,self.charset)
    conn.call_proc(proc_name)
    return 123

def exc1(self,sql):
    conn=connect(self.host,self.port,self.db,self.charset)
    conn.execute(sql)
    return 123

my1 = Mysql("127.0.0.1",3306,"mydb","utf-8")
my1.exc1("select *from table1")
my1.exc2("名字")

2.组合

什么叫组合,多个对象放在一起叫组合
在程序中,一个对象将另一个对象作为自己的属性
组合 也可以降低代码的冗余

学生会增加各种各样的新的属性,比如手机,比如电脑,这样Student中会增加大量的属性和方法
class Person:
def __init__(self,name,sex,age,phonenumber,operator,address):
    self.name = name
    self.sex = sex
    self.age = age

    self.phonenumber = phonenumber
    self.operator = operator
    self.address = address

def call(self):
    print("%s 正在拨号" % self.phonenumber)

class Student(Person):
     def __init__(self,name,sex,age,number,phonenumber,operator,address):
         super().__init__(name, sex, age,phonenumber,operator,address)
        self.number = number

    def show_info(self):
         # print("name:%s sex:%s, age:%")
        print(self.__dict__)

     def select_cursor(self):
        print("%s 正在选课...." % self.name)

class Teacher(Person):
    def __init__(self,name,sex,age,salary,level,phonenumber,operator,address):
         super().__init__(name,sex,age,phonenumber,operator,address)
         self.salary = salary
         self.level = level
    def set_score(self):
         print("%s 正在为学生打分..." % self.name)

# 上述代码通过继承减少了代码冗余
# 需要给学生添加手机这个属性,(手机号码,运营商,归属地,可以打电话)
# 需要给学生添加电脑这个属性,(品牌,系统,CPU,内存,可以看视频,打游戏)
# stu = Student("李寻欢","女",20,"飞刀一班","18666666666","中国移动","上海浦东")
# print(stu.name)
# print(stu.phonenumber)
# stu = Student("李寻欢","女",20,"飞刀一班","18666666666","中国移动","上海浦东")
# stu.show_info()

# 学生会增加各种各样的新的属性  比如手机  比如电脑, 这样Student中会增加大量的属性和方法

后期的维护成本非常高
这时候就需要使用组合来完成减少代码冗余

class Phone:
    def __init__(self,phonenumber,operator,address):
         self.phonenumber = phonenumber
         self.operator = operator
         self.address = address

     def call(self):
     print("%s 正在拨号" % self.phonenumber)

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

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

     def show_info(self):
         # print("name:%s sex:%s, age:%")
           print(self.__dict__)

    def select_cursor(self):
         print("%s 正在选课...." % self.name)

class Teacher(Person):
    def __init__(self,name,sex,age,salary,level):
        super().__init__(name,sex,age)
        self.salary = salary
        self.level = level
    def set_score(self):
        print("%s 正在为学生打分..." % self.name)

stu = Student("乔峰","男",38,"007")
# 学生买了一台手机 所以增加一个手机属性
p1 = Phone("1999999999","中国小米移动","上海浦东")

stu.phone = p1
# 学生要打电话
stu.phone.call()

# 通过将手机对象和学生对象进行组合  完成了需求,并且相比较继承而言
# 耦合度低  手机和学生在修改的时候 互不影响
# 同时也减少了代码冗余

# 继承是一种关系  什么是什么   学生是人类  老师是人类    (如果把手机相关内容插入到人类中,相当于学生是手机???)
# 组合是 对象之间的关系   学生对象拥有手机对象

3.封装

1.什么是封装
    类似工厂拿个纸箱,装入一堆产品,拿胶带封起来
    在程序中,封装指的是将内容隐藏起来,在面向对象中有什么内容可以被隐藏,就是属性和方法

    注意:封装绝不是单纯的隐藏
    封装是指,隐藏内部实现细节,对外提供使用接口
    封装是为了明确区分内部和外部

2.为什么要封装
    1.提高安全性 (cpu频率,缓冲区大小)
    封装的例子(电脑,手机,汽车,收音机)
        对于封装的属性而言,是通过给访问和修改增加额外的逻辑判断实现

    2.封装是为了明确区分内部和外部

3.如何使用封装
    在属性或方法前 加上两个下划线,就可以将其设置为私有的
    另外补充:python中权限只有两种,公开(谁都能访问)和私有的(只有自己能访问的)

    可以用对象的绑定方法,来返回封装的属性,如果直接返回的话,就没必要设置隐藏了,谁都可以通过调用方法来获取,我们在方法中加上自己的判断逻辑

    即实现了隐藏,又提供了访问的接口,这就是封装的用法

class Student:
    def __init__(self,name,sex,age,idCard):
        self.name = name
        self.age = age
        self.sex = sex
        self.__idCard = idCard
    def say_hi(self):
        print("hello i am %s age is : %s sex is %s" %
          (self.name,self.age,self.sex))

def test(self):
    print(self.__idCard)

# 可以使用方法 将内部封装的内容返回出去
def get_idCard(self):
    return self.__idCard

# 如果直接返回的话 就没必要设置隐藏了 ,谁都可以通过调用方法来获取,我们再方法中加上自己的判断逻辑
def get_idCard2(self,pwd): # 如果密码正确我就给你身份证号码
    if pwd == "1111":
        return self.__idCard
    else:
        print("滚 你没有资格知道我的身份证...")

def set_idCard(self,pwd,new_idCard): # 如果密码正确就允许修改
    if pwd == "1111":
        self.__idCard = new_idCard
    else:
        print("滚 你没有资格修改我的身份证...")

stu = Student("步惊云","男",20,"3206661998445132")
stu.say_hi()

print(stu.__idCard)  # 加上__也访问不了

 stu.test() # 但在内部是可以访问的
 idcard = stu.get_idCard()
print(idcard)
# 即实现了隐藏  又提供了访问的接口 这就是封装的用法
# idcard = stu.get_idCard2("1111")
# print(idcard)

# 身份证填错了 要修改
# stu.__idCard = "123" # 这样是无法修改原来的身份证信息的 而是添加了新的属性
print(stu.__idCard)
print(stu.get_idCard2("1111"))

调用方法来修改隐藏的属性
stu.set_idCard("1111","xxxxxxxxxxxxxxxxxx")
print(stu.get_idCard2("1111"))

总结:对于被隐藏的属性  访问和修改都需要通过方法 get用于获取  set用于设置(也称之为设置器和访问器)