一,組合
1,什麼是組合
組合指的是某一物件擁有乙個屬性,該屬性的值是另外乙個類的物件
class foo:
pass
class bar:
pass
obj=foo()
obj.attr=bar()
obj.***
obj.attr.yyy
2,為何要用組合
通過為某乙個物件新增屬性(屬性的值是另外乙個類的物件)的方式,可以間接地將兩個類關聯/整合/組合到一起
從而減少類與類之間**冗餘
class foo1:
pass
class foo2:
pass
class foo3:
pass
class bar:
pass
obj_from_bar=bar()
obj1=foo1()
obj2=foo2()
obj3=foo3()
obj1.attr1=obj_from_bar
obj2.attr2=obj_from_bar
obj3.attr3=obj_from_bar
3,如何用組合
class oldboypeople:
school='oldboy'
def __init__(self,name,age,***):
self.name = name
self.age = age
self.*** = ***
class oldboystudent(oldboypeople):
def __init__(self,name,age,***,score):
oldboyppeople.__init__(self,name,age,***)
self.score = score
def choose_course(self):
print('%s choosing course' % self.name)
class oldboyteacher(oldboypeople):
def __init__(self,name,age,***,level):
oldboypeople.__init__(self,name,age,***)
self.level=level
def score(self,stu,num):
stu.score=num
class course:
def __init__(self,c_name,c_price,c_period):
self.c_name = c_name
self.c_price = c_price
self.c_period = c_period
def tell_info(self):
print('《課程名:%s 價錢:%s 週期:%s>' %(self.c_name,self.c_price,self.c_period)) #呼叫函式的時候設定的乙個輸出格式
# 建立課程物件
python=course('python全棧開發',1900,'5mons')
linux=course('linux架構師',900,'3mons')
# 建立乙個學生物件
stu1=oldboystudent('劉二蛋',38,'male')
stu1.course=python
stu1.course.tell_info() # 輸出格式
# 建立乙個教室物件
tea1=oldboyteacher('egon',18,'male',10)
tea1.course=python
# print(tea1.__dict__)
tea1.course.tell_info()
二,多型與多型性
1,什麼是多型
多型指的是同一種/類事物的不同形態
2,為何要用多型
多型性:在多型的背景下,可以在不用考慮物件具體型別的前提下而直接使用物件
多型性的精髓:統一
3,如何要用多型
import abc
class animal(metaclass=abc.abcmeta): # 強制要求子類嚴格按父類的格式來
@abc.abstractmethod
def speak(self):
pass
@abc.abstractmethod
def run(self):
pass
# animal() # 父類只是用來建立規範的,不能用來例項化的,更無需實現內部的方法
class people(animal):
def speak(self):
print('say hello')
def run(self):
pass
class dog(animal):
def speak(self):
print('汪汪汪')
def run(self):
pass
class pig(animal):
def speak(self):
print('哼哼哼')
def run(self):
pass
obj1=people()
obj2=dog()
obj3=pig()
鴨子型別:長得像鴨子就認為是鴨子 #沒有父類好多子類(沒有直接的關係)的實現的方法都一樣,從多型的角度就
可以認為這些子類就是鴨子
規定:有text()方法的類都是鴨子
下面很多子類產生的物件都可以呼叫text()方法
####### 這裡缺乙個老師補課時舉得例子,幫助理解
三,封裝(出發點就是安全)
1,什麼是封裝
裝:往容器/命名空間裡存放名字
封:代表將存放於命名空間中的名字給藏起來,這種隱藏對外不對內
2,為何要封裝
分兩種,封資料屬性
封函式屬性
3,如何封裝
在類內定義的屬性前加__開頭(沒有__結尾)
總結:1,__開頭的屬性實現的隱藏僅僅只是一種語法意義上的變形,並不會真的限制類外部的訪問
2,該變形操作只在類的定義階段檢測語法時發生一次,類定義階段之後新增的__開頭的屬性並不會變形
# 在增加屬性是__開頭的屬性並不會變形
3,如果父類不想讓子類覆蓋自己的屬性,可以在屬性的前面加__開頭
class foo:
__x=111 # _foo__x
__y=222 # _foo__y
def __init__(self,name,age):
self.__name=name
self.__age=age
def __func(self): #_foo__func
print('func')
def get_info(self):
print(self.__name,self.__age,self.__x) #print(self._foo__name,self._foo__age,self._foo__x)
obj = foo()
obj.__x #會報錯,根本找不到__x
# 封裝資料屬性:將資料屬性隱藏起來,類外就無法直接操作屬性,需要類內開闢乙個介面來外部可以間接地操作屬性,可以在介面內定義任意的控制邏輯,從而嚴格控制使用對屬性的操作
# 封裝函式的屬性:隔離複雜度
class people:
def __init__(self,name,age):
self.__name=name
self.__age=age
def tell_info(self):
print('' %(self.__name,self.__age))
def set_info(self,name,age):
if type(name) is not str:
print('名字必須是str型別傻叉')
return
if type(age) is not int:
print('年齡必須是int型別傻叉')
return
self.__name=name
self.__age=age
obj=people('egon',18)
# obj.tell_info()
# obj.set_info('egon',19)
# obj.set_info(123,19)
obj.set_info('egon','18')
obj.tell_info()
面對物件的三大特性 三 多型
動態編譯型別 同一方法可以根據傳送物件的不同而採用多種不同的行為方式。乙個物件的實際型別是確定的，但可以指向物件的引用的型別有很多。注意 多型是方法的多型，屬性沒有多型性 instanceof 乙個物件的實際型別是確定的 new student new person 但是，可以指向的引用型別就不確定...
面對物件三大特性
1.封裝 安全，在需要封裝的屬性或者函式前加雙下劃線，並提供讀 寫的介面 1.封裝是物件導向程式設計的一大特點 2.物件導向程式設計的第一步 將屬性和方法封裝到乙個抽象的類中 為什麼說是抽象的，因為類不能直接使用 3.外界使用類建立物件，然後讓物件呼叫方法 4.物件方法的細節都被封裝在類的內部 cl...
java面對物件三大特性
繼承 概念繼承通過extends關鍵字來實現,其中subclass稱為子類,superclass稱為父類,基類,或超類 作用 重用，復用 單繼承乙個類，只能繼承乙個父類 乙個類，可以有多個子類 不繼承構造方法不繼承 沒有訪問許可權的成員不繼承 靜態成員不繼承 多型多型指的是編譯器 申明變數是 和執行...