昨天我介紹了繼承，它是描述類與類之間什麽是什麽的關系，它的作用就是減少代碼冗余，但是它是強耦合

而今天我們介紹了另一種解決類與類之間代碼冗余的方式

組合

什麽是組合那？

描述的是類與類之間的關系，是一種什麽有什麽的關系

一個類產生的對象，該對象擁有一個屬性 這個屬性的值是來自於另外一個類的對象

# 組合
# 舉個例子來說明繼承和組合的區別
# 代碼冗余的
class Teacher:
    def __init__(self,name,age,sex,leven,salary,year,mon,day):
        self.name=name
        self.age=age
        self.sex
 
=sex
        self.leven=leven
        self.salary=salary
        self.year=year
        self.mon=mon
        self.day=day
    def inter(self):
        print(‘講課，改分‘)
    def info(self):
        print(‘‘‘
        年:%s
        月:%s
        日:%s
        ‘‘‘%(self.year,self.mon,self.day))
class Student:
    def __init__(self,name,age,sex,id,year,mon,day):
        self.name
 
=name
        self.age=age
        self.sex=sex
        self.id=id
        self.year=year
        self.mon=mon
        self.day=day
    def inter(self):
        print(‘學習，選課‘)
    def info(self):
        print(‘‘‘
        年:%s
        月:%s
        日:%s
        ‘‘‘%(self.year,self.mon,self.day))
tea=Teacher(‘
 
lxx‘,18,‘man‘,10,30000,2000,1,1)
tea.info()
stu=Student(‘wxx‘,16,‘man‘,10086,2002,3,3)
stu.info()
# 繼承
class Oldboypeople:
    def __init__(self,name,age,sex,year,mon,day):
        self.name=name
        self.age=age
        self.sex=sex
        self.year=year
        self.mon=mon
        self.day=day
    def info(self):
        print(‘‘‘
        年:%s
        月:%s
        日:%s
        ‘‘‘%(self.year,self.mon,self.day))
class Teacher(Oldboypeople):
    def __init__(self,name,age,sex,year,mon,day,leven,salary):
        super().__init__(name,age,sex,year,mon,day)
        self.leven=leven
        self.salary=salary
    def inter(self):
        print(‘學習，選課‘)
class Student(Oldboypeople):
    def __init__(self,name,age,sex,year,mon,day,id):
        super().__init__(name,age,sex,year,mon,day)
        self.id=id
    def inter(self):
        print(‘學習，選課‘)
tea1=Teacher(‘lxx‘,18,‘man‘,30000,2000,1,1,10)
tea1.info()
stu1=Student(‘wxx‘,16,‘man‘,2002,3,3,10086)
stu1.info()
# 組合
class Date:
    def __init__(self,year, mon, day):
        self.year = year
        self.mon = mon
        self.day = day

    def info(self):
        print(‘‘‘
         年:%s
         月:%s
         日:%s
         ‘‘‘ % (self.year, self.mon, self.day))
class Oldboypeople:
    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex
class Teacher(Oldboypeople):
    def __init__(self,name,age,sex,leven,salary):
        super().__init__(name,age,sex,)
        self.leven=leven
        self.salary=salary
    def inter(self):
        print(‘學習，選課‘)
class Student(Oldboypeople):
    def __init__(self,name,age,sex,id):
        super().__init__(name,age,sex)
        self.id=id
    def inter(self):
        print(‘學習，選課‘)
tea1=Teacher(‘lxx‘,18,‘man‘,30000,2000,)
stu1=Student(‘wxx‘,16,‘man‘,2002,)
dat=Date(2000,3,3)
tea1=dat
tea1.info()
stu1=dat
stu1.info()

封裝

什麽是封裝？

裝就是一堆屬性存在起來，封的概念就把這些屬性給隱藏起來

class 類名:
    __屬性名=2
賦值給一個名字=類名()
print(賦值給一個名字.x)
#會報錯誤
SyntaxError: invalid syntax

__屬性=_類名__屬性名

舉些實際例子

class Teacher:
    __x=2
tea=Teacher()
print(tea.x)

class Teacher:
    def __x(self):
        print(‘x‘)
tea=Teacher()
tea.x()

class Teacher:
    def __init__(self,name):
        self.__name=name
tea=Teacher(‘lxx‘)
print(tea.__name)

這些就是封裝的實際例子 但是有些人會發現你調的都是__x 定義的確是x 請看下面

class Teacher:
    __x=2
tea=Teacher()
print(tea.__x)
#依然會報錯
Traceback (most recent call last):
  File "C:/Users/64802/PycharmProjects/kaoshi/學習/學習/day21/組合與分裝.py", line 122, in <module>
    print(tea.__x)
AttributeError: ‘Teacher‘ object has no attribute ‘__x‘

其實這種隱藏只是一種語法上的變形

註意：1.為一個屬性名加__開頭，會在類定義階段將屬性名變形

2.這種語法意義上變形，只在類的定義階段發生一次，類定義之後，新增__開頭的屬性都沒有變形的效果

3.如果父類不想讓子類覆蓋自己 就可以用__開頭的方法

#父類不想被子類覆蓋

#會被覆蓋
class Father:
    def f1(self):
        print(‘Father f1‘)
class Sun(Father):
    def f1(self):
        print(‘Sun f1‘)
res=Sun()
res.f1()#Sun f1

#用__開頭不會被覆蓋
class Father:
    def f1(self):
        print(‘Father f1‘)
class Sun(Father):
    def __f1(self):
        print(‘Sun f1‘)
res=Sun()
res.f1()#Father f1

搞清楚封裝是怎麽回事，我們就會產生疑問 ？？？

既然你要藏起來它 你還定義它幹嘛！！！（但凡定義了說明我們需要用到它）

這就說明了封裝不是單純的隱藏

我們先不說封裝到底是幹什麽的 來舉個例子

class Oldboypeople:
    def __init__(self,name,age,sex):
        self.__name=name
        self.__age=age
        self.__sex=sex
    def info(self):
        name=input(‘想學的課程，我們為你介紹我們的金牌講師>>:‘).strip()
        if name==‘q‘:
            return
        print(‘‘‘
        性別:%s
        年齡:%s
        性別:%s
        ‘‘‘%(self.__name,self.__age,self.__sex))
class Teacher(Oldboypeople):
    def __init__(self,name,age,sex,leven,salary):
        super().__init__(name,age,sex,)
        self.leven=leven
        self.salary=salary
tea1=Teacher(‘lxx‘,18,‘man‘,30000,2000,)
tea1.info()
print(tea1.leven)

我們把信息隱藏起來了，類外面無法直接調用，這樣我們就可以設計個接口 通過這個接口來調用信息，因為想調用信息必須經過接口 所以我們就可以肆意的加條件，有點相似於我們劉老師之前講的寫程序分層，也符合我們上帝是的思維方式這就是封裝的作用

總結一下：

封裝數據屬性的目的：為了隔離復雜度，把數據屬性封裝起來，然後需要開辟接口給類外部的使用者使用，好處是我們可以在接口之上添加邏輯從而嚴格空間訪問者對屬性的操作

終極奧義：明確的區分內外，對外隱藏的，對內是開放的

所謂內是一個類內 不包括其子類，簡單粗暴的說就是這個類以外 全部都是外

組合和封裝