• 面向物件：以物件為中心的程式設計思想，通過指揮物件實現具體功能
• 面向過程：以過程為中心的程式設計思想，實現具體功能都是自己實現

1、類的描述

類：

1. 類是對現實生活類中具有共同屬性和行為的實物的抽象
2. 類是物件的資料型別，類是具有相同屬性和行為的一組物件的集合
3. 類就是對現實事務的一種描述

物件：

​ 是以類為模板所建立的例項，通過例項物件可以執行類中的函式

2、類的建立

#建立類
class Foo(): #class是關鍵字（表示要開始建立類了）；Foo是新建類名稱
    #建立類中函式
    def bar(self):	#self特殊引數
        print("Bar")
    def hello(self,name):
        print("I am %s" % name)
        
#根據Foo建立物件
obj = Foo()
obj.bar()	#執行bar方法
obj.hello("Torres")	#執行hello方法
 

3、面向物件三大特性

面向物件的三大特性是指：封裝、繼承和多型。

3.1、封裝

封裝，就是將內容封裝到某個地方，以後再去呼叫被封裝在某處的內容。

在使用面向物件的封裝特性時，需要：

• 將內容封裝到某處
• 從某處呼叫被封裝的內容

第一步：建立類，封裝內容

class Foo:
    def __init__(self,name,age)
    	'''初始化例項屬性'''
        self.name = name
        self.age = age
        
#根據類Foo建立物件
obj1 = Foo("taolei",18) #將taolei和18分別封裝到obj1/self的name和age屬性中（此處obj1其實就是self）
obj2 = Foo("Torres",23)	#將Torres和23分別封裝到obj1/self的name和age屬性中（此處obj2其實就是self）
 

第二步：從類中呼叫被封裝的內容

呼叫被封裝的內容時，有兩種情況：

• 通過物件直接呼叫
• 通過self間接呼叫

1、通過物件直接呼叫被封裝的內容

class Foo:
    def __init__(self,name,age)
    	'''初始化例項屬性'''
        self.name = name
        self.age = age
        
obj1 = Foo("taolei",18) 
print(obj1.name)
print(obj1.age)

obj2 = Foo("Torres",23)
print(obj2.name)
print(obj2.age)
 

2、通過self間接呼叫被封裝的內容（執行類中的方法時，需通過self間接呼叫被封裝的內容）

class Foo:
    def __init__(self,name,age)
    	'''初始化例項屬性'''
        self.name = name
        self.age = age
        
    def detail(self):
        print(self.name)
        print(self.age)
        
obj1 = Foo("taolei",18) 
obj1.detail()

obj2 = Foo("Torres",23)
obj2.detail()

3.2、繼承

繼承，即子可以繼承父的內容

#!/usr/bin/python3
#coding=utf-8

class Car():
    '''
    一次模擬汽車的簡單嘗試
    '''
    def __init__(self,make,model,year):
        self.make = make
        self.model = model
        self.year = year
        self.odometer_reading = 0

    def get_desc_name(self):
        long_name = str(self.year) + " " + self.make + " " + self.model
        return long_name.title()

    def read_odometer(self):
        print("This car has " + str(self.odometer_reading) + " miles on it.")

    def update_odometer(self,mileage):
        if mileage >= self.odometer_reading:
            self.odometer_reading = mileage
        else:
            print("You can't roll back an odometer!")

    def increment_odometer(self,miles):
        self.odometer_reading += miles

class ElectricCar(Car):
    '''
    電動車的獨特之處
    '''
    def __init__(self,make,model,year):
        """初始化父類的屬性"""
        super().__init__(make,model,year)
        self.battery_size = 70

    def describe_battery(self):
        """列印一條描述電瓶容器的訊息"""
        print("This car has a " + str(self.battery_size) + "-kWh battery.")

if __name__ == "__main__":
    my_tesla = ElectricCar("tesla","model s",2016)
    print(my_tesla.get_desc_name())
    my_tesla.describe_battery()

"""
[root@aliyun DevOps]# python3 /home/python/electric_car.py 
2016 Tesla Model S
This car has a 70-kWh battery.
"""

對於面向物件的繼承來說，其實就是將多個類共有的方法提取到父類中，子類僅需繼承父類而不必一一實現每個方法。

注：除了父類和子類的稱謂，子類也被稱為：派生類；父類也被稱為：基類。

3.3、多型

不同的物件都可以響應同一方法，但是執行結果各不相同

更通俗的講，多型是指一類事物有多種形態。比如動物有多種形態，人、狗、貓等等；在二進位制的世界，例如檔案，檔案有多種形態：文字檔案、可執行檔案。

總而簡言，多型即某類的再分類，再分的每一類就是父類的多種形態的一種

3.3.1、使用場景

• 統一管理
• 方法返回統一父類的不同物件
• 方法引數接收同一父類的不同子類物件

3.3.2、實現方式

• 不同子類繼承同一父類，重寫要執行的方法，保證執行結果各不相同
• 採用鴨子模型的思想，為任意一個類植入需要的方法也可以實現

class Animal:
    def run(self):
        raise AttributeError("子類必須實現這個方法")
        
class People(Animal):
    def run(self):
        print("人正在走路")
        
class Dog(Animal):
    def run(self):
        print("dog is running")
        
peo1 = People()
dog1 = Dog()

peo1.run()
dog1.run()