Python——面向對象的三個基本特徵和幾種運行方法

一、面向對象

1.簡單介紹

"""
面向過程：怎麼做
面向對象：誰來做
1.確定職責 -- 要做的事(方法)
2.對象內部封裝不同方法(多個)
3.不同對象調用不同方法
類 對象
類：模板，對象都是根據這個模板創建出來的
類只需要有一個，對象可以有多個

類：屬性(信息)和方法(你能幹什麼)
1.類名
2.屬性
3.方法

面向對象的程序設計的
優點是：解決了程序的擴展性。對某一個對象單獨修改，會立刻反映到整個體系中，如對遊戲中一個人物參數的特徵和技能修改都很容易。
缺點：可控性差，無法向面向過程的程序設計流水線式的可以很精準的預測問題的處理流程與結果，面向對象的程序一旦開始就由對象之間的交互解決問題，即便是上帝也無法預測最終結果。於是我們經常看到一個遊戲人某一參數的修改極有可能導致陰霸的技能出現，一刀砍死3個人，這個遊戲就失去平衡。
應用場景：需求經常變化的軟件，一般需求的變化都集中在用戶層，互聯網應用，企業內部軟件，遊戲等都是面向對象的程序設計大顯身手的好地方。

面向過程的程序設計的核心是過程（流水線式思維），過程即解決問題的步驟，面向過程的設計就好比精心設計好一條流水線，考慮周全什麼時候處理什麼東西。
優點是：極大的降低了寫程序的複雜度，只需要順着要執行的步驟，堆疊代碼即可。
缺點是：一套流水線或者流程就是用來解決一個問題，代碼牽一髮而動全身。
應用場景：一旦完成基本很少改變的場景，著名的例子有Linux內核，git，以及Apache HTTP Server等。
"""

"""
例：小貓愛吃魚，小貓要喝水
self:哪一個對象調用的方法，self就是哪個對象的引用
"""
class Cat():
    def eat(self):
        print('%s愛吃魚' %self.name)
    def drink(self):
        print('小貓要喝水')

tom = Cat()
tom.name = 'Tom'
tom.drink()
tom1 = Cat()
# print(tom1)
tom1.drink()
print(id(tom))
print(id(tom1))					##查看兩個調用類方法的地址，雖然輸出內容相同，但是地址不同

2.類和實例化

"""
1.如何定義類  class 類名(): pass
2.類創建對象的過程稱爲實例化，把抽象的類具體化
對象名 = 類名(參數1、參數2...參數n)
"""

#類：模板
class People():
    #屬性：類中的變量
    name = 'yy'
    age = 21
    #方法：類中的函數
    def eat(self):
        print('吃東西')

    def sleep(self):
        print('睡覺中')
#實例化：通過類創建對象
p1 = People()
p2 = People()
print(p1.name)
print(p2.name)
#在實例化後調用類中的方法
p1.eat()					
p2.sleep()

3.類和屬性

class People():
    #構造方法：
    def __init__(self):     ##一般常用爲self，也可以自己定義名稱
        print('self',self)

p1 = People()
print('p1',p1)          ##可以看出self就是調用的對象本身，地址是相同的

二、面向對象的三個基本特徵

1.封裝

#封裝就是把同一類型的東西放在一起，通過self.xxx去調用
class People():

    def __init__(self,name,age):
        #類裏的self實質就是對象本身
        #self是對象，name是屬性，self.name就是將對象和屬性封裝在一起
        self.name = name
        self.age = age

    def run(self):
        print('%s正在跑步' %(self.name))

    def year(self):
        print('%s今年%s歲了' %(self.name,self.age))

p1 = People('yy',21)     ##定義了兩個屬性時，即使只用到其中一個，但是兩個值都得有輸入
p1.run()

p2 = People('zz',18)
p2.year()

2.繼承

"""
定義一個類，可以從現有的某個類繼承
新的類稱爲子類、擴展類(Subclass),被繼承的稱爲父類、基類、超類
(Baseclass、Superclass)
"""

'''(1)'''
class Father():
    def __init__(self,name,age):
        #構造方法在實例化對象時自動執行
        self.name = name
        self.age = age

    def eat(self):
        print('%s正在吃東西' %(self.name))

    def sleep(self):
        print('%s正在睡覺' %(self.name))
#實例化對象默認執行構造方法，子類沒有的方法會調用父類的
class Son(Father):
    def eat(self):
        #Father.eat(self) 	 ##子類與父類方法相同時，先調用父類方法，再調用子類方法，一般用第二種方法，因爲它沒有調用父類名稱
        super(Son,self).eat()        ##子類與父類方法相同時，先調用父類方法，再調用子類方法
        print('%s沒有吃飯' %(self.name))

father = Father('yy',21)
son = Son('y',18)
#子類中有與父類相同的方法時，默認調用的是子類中的方法
son.eat()
#子類中沒有，會自己調用父類方法
son.sleep()

'''2.繼承具有傳遞性，子類可以調用父類的父類的屬性和方法'''
class Animal():
    def eat(self):
        print('吃魚')

    def drink(self):
        print('喝水')

    def sleep(self):
        print('睡覺')

class Cat(Animal):
    def yell(self):
        print('喵~')

class Jiqimao(Cat):
    def speak(self):
        print('我會說話')

jqm = Jiqimao()
jqm.speak()
jqm.yell()
jqm.eat()

'''3.多個父類的繼承，類中的方法相同時，誰寫在前面先繼承誰，第一個中沒有才會繼承第二個父類'''
class A():
    def test(self):
        print('A --- test方法')
    def demo1(self):
        print('A --- demo1方法')

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

class C(A,B):
    pass

c = C()
c.test()
c.demo()

3.str方法

class People():

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

    def __str__(self):
        ##必須返回一個字符串
        return '我是%s' %(self.name)

p1 = People('yy')
print(p1)

舉個簡單的應用例子：
"""
題目要求1：
1.小明體重75.0公斤
2.小明每次跑步會減肥0.5公斤
3.小明每次吃東西體重會增加1公斤

題目要求2：
1.小明和小美都愛跑步
2.小美體重45.0公斤
3.小明體重75.0公斤
4.每次跑步都會減少0.5公斤
5.每次吃東西都會增加1公斤
"""

class People():
    def __init__(self,name,weight):
        self.name = 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

yy = People('小明',75)
yy.run()
print(yy)
zz = People('小美',45)
zz.eat()
print(zz)

4.多態性

"""
對擴展開放：允許子類重寫方法
對修改封閉：不修改，直接繼承父類方法
"""
class Student():
    def get_score(self):
        print('獲取學生成績')

class Chinese():
    def get_score(self):
        print('獲取語文成績')

class Math():
    def get_score(self):
        print('獲取數學成績')

student1 = Student()
student2 = Chinese()
student3 = Math()
student1.get_score()
student2.get_score()
student3.get_score()

5.類屬性類方法

"""
類屬性：使用賦值語句在class關鍵字下定義
類方法：在類內部可以直接訪問類屬性或者其他類方法
類方法由類調用，至少一個cls參數，並且需要裝飾器@classmethod修飾
cls指向當前的類對象,類對象不等於實例對象,類對象和實例對象都有單獨的內存空間存儲,
當調用一個含有@classmethod裝飾的方法,則會先加載這個類的內存空間
"""
class Student(object):
    count = 0

    def __init__(self,name):
        self.name = name
        Student.count += 1

    @classmethod
    def Show_Student_count(awda):			##一般爲self，但是也可以是自己定義的，函數內應該統一這個名稱
        print('學生數量爲 %d' %(awda.count))		##這裏的awda.count實際上就是Student.count,但是不等同

student1 = Student('小明')
student2 = Student('小美')
Student.Show_Student_count()

6.靜態方法

"""
靜態方法由類調用，不需要參數，需要裝飾器@staticmethod修飾
靜態方法不不要使用實例對象的屬性方法也不需要使用類對象的屬性所有無論往靜態方法中傳一個self還是cls都會加載對應的資源,
而靜態方法又不使用,所有爲了節省資源靜態方法就應運而生
"""
class Cat(object):

    @staticmethod
    def call():
        print('喵~')

Cat.call()

7.私有屬性和私有方法

"""
Python默認的成員函數和成員變量都是公開的， 
在Python中定義私有變量只需要在變量名或函數名前加上 "__"兩個下劃線，那麼這個函數或變量就會爲私有的了
若聲明該方法爲私有方法，則不能在類的外部調用
"""
class Women():

    def __init__(self,name):
        self.name = name
        self.__age = 18

    def __secret(self):
        print('%s的年齡是%d' %(self.name,self.__age))

lily = Women('lily')
print(lily.name)
# print(lily.__age)         ##私有屬性不能在外部訪問，會報錯
lily.__secret()             ##在外部調用私有方法也會報錯

"""
通過內部調用私有方法可以讓外部看到私有屬性
"""
class Student(object):

    def __init__(self,name,score):
        self.__name = name
        self.__socre = score

    def get_name(self):             
        return self.__name

    def get_score(self):
        return self.__socre

tom = Student('Tom',89)
print(tom.get_score())
print(tom.get_name())