面向對象

OOP編程是利用“類”和“對象”來創建各種模型來實現對真實世界的描述，使用面向對象編程的原因不僅因為它可以使程序的維護和擴展變得更簡單，並且可以大大提高程序開發效率 ，另外，基於面向對象的程序可以使它人更加容易理解你的代碼邏輯，從而使團隊開發變得更從容。

面向對象核心特性

• Class 類：一個類即是對一類擁有相同屬性的對象的抽象、藍圖、原型。在類中定義了這些對象的都具備的屬性（variables(data)）、共同的方法
• Object 對象：一個對象即是一個類的實例化後實例，一個類必須經過實例化後方可在程序中調用，一個類可以實例化多個對象，每個對象亦可以有不同的屬性，就像人類是指所有人，每個人是指具體的對象，人與人之前有共性，亦有不同
• Encapsulation 封裝：在類中對數據的賦值、內部調用對外部用戶是透明的，這使類變成了一個膠囊或容器，裏面包含著類的數據和方法
• Inheritance 繼承：一個類可以派生出子類，在這個父類裏定義的屬性、方法自動被子類繼承
• Polymorphism 多態：多態是面向對象的重要特性,簡單點說:“一個接口，多種實現”，指一個基類中派生出了不同的子類，且每個子類在繼承了同樣的方法名的同時又對父類的方法做了不同的實現，這就是同一種事物表現出的多種形態。編程其實就是一個將具體世界進行抽象化的過程，多態就是抽象化的一種體現，把一系列具體事物的共同點抽象出來, 再通過這個抽象的事物, 與不同的具體事物進行對話。對不同類的對象發出相同的消息將會有不同的行為。而且多態允許將子類的對象當作父類的對象使用，某父類型的引用指向其子類型的對象,調用的方法是該子類型的方法。這裏引用和調用方法的代碼編譯前就已經決定了,而引用所指向的對象可以在運行期間動態綁定。

簡單示例

#定義一個類， class是定義類的語法，Role是類名，(object)是新式類的寫法，必須這樣寫
class Role(object): 
     #初始化函數，在生成一個角色時要初始化的一些屬性寫在這裏
    def __init__(self,name,role,weapon,life_value=200,money=5000):
        self.name = name 
        self.role = role
        self.weapon = weapon
        self.life_value = life_value
        self.money 
 
= money
        
def buy_gun(self,gun_name):
    print(“%s has just bought %s” %(self.name,gun_name) )    
    
#生成一個角色 , 會自動把參數傳給Role下面的__init__(...)方法
r = Role(‘Tom‘,‘police‘,‘AK47’

示例解析

__init__()叫做初始化方法(或構造方法)，在類被調用時，這個方法(雖然它是函數形式，但在類中就不叫函數了,叫方法)會自動執行，進行一些初始化的動作，所以我們這裏寫的__init__(self,name,role,weapon,life_value=100,money=15000)就是要在創建一個角色時給它設置這些屬性，參數self的作用：self.name = name , self.role = role 等等的意思就是要把這幾個值 存到r的內存空間裏
執行r = Role(‘Tom‘,‘police‘,‘AK47’)時，python的解釋器其實幹了兩件事：
1,在內存中開辟一塊空間指向r這個變量名

　　2.調用Role這個類並執行其中的__init__(…)方法，相當於Role.__init__(r,‘Tom‘,‘police‘,’AK47’),這是為了把‘Alex‘,‘police‘,’AK47’這3個值跟剛開辟的r關聯起來，因為關聯起來後，你 就可以直接r.name, r.weapon這樣來調用啦。所以，為實現這種關聯，在調用__init__方法時，就必須把r這個變量也傳進去，否則__init__不會知道要把那3個參數與誰關聯起來
buy_gun(..)方法中可能要訪問r1的一些其它屬性，比如訪問r的名字，怎麽訪問呢？所以必須告訴這個方法所以需要將r傳給了這個self參數，然後在buy_gun裏調用 self.name 就相當於調用r.name ，若想知道r的生命值 有多少，可寫成self.life_value就可以。總結就是在調用類中的一個方法時，你得告知自己是誰。
總結如下：

• r = Role(‘Tom‘,‘police‘,‘AK47’)動作，叫做類的“實例化”， 就是把一個虛擬的抽象的類，通過這個動作，變成了一個具體的對象了， 這個對象就叫做實例
• 這個類體現了面向對象的第一個基本特性，封裝，其實就是使用構造方法將內容封裝到某個具體對象中，然後通過對象直接或者self間接獲取被封裝的內容

封裝

封裝是面向對象的特征之一，是對象和類概念的主要特性。封裝也就是把客觀事物封裝成抽象的類，並且類可以把自己的數據和方法只讓可信的類或者對象操作，對不可信的進行信息隱藏

繼承

繼承是指這樣一種能力：它可以使用現有類的所有功能，並在無需重新編寫原來的類的情況下對這些功能進行擴展。通過繼承創建的新類稱為“子類”或“派生類”，被繼承的類稱為“基類”、“父類”或“超類”。繼承的過程，就是從一般到特殊的過程。要實現繼承，可以通過“繼承”（Inheritance）和“組合”（Composition）來實現。在某些 OOP語言中，一個子類可以繼承多個基類。但是一般情況下，一個子類只能有一個基類，要實現多重繼承，可以通過多級繼承來實現。繼承概念的實現方式：

• 實現繼承:是指使用基類的屬性和方法而無需額外編碼的能力；
• 接口繼承:是指僅使用屬性和方法的名稱、但是子類必須提供實現的能力(子類重構爹類方法)；

ps:使用繼承時，有一點需要註意，那就是兩個類之間的關系應該是“屬於”關系。例如，Employee 是一個人，Manager 也是一個人，因此這兩個類都可以繼承 Person 類。但是 Leg 類卻不能繼承 Person 類，因為腿並不是一個人。抽象類僅定義將由子類創建的一般屬性和方法。

class SchoolMember(object):
    #初始學校人數為0
    members = 0 
    def __init__(self,name,age):
        self.name = name
        self.age = age
 
    def  tell(self):
        pass
 
    def enroll(self):
        ‘‘‘註冊‘‘‘
        SchoolMember.members +=1
        print("\033[32;1mnew member [%s] is enrolled,now there are [%s] members.\033[0m " %(self.name,SchoolMember.members))
     
    def __del__(self):
        ‘‘‘析構方法‘‘‘
        print("\033[31;1mmember [%s] is dead!\033[0m" %self.name)
class Teacher(SchoolMember):
    def __init__(self,name,age,course,salary):
        super(Teacher,self).__init__(name,age)
        self.course = course
        self.salary = salary
        self.enroll()
 
 
    def teaching(self):
        ‘‘‘講課方法‘‘‘
        print("Teacher [%s] is teaching [%s] for class [%s]" %(self.name,self.course,‘s12‘))
 
    def tell(self):
        ‘‘‘自我介紹方法‘‘‘
        msg = ‘‘‘Hi, my name is [%s], works for [%s] as a [%s] teacher !‘‘‘ %(self.name,‘Oldboy‘, self.course)
        print(msg)
 
class Student(SchoolMember):
    def __init__(self, name,age,grade,sid):
        super(Student,self).__init__(name,age)
        self.grade = grade
        self.sid = sid
        self.enroll()
 
 
    def tell(self):
        ‘‘‘自我介紹方法‘‘‘
        msg = ‘‘‘Hi, my name is [%s], I‘m studying [%s] in [%s]!‘‘‘ %(self.name, self.grade,‘Oldboy‘)
        print(msg)
 
if __name__ == ‘__main__‘:
    t1 = Teacher("Tom",22,‘Python‘,20000)
    t2 = Teacher("Jack",29,‘Linux‘,3000)
 
    s1 = Student("zhangsan", 24,"Python S12",1483)
    s2 = Student("lisi", 26,"Python S12",1484)
 
    t1.teaching()
    t2.teaching()
    t1.tell()

多態

多態性（polymorphisn）是允許你將父對象設置成為和一個或更多的他的子對象相等的技術，賦值之後，父對象就可以根據當前賦值給它的子對象的特性以不同的方式運作。簡單的說就是允許將子類類型的指針賦值給父類類型的指針。多態的作用是什麽呢？封裝可以隱藏實現細節，使得代碼模塊化；繼承可以擴展已存在的代碼模塊（類）；而它們的目的都是為了——代碼重用。而多態則是為了實現另一個目的——接口重用！多態的作用，就是為了類在繼承和派生的時候，保證使用“家譜”中任一類的實例的某一屬性時的正確調用。例如Pyhon 很多語法都是支持多態的，比如 len(),sorted(), 你給len傳字符串就返回字符串的長度，傳列表就返回列表長度。

class Animal(object):
    def __init__(self, name):  
        self.name = name
    # Abstract method, defined by convention only
    def talk(self):             
        raise NotImplementedError("Subclass must implement abstract method")
 
 
class Cat(Animal):
    def talk(self):
        print(‘%s: 喵喵喵!‘ %self.name)
 
 
class Dog(Animal):
    def talk(self):
        print(‘%s: 汪！汪！汪！‘ %self.name)
 
 
 #一個接口，多種形態
def func(obj): 
    obj.talk()
 
c = Cat(‘小晴‘)
d = Dog(‘李磊‘)
 
func(c)
func(d)

python-->面向對象基礎