面向物件和麵向過程

面向過程就是分析出解決問題所需要的步驟，然後用函式把這些步驟一步一步實現，使用的時候一個一個依次呼叫就可以了；
面向物件是把構成問題事務分解成各個物件，建立物件的目的不是為了完成一個步驟，而是為了描敘某個事物在整個解決問題的步驟中的行為。

一·面向物件的基本語法

1、簡單的動物特性的面向物件程式設計

# _*_ coding:utf-8 _*_
"""
file: 面向物件_3.py
date: 2018-07-23 18:29
author: jiong
desc:
類的設計：
在程式中,要設計一個類,通常需要滿足以下三個需求:
1.類名 這類事物的名字,滿足大駝峰命名法
2.屬性 這類事物具有什麼樣的特徵
3.方法 這類事物具有什麼樣的行為

面向物件的基礎語法：
定義簡單的類：
定義只包含方法的類：
class 類名：
    def 方法1(self,引數列表)：
        pass
    def 方法2(self,引數列表)：
        pass

當一個類定義完成之後,要使用這個類來建立物件,語法格式如下:
物件變數 = 類名()
需求
    小狗愛吃肉，小狗愛玩耍
"""
 

# 定義一個類，但是隻有一個類是無法輸出的
class Dog():
    def eat(self):
        print '小狗愛吃肉'
    def play(self):
        print '小狗愛玩耍'
# 將類轉換到物件
dou = Dog()
dou.eat()
dou.play()

2、一個類可以建立多個物件

# _*_ coding:utf-8 _*_
"""
file: 面向物件_1.py
date: 2018-07-23 13:40
author: jiong
desc:

需求：
    小貓愛吃魚,小貓愛喝水

"""
class Cat
 
():
    # 哪一個物件呼叫的方法,self就是哪一個物件的引用
    def eat(self):
        print '%s like eating fish' % self.name
    def drink(self):
        print '小貓愛喝水'

# 建立貓物件
dudu = Cat()
dudu.name = 'dudu'   #給貓一個名字
dudu.eat()
dudu.drink()
print dudu
#addr = id(dudu)
# %x:列印格式為十六進位制的記憶體地址
#print '%x' % addr
# %x:列印格式為十進位制的記憶體地址
 

#print '%d' % addr

# 再建立一個貓物件(記憶體地址與dudu的不同)
lazy_cat = Cat()
lazy_cat.name = 'bobo'
lazy_cat.eat()
lazy_cat.drink()
print lazy_cat

lazy_cat2 = lazy_cat
print lazy_cat2  #記憶體地址與lazy_cat相同

3、在類的外部給物件增加屬性會報錯：（還是剛才的指令碼做了點修改）

# _*_ coding:utf-8 _*_
"""
file: 面向物件_2.py
date: 2018-07-23 16:15
author: jiong
desc:

需求:小狗愛吃骨頭,小狗喜歡汪汪叫
"""
class Dog():
    # self:哪一個物件呼叫的方法,self就是哪一個物件的引用
    def eat(self):
        print '%s love a bone'  % self.name
    def shout(self):
        print '小狗喜歡汪汪叫'

# 建立狗物件
shoutao = Dog()
shoutao.name = 'shoutao'
shoutao.eat()
shoutao.shout()
print shoutao
addr = id(shoutao)
# %x:列印格式為十六進位制
print '%x' % addr
# %d:列印格式為十進位制
print '%d' % addr

# 再建立一個狗物件
Dog_1 = Dog()
Dog_1.eat()
Dog_1.shout()

Dog_2 = Dog_1
print Dog_2

二·初始化方法

# _*_ coding:utf-8 _*_
"""
file: 面向物件_4.py
date: 2018-07-23 22:52
author: jiong
desc:
初始化方法
我們現在已經知道了使用 類名() 就可以建立一個物件
當使用類名()建立物件時,python的直譯器就會自動執行以下操作：
    1.為物件在記憶體中分配空間--建立物件
    2.呼叫初始化方法為物件的屬性設定初始值--初始化方法(__init__)
這個初始化方法就是__init__方法,__init__時物件的內建方法
__init__方法是專門用來定義一個類具有那些屬性的方法

"""


class Cat():
    def __init__(self):
        print '這是一個初始化方法'
        # self.屬性名 = 屬性的初始值
        self.name = 'dudu'


# 使用 類名() 建立物件的時候,會自動呼叫初始化方法_init_
dudu = Cat()
print dudu.name


class Cat():
    def __init__(self, new_name):
        self.name = new_name
        # 在類中,任何方法都可以使用self.name

    def eat(self):
        print '%s like eating fish' % self.name


dudu = Cat('dudu')
print dudu.name
dudu.eat()

lazy_cat = Cat('lazy_cat')
lazy_cat.eat()

1、直接呼叫初始化不加入形參

# _*_ coding:utf-8 _*_
"""
file: 面向物件_5.py
date: 2018-07-23 22:59
author: jiong
desc:


"""
class Cat():
    def __init__(self):
        self.name = 'Tom'
        # 在類中，任何方法都可以使用self.name
    def eat(self):
        print '%s 愛吃魚' % self.name
tom = Cat()
print tom.name
tom.eat()
# 重新定義一個貓輸出還是Tom,顯然不合理
lazy_cat = Cat()
lazy_cat.eat()

2、呼叫初始化加入形參

# _*_ coding:utf-8 _*_
"""
file: 面向物件_6.py
date: 2018-07-23 23:01
author: jiong
desc:


"""
class Cat():
    def __init__(self,new_name):  # new_name為形參
        # 在類中，任何方法都可以使用self.name
        self.name = new_name
    def eat(self):
        print '%s 愛吃魚' % self.name
tom = Cat('tom')    # 必須給傳遞實際的引數不然會報錯
print tom.name
tom.eat()
lazy_cat = Cat('lazy_cat')   # 必須給傳遞實際的引數不然會報錯
lazy_cat.eat()

三·面向物件程式設計的三大特點

1.封裝：根據職責將屬性和方法封裝到一個抽象的類中
定義類的準則
2.繼承：實現程式碼的重用，相同的程式碼不需要重複的編寫
設計類的技巧
子類針對自己特有的需求，編寫特定的程式碼
3.多型：
不同的子類物件呼叫相同的方法，產生不同的執行結果

1、封裝

# _*_ coding:utf-8 _*_
"""
file: 封裝_1.py
date: 2018-07-23 23:05
author: jiong
desc:
封裝：
1.封裝是面向物件程式設計的一大特點
2.面向物件程式設計的第一步 將屬性和方法封裝到一個抽象的類中
3.外界使用類建立物件,然後讓物件呼叫方法
4.物件方法的細節都被封裝在類的內部

需求：
1.xx愛跑步
2.xx體重50公斤
3.xx每次跑步會減肥0.5公斤
4.xx每次吃東西體重會增加1公斤

"""
class Person():
    def __init__(self,new_name,weight):
        self.name = new_name
        self.weight = weight
    def __str__(self):
        return '我的名字叫%s 體重是%.2f' % (self.name,self.weight)
    def run(self):
        print '%s 愛跑步' % self.name
        self.weight -= 0.5
    def eat(self):
        print '%s 吃東西' % self.name
        self.weight += 1

name = Person('jiong',52.0)
#name.run()
name.eat()
print name

1、士兵開槍案例：

# _*_ coding:utf-8 _*_
"""
file:士兵開槍.py
date:2018-07-21 7:21 AM
author:Jiong
desc:


"""
class Gun():
    def __init__(self,model):
        # 槍的型號
        self.model = model
        # 子彈的數量
        self.bullet_count = 0
    def add_bullet(self,count):
        self.bullet_count += count

    def shoot(self):
        # 1.判斷子彈的數量
        if self.bullet_count <= 0:
            print '%s 沒有子彈' % self.model
            return
        # 2.發射子彈
        self.bullet_count -= 1
        # 3。提示發射資訊
        print '%s 突突突 %d' %(self.model,self.bullet_count)

class Soldier():
    def __init__(self,name):
        self.name = name
        self.gun = None
    def fire(self):
        # 1.判斷士兵沒有槍
        if self.gun == None:
            print '%s 需要一把槍' %self.name
            return
        # 2.高喊口號
        print 'go!!! %s' % self.name
        # 3.讓槍裝填
        self.gun.add_bullet(50)
        # 4.讓槍發子彈
        self.gun.shoot()

# 1.建立槍物件
ak47 = Gun('AK47')
# ak47.add_bullet(50)
# ak47.shoot()

# 建立士兵
ryan = Soldier('Ryan')
ryan.gun = ak47
ryan.fire()
print ryan.gun

2、擺放傢俱（沒有完成新增傢俱）

# _*_ coding:utf-8 _*_
"""
file:擺放傢俱1.py
date:2018-07-21 5:44 AM
author:Jiong
desc:
1.房子有戶型,總面積和傢俱名稱列表
  新房子沒有任何傢俱
2.傢俱有名字和佔地面積,其中
    床：佔4平米
    衣櫃：佔2平米
    餐桌：佔2平米
3.將以上三件傢俱新增到房子中
4.列印房子時,要求輸出：戶型,總面積,剩餘面積,傢俱名稱列表

小結：
1.建立了一個房子類,使用__init__和__str__兩個內建的方法
2.準備了一個add_item方法 準備新增傢俱
3.使用 房子類 建立了一個房子物件
4.讓 房子物件 呼叫三次add_item方式,將三件傢俱以實參的形式傳遞到add_item

"""
class Furniture():
    # 初始化方法
    def __init__(self,name,area):
        self.name = name
        self.area = area
    def __str__(self):
        return '[%s] 佔地%.2f' %(self.name,self.area)

class House():
        def __init__(self,house_type,area):
            self.house_type = house_type
            self.area = area
            #剩餘面積
            self.free_area = area
            #傢俱名稱列表
            self.item_list = []
        def __str__(self):
            return '戶型:%s\n總面積：%.2f[剩餘面積：%.2f]\n傢俱%s'\
                   % (self.house_type,self.area,self.free_area,self.item_list)
        def add_item(self,item):
            print '要新增%s' % item
            # 1.判斷傢俱的面積
            if item.area > self.free_area:
                print '%s 的面積太大了,無法新增' % item.name
                # 如果不滿足,下方的程式碼就不執行
                return
            # 2.將傢俱的名稱新增到列表中
            self.item_list.append(item.name)
            # 3.計算剩餘面積
            self.free_area -= item.area

# 建立傢俱
bed = Furniture('bed',4)
print bed
chest = Furniture('chest',2)
print chest
table = Furniture('table',2)
print table


#建立房子物件
my_home = House('兩室一廳',100)
# 新增傢俱
my_home.add_item(bed)
my_home.add_item(chest)
my_home.add_item(table)
print my_home

2、繼承

1、單繼承

# _*_ coding:utf-8 _*_
"""
file:繼承_1.py
date:2018-07-21 8:15 AM
author:Jiong
desc:
單繼承
1.繼承的概念,語法和特點
繼承的概念:子類 擁有的所有法方法和屬性（子類只需要封裝自己特有的方法）
2.繼承的語法
class 類名（父類）
    def 子類特有的方法

"""
class Animal():
    def eat(self):
        print '吃'
    def drink(self):
        print '喝'
    def run(self):
        print '跑'
    def sleep(self):
        print '睡'

class Cat(Animal):
    # 子類擁有父類的所有屬性和方法
    def call(self):
        print '喵喵喵'

mm = Cat()
mm.eat()
mm.drink()
mm.run()
mm.sleep()
mm.call()

# 子類繼承自父類,可以直接享受父類中已經封裝好的方法
# 子類中應該根據自己的職責,封裝子類特有的屬性和方法

2、繼承的傳遞性

# _*_ coding:utf-8 _*_
"""
file:繼承_2.py
date:2018-07-21 8:44 AM
author:Jiong
desc:
繼承的傳遞性：（爺爺,父親,兒子）
1.C類從B類繼承,B類又從A類繼承
2.那麼C類就具有B類和A類的所有屬性和方法
子類擁有父類以及父類的父類中封裝的所有屬和方法

"""
class Animal():
    def eat(self):
        print '吃'
    def    drink(self):
        print '喝'
    def run(self):
        print '跑'
    def sleep(self):
        print '睡'

class Cat(Animal):
    # 子類擁有父類的所有屬性和方法
    def call(self):
        print '喵喵喵'

class Hellokitty(Cat):
    def speak(self):
        print '我可以說日語'

# 建立一個hellokitty物件
kt = Hellokitty()

kt.speak()
# 子類可以繼承自父類的所有屬性和方法
kt.call()
# 繼承的傳遞性,子類擁有父類和父類的父類的所有屬性和方法
kt.eat()
kt.drink()
kt.run()
kt.sleep()

3、重寫父類

# _*_ coding:utf-8 _*_
"""
file:繼承_3.py
date:2018-07-21 8:49 AM
author:Jiong
desc:
重寫父類方法有兩種情況:
1.覆蓋父類的方法
2.對父類方法進行擴充套件

1.覆蓋父類的方法
如果在開發中,父類的方法的實現和子類方法的實現,
完全不同,就可以使用覆蓋的方法,
在子類中重新編寫父類的方法

具體實現方法,就相當於在子類中定義了
一個和父類同名的方法並且實現
重寫之後,在執行時,只會呼叫子類的重寫方法
而不會再呼叫父類封裝的方法

"""
class Animal():
    def eat(self):
        print '吃'
    def drink(self):
        print '喝'
    def run(self):
        print '跑'
    def sleep(self):
        print '睡'

class Cat(Animal):
    # 子類擁有父類的所有屬性和方法
    def call(self):
        print '喵喵～'

class Hellokitty(Cat):
    def speak(self):
        print '我可以說日語'
    def call(self):
        print '偶哈呦 空你起哇'

kt = Hellokitty()
# 如果子類中,重寫了父類的方法
# 在執行中,只會呼叫子類中重寫的方法,不會呼叫父類的方法
kt.call()

4、對父類的方法進行擴充套件

# _*_ coding:utf-8 _*_
"""
file:繼承_4.py
date:2018-07-21 9:02 AM
author:Jiong
desc:
對父類的方法進行擴充套件：
如果在開發中,子類的方法實現包含有父類的方法實現
(父類原本封裝的方法實現是子類方法的一部分就可以使用擴充套件方法)
1.在子類中重寫父類的方法
2.在需要的位置使用 父類名.方法(self)來呼叫父類方法的執行
（使用父類名稱呼叫父類方法）
3.程式碼其他的位置針對子類的需求,編寫子類特有的程式碼實現

"""
class Animal():
    def eat(self):
        print '吃'
    def drink(self):
        print '喝'
    def run(self):
        print '跑'
    def sleep(self):
        print '睡'

class Cat(Animal):
    # 子類擁有父類的所有屬性和方法
    def call(self):
        print '喵喵～'

class Hellokitty(Cat):
    def speak(self):
        print '我可以說日語'
    def call(self):
        print '偶哈呦 空你起哇'
        # 呼叫原本在父類中封裝的方法
        Cat.call(self)

kt = Hellokitty()
kt.call()

5、多繼承

# _*_ coding:utf-8 _*_
"""
file:多繼承.py
date:2018-07-22 1:13 AM
author:Jiong
desc:
多繼承：
子類擁有一個父類叫做單繼承
子類可以擁有多個父類,並且具有所有父類的屬性和方法
例如：孩子會繼承自己父親和母親的特性

"""
class A(object):
    def test(self):
        print 'A----test 方法'
    def demo(self):
        print 'A----demo 方法'

class B():
    def test(self):
        print 'B----test 方法'
    def demo(self):
        print 'B----demo 方法'

class C():
    def teat(self):
        print 'C----test 方法'
    def demo(self):
        print 'C----demo 方法'
class D(A,B,C):
    # 多繼承可以讓子類物件,同時具有多個父類的屬性和方法
    pass

d = D()
d.test()
d.demo()

3、多型

# _*_ coding:utf-8 _*_
"""
file:多型.py
date:2018-07-22 2:40 AM
author:Jiong
desc:
多型
不同的子類（這是之前提到的繼承的知識）
物件呼叫相同的方法,產生不同的執行結果

"""
class Cat(object):
    def __init__(self,name):
        self.name = name
    def play(self):
        print '%s 喜歡玩毛球' % self.name

class HelloKetty(Cat):
    def play(self):
        print '%s 會說日語' % self.name


class Person(object):
    def __init__(self,name):
        self.name = name
    def play_with_cat(self,a):
        print '%s 和 %s 玩耍' % (self.name,a.name)
        a.play()
# 建立一個貓物件
maiomiao = Cat('喵喵')
# maiomiao.play()
# 建立一個人物件
xiaoming = Person('小明')
# 讓小明和貓玩耍
xiaoming.play_with_cat(maiomiao)