面向對象【一】什麼是面向對象

• 2. 沒法向面向過程的程序設計流水線式的能夠很精準的預測問題的處理流程與結果，面向對象的程序一旦開始就由對象之間的交互解決問題，即使是上帝也沒法準確地預測最終結果。因而咱們常常看到對戰類遊戲，新增一個遊戲人物，在對戰的過程當中極容易出現陰霸的技能，一刀砍死3我的，這種狀況是沒法準確預知的，只有對象之間交互才能準確地知道最終的結果。
• 應用場景：需求常常變化的軟件，通常需求的變化都集中在用戶層，互聯網應用，企業內部軟件，遊戲等都是面向對象的程序設計大顯身手的好地方

面向對象的程序設計並非所有。對於一個軟件質量來講，面向對象的程序設計只是用來解決擴展性。

面向過程實質上就是分析出解決問題所須要的步驟，而後用函數把這些步驟一步一步實現，使用的時候一個一個依次調用就能夠了。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

while  True ：      if  cpu利用率 >  90 % :          #發送郵件提醒          鏈接郵箱服務器          發送郵件          關閉鏈接         if  硬盤使用空間 >  90 % :          #發送郵件提醒          鏈接郵箱服務器          發送郵件          關閉鏈接         if  內存佔用 >  80 % :          #發送郵件提醒          鏈接郵箱服務器          發送郵件          關閉鏈接

 隨着時間的推移，開始使用了函數式編程，加強代碼的重用性和可讀性，就變成了這樣：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

def  發送郵件(內容)      #發送郵件提醒      鏈接郵箱服務器      發送郵件      關閉鏈接    while  True ：         if  cpu利用率 >  90 % :          發送郵件( 'CPU報警' )         if  硬盤使用空間 >  90 % :          發送郵件( '硬盤報警' )         if  內存佔用 >  80 % :          發送郵件( '內存報警' )

面向對象(Object Oriented,OO)是軟件開發方法。面向對象的概念和應用已超越了程序設計和軟件開發，擴展到如數據庫系統、交互式界面、應用結構、應用平臺、分佈式系統、網絡管理結構、CAD技術、人工智能等領域。面向對象是一種對現實世界理解和抽象的方法，是計算機編程技術 ^[1]  發展到必定階段後的產物。

面向對象設計

面向對象設計：
類：把一類事物相同的特徵和動做整合到一塊兒,是一個抽象概念
對象：基於類而建立的一個具體的事物(具體存在的)也是特徵和動做整合到一塊兒；

def func(name,gender,type):
    #動做
    def inner(dog):
        print("%s在工做"%dog["name"])
    def person(dog):
        print("%s在吃%s"%(dog["name"],dog["type"]))
    #特徵
    res = {
        "name":name,
        "gender":gender,
        "type":type,
        "inner":inner,
        "person":person,
    }
    return res
d1 = func("老王","中","飯")
print(d1)
d1["inner"](d1)
d1["person"](d1)
"""
一、執行func("老王","中","飯")會返回字典res，該過程叫初始化；
二、因字典中有動做的函數名,so經過取字典中的key值獲得value加上括號傳入參數便可執行；
"""

基礎版

基礎版

def func(name,gender,type):
    #動做  功能函數
    def inner(dog):
        print("%s在工做"%dog["name"])
    def person(dog):
        print("%s在吃%s"%(dog["name"],dog["type"]))
    #特徵  初始化函數
    def init(name,gender,type):
        res = {
            "name":name,
            "gender":gender,
            "type":type,
            "inner":inner,
            "person":person,
        }
        return res
    return init(name,gender,type)
d1 = func("老王","中","飯")
print(d1)
d1["inner"](d1)
d1["person"](d1)
"""
一、執行func()會返回init()函數,init()函數被執行,返回字典res；init函數叫作初始化函數；
二、因字典中有動做的函數名,so經過取字典中的key值獲得value加上括號傳入參數便可執行；
"""

升級版

升級版

類和對象

類即類別、種類，是面向對象設計最重要的概念，對象是特徵與技能的結合體，而類則是一系列對象類似的特徵與技能的結合體 

那麼問題來了，先有的一個個具體存在的對象（好比一個具體存在的人），仍是先有的人類這個概念，這個問題須要分兩種狀況去看 

在現實世界中：先有對象，再有類

世界上確定是先出現各類各樣的實際存在的物體，而後隨着人類文明的發展，人類站在不一樣的角度總結出了不一樣的種類，如人類、動物類、植物類等概念

也就說，對象是具體的存在，而類僅僅只是一個概念，並不真實存在 

在程序中：務必保證先定義類，後產生對象

這與函數的使用是相似的，先定義函數，後調用函數，類也是同樣的，在程序中須要先定義類，後調用類

不同的是，調用函數會執行函數體代碼返回的是函數體執行的結果，而調用類會產生對象，返回的是對象

面向對象編程

面向對象編程是一種編程方式，此編程方式的落地須要使用 「類」 和 「對象」 來實現，因此，面向對象編程其實就是對 「類」 和 「對象」 的使用。

　　類就是一個模板，模板裏能夠包含多個函數，函數裏實現一些功能

　　對象則是根據模板建立的實例，經過實例對象能夠執行類中的函數

• class是關鍵字，表示類
• 建立對象，類名稱後加括號便可

學校類：

特徵：name，addr，type

動做：考試，招生，開除學生

class School:
    #實例化
    def __init__(self):
        pass
    #考試
    def Examination(self):
        pass
    #招生
    def Recruit_students(self):
        pass
person = School()

class School:
    #實例化,init函數不能夠有返回值,返回值爲空
    def __init__(self,name,addr,type):
        self.name = name
        self.addr = addr
        self.type = type
    #考試
    def Examination(self):
        print("%s正在考試"%self.name)
    #招生
    def Recruit_students(self):
        print("%s正在招生"%self.name)
person = School("oldboy","沙河","私立")
print(person.__dict__)#{'name': 'oldboy', 'addr': '沙河', 'type': '私立'}
person.Examination() #oldboy正在考試
person.Recruit_students() #oldboy正在招生

舉例

舉例

#在現實世界中，站在老男孩學校的角度：先有對象，再有類
對象1：李坦克
    特徵:
        學校=oldboy
        姓名=李坦克
        性別=男
        年齡=18
    技能：
        學習
        吃飯
        睡覺

對象2：王大炮
    特徵:
        學校=oldboy
        姓名=王大炮
        性別=女
        年齡=38
    技能：
        學習
        吃飯
        睡覺

對象3：牛榴彈
    特徵:
        學校=oldboy
        姓名=牛榴彈
        性別=男
        年齡=78
    技能：
        學習
        吃飯
        睡覺


現實中的老男孩學生類
    類似的特徵:
        學校=oldboy
    類似的技能：
        學習
        吃飯
        睡覺

現實中

現實中

#在程序中，務必保證：先定義（類），後使用（產生對象）
PS:
  1. 在程序中特徵用變量標識，技能用函數標識
  2. 於是類中最多見的無非是：變量和函數的定義

#程序中的類
class OldboyStudent:
    school='oldboy'
    def learn(self):
        print('is learning')
        
    def eat(self):
        print('is eating')
    
    def sleep(self):
        print('is sleeping')
  


#注意：
  1.類中能夠有任意python代碼，這些代碼在類定義階段便會執行
  2.於是會產生新的名稱空間，用來存放類的變量名與函數名，能夠經過OldboyStudent.__dict__查看
  3.對於經典類來講咱們能夠經過該字典操做類名稱空間的名字（新式類有限制），但python爲咱們提供專門的.語法
  4.點是訪問屬性的語法，類中定義的名字，都是類的屬性

#程序中類的用法
.:專門用來訪問屬性，本質操做的就是__dict__
OldboyStudent.school #等於經典類的操做OldboyStudent.__dict__['school']
OldboyStudent.school='Oldboy' #等於經典類的操做OldboyStudent.__dict__['school']='Oldboy'
OldboyStudent.x=1 #等於經典類的操做OldboyStudent.__dict__['x']=1
del OldboyStudent.x #等於經典類的操做OldboyStudent.__dict__.pop('x')


#程序中的對象
#調用類，或稱爲實例化，獲得對象
s1=OldboyStudent()
s2=OldboyStudent()
s3=OldboyStudent()

#如此，s一、s二、s3都同樣了，而這三者除了類似的屬性以外還各類不一樣的屬性，這就用到了__init__
#注意：該方法是在對象產生以後纔會執行，只用來爲對象進行初始化操做，能夠有任意代碼，但必定不能有返回值
class OldboyStudent:
    ......
    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex
    ......


s1=OldboyStudent('李坦克','男',18) #先調用類產生空對象s1，而後調用OldboyStudent.__init__(s1,'李坦克','男',18)
s2=OldboyStudent('王大炮','女',38)
s3=OldboyStudent('牛榴彈','男',78)


#程序中對象的用法
#執行__init__,s1.name='牛榴彈'，很明顯也會產生對象的名稱空間
s2.__dict__
{'name': '王大炮', 'age': '女', 'sex': 38}

s2.name #s2.__dict__['name']
s2.name='王三炮' #s2.__dict__['name']='王三炮'
s2.course='python' #s2.__dict__['course']='python'
del s2.course #s2.__dict__.pop('course')

程序中

程序中

！！！細說__init__方法！！！

#方式1、爲對象初始化本身獨有的特徵
class People:
    country='China'
    x=1
    def run(self):
        print('----->', self)

# 實例化出三個空對象
obj1=People()
obj2=People()
obj3=People()

# 爲對象定製本身獨有的特徵
obj1.name='egon'
obj1.age=18
obj1.sex='male'

obj2.name='lxx'
obj2.age=38
obj2.sex='female'

obj3.name='alex'
obj3.age=38
obj3.sex='female'

# print(obj1.__dict__)
# print(obj2.__dict__)
# print(obj3.__dict__)
# print(People.__dict__)





#方式2、爲對象初始化本身獨有的特徵
class People:
    country='China'
    x=1
    def run(self):
        print('----->', self)

# 實例化出三個空對象
obj1=People()
obj2=People()
obj3=People()

# 爲對象定製本身獨有的特徵
def chu_shi_hua(obj, x, y, z): #obj=obj1,x='egon',y=18,z='male'
    obj.name = x
    obj.age = y
    obj.sex = z

chu_shi_hua(obj1,'egon',18,'male')
chu_shi_hua(obj2,'lxx',38,'female')
chu_shi_hua(obj3,'alex',38,'female')





#方式3、爲對象初始化本身獨有的特徵
class People:
    country='China'
    x=1

    def chu_shi_hua(obj, x, y, z): #obj=obj1,x='egon',y=18,z='male'
        obj.name = x
        obj.age = y
        obj.sex = z

    def run(self):
        print('----->', self)


obj1=People()
# print(People.chu_shi_hua)
People.chu_shi_hua(obj1,'egon',18,'male')

obj2=People()
People.chu_shi_hua(obj2,'lxx',38,'female')

obj3=People()
People.chu_shi_hua(obj3,'alex',38,'female')




# 方式4、爲對象初始化本身獨有的特徵
class People:
    country='China'
    x=1

    def __init__(obj, x, y, z): #obj=obj1,x='egon',y=18,z='male'
        obj.name = x
        obj.age = y
        obj.sex = z

    def run(self):
        print('----->', self)

obj1=People('egon',18,'male') #People.__init__(obj1,'egon',18,'male')
obj2=People('lxx',38,'female') #People.__init__(obj2,'lxx',38,'female')
obj3=People('alex',38,'female') #People.__init__(obj3,'alex',38,'female')


# __init__方法
# 強調：
#   一、該方法內能夠有任意的python代碼
#   二、必定不能有返回值
class People:
    country='China'
    x=1

    def __init__(obj, name, age, sex): #obj=obj1,x='egon',y=18,z='male'
        # if type(name) is not str:
        #     raise TypeError('名字必須是字符串類型')
        obj.name = name
        obj.age = age
        obj.sex = sex


    def run(self):
        print('----->', self)


# obj1=People('egon',18,'male')
obj1=People(3537,18,'male')

# print(obj1.run)
# obj1.run() #People.run(obj1)
# print(People.run)

！！！__init__方法之爲對象定製本身獨有的特徵

！！！細說__init__方法之爲對象定製本身獨有的特徵