一、組合

解決類與類之間代碼冗余問題有兩種解決方案：
1、繼承 2、組合
1、繼承：描述的是類與類之間，從屬關系
2、組合：描述的是類與類之間的關系，是一種什么有什么關系
一個類產生的對象，該對象擁有一個屬性，這個屬性的值是來自于另外一個類的對象

class Date:
def __init__(self,year,mon,day):
self.year = year
self.mon = mon
self.day = day

def tell_birth(self):
print('出生年月日<%s-%s-%s>' % (self.year, self.mon, self.day))

class OldboyPeople:
school = 'oldboy'

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

class OldboyTeacher(OldboyPeople):
def __init__(self,name,age,sex,level,salary):
super().__init__(name,age,sex)
self.level=level
self.salary=salary

def change_score(self):
print('teacher %s is changing score' %self.name)

class Oldboystudent(OldboyPeople):
def __init__(self,name,age,sex,course,):
super().__init__(name,age,sex,)
self.course=course

def choose(self):
print('student %s choose course' %self.name)


tea1=OldboyTeacher('egon',18,'male',9,3.1)
date_obj=Date(2000,1,1)

tea1.birth=date_obj

stu1=Oldboystudent('張三',16,'male','linux')
stu1.birth=Date(2002,3,3)
stu1.birth.tell_birth()

二、封裝

什么是封裝
裝就是把一堆屬性存起來，封的概念就把這些屬性給隱藏起來
強調：封裝單從字面意思去看等同于隱藏，但其實封裝絕對不是單純意義的隱藏

如何把屬性隱藏起來，就在屬性前面加上__開頭（注意不要加__結尾）
注意：
1、其實這種隱藏只是一種語法上的變形,對外不對內
為一個屬性名加__開頭（注意不要加__結尾），會在類定義階段將屬性名統一變形：_自己的類名__屬性名

class Foo:
__x=1111 #_Foo__x=1111
def __init__(self,y):
self.__y=y #self._Foo__y=y

def __f1(self): #_Foo__f1
print('Foo.f1')

def get_y(self):
print(self.__y) # print(self._Foo__y)

obj=Foo(22222)
print(obj.x)
print(obj.__x)
obj.__f1()
print(obj.y)
print(obj.__y)
print(Foo.__dict__)
print(obj._Foo__x)
print(obj._Foo__y)
obj._Foo__f1()

obj.get_y()


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

Foo.__aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa=1
print(Foo.__dict__)

3、如果父類不想讓子類覆蓋自己的方法，可以在方法名前加__開頭
class Foo:
def __f1(self): #_Foo__f1
print('Foo.f1')

def f2(self):
print('Foo.f2')
self.__f1() #obj._Foo__f1()

class Bar(Foo):
def __f1(self): #_Bar__f1
print("Bar.f1")

obj=Bar()

obj.f2()

強調：封裝單從字面意思去看等同于隱藏，但其實封裝絕對不是單純意義的隱藏

2、為什么要用封裝

1 封裝數據屬性的目的：把數據屬性封裝起來，然后需要開辟接口給類外部的使用者使用，好處是
我們可以在接口之上添加控制邏輯，從而嚴格空間訪問者對屬性的操作
class People:
def __init__(self,name,age):
self.__name=name
self.__age=age

def tell_info(self):
# u=input('user>>: ').strip()
# p=input('pwd>>: ').strip()
# if u == 'egon' and p == '123':
print(self.__name,self.__age)

def set_info(self,name,age):
if type(name) is not str:
raise TypeError('用戶名必須為str類型')
if type(age) is not int:
raise TypeError('年齡必須為int類型')
self.__name=name
self.__age=age

p=People('egon',18)

# p.tell_info()
# p.tell_info()

# p.set_info('EGON',19)
# p.tell_info()

# p.set_info(353535353535353535,20)
p.set_info('EGON','20')



#2 封裝函數屬性的目的：為了隔離復雜度

class ATM:
def __card(self):
print('插卡')
def __auth(self):
print('用戶認證')
def __input(self):
print('輸入取款金額')
def __print_bill(self):
print('打印賬單')
def __take_money(self):
print('取款')

def withdraw(self):
self.__card()
self.__auth()
self.__input()
self.__print_bill()
self.__take_money()


obj=ATM()
obj.withdraw()

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

轉載于:https://www.cnblogs.com/zhaodafa/p/8823866.html

總結

以上是生活随笔為你收集整理的类的组合与封装的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。