## 類的繼承
面向對象的編程帶來的主要好處之一是代碼的重用，實現這種重用的方法之一是通過繼承機制。
通過繼承創建的新類稱為**子類**或**派生類**，被繼承的類稱為**基類**、**父類**或**超類**。
**繼承語法**
~~~
class 派生類名(基類名)
...
~~~
在python中繼承中的一些特點：
* 1、如果在子類中需要父類的構造方法就需要顯式的調用父類的構造方法，或者不重寫父類的構造方法.。
* 2、在調用基類的方法時，需要加上基類的類名前綴，且需要帶上 self 參數變量。區別在于類中調用普通函數時并不需要帶上 self 參數
* 3、Python 總是首先查找對應類型的方法，如果它不能在派生類中找到對應的方法，它才開始到基類中逐個查找。（先在本類中查找調用的方法，找不到才去基類中找）。
如果在繼承元組中列了一個以上的類，那么它就被稱作"多重繼承" 。
**語法：**
派生類的聲明，與他們的父類類似，繼承的基類列表跟在類名之后，如下所示：
~~~
class SubClassName (ParentClass1[, ParentClass2, ...]):
...
~~~
## 實例
```
#!/usr/bin/python
# -*- coding: UTF-8 -*-
class Parent: # 定義父類
parentAttr = 100
def __init__(self):
print "調用父類構造函數"
def parentMethod(self):
print '調用父類方法'
def setAttr(self, attr):
Parent.parentAttr = attr
def getAttr(self):
print "父類屬性 :", Parent.parentAttr
class Child(Parent): # 定義子類
def __init__(self):
print "調用子類構造方法"
def childMethod(self):
print '調用子類方法'
c = Child() # 實例化子類
c.childMethod() # 調用子類的方法
c.parentMethod() # 調用父類方法
c.setAttr(200) # 再次調用父類的方法 - 設置屬性值
c.getAttr() # 再次調用父類的方法 - 獲取屬性值
```
以上代碼執行結果如下：
~~~
調用子類構造方法
調用子類方法
調用父類方法
父類屬性 : 200
~~~
你可以繼承多個類
~~~
class A: # 定義類 A
.....
class B: # 定義類 B
.....
class C(A, B): # 繼承類 A 和 B
.....
~~~
你可以使用issubclass()或者isinstance()方法來檢測。
* issubclass() - 布爾函數判斷一個類是另一個類的子類或者子孫類，語法：issubclass(sub,sup)
* isinstance(obj, Class) 布爾函數如果obj是Class類的實例對象或者是一個Class子類的實例對象則返回true
## Python 子類繼承父類構造函數說明
如果在子類中需要父類的構造方法就需要顯式地調用父類的構造方法，或者不重寫父類的構造方法。
子類不重寫\_\_init\_\_，實例化子類時，會自動調用父類定義的\_\_init\_\_。
## 實例
```
class Father(object):
def __init__(self, name):
self.name=name
print ( "name: %s" %( self.name) )
def getName(self):
return 'Father ' + self.name
class Son(Father):
def getName(self):
return 'Son '+self.name
if __name__=='__main__':
son=Son('yingtai')
print ( son.getName() )
```
輸出結果為：
~~~
name: yingtai
Son yingtai
~~~
如果重寫了\_\_init\_\_時，實例化子類，就不會調用父類已經定義的\_\_init\_\_，語法格式如下：
## 實例
```
class Father(object):
def __init__(self, name):
self.name=name
print ( "name: %s" %( self.name) )
def getName(self):
return 'Father ' + self.name
class Son(Father):
def __init__(self, name):
print ( "hi" )
self.name = name
def getName(self):
return 'Son '+self.name
if __name__=='__main__':
son=Son('yingtai')
print ( son.getName() )
```
輸出結果為：
~~~
hi
Son yingtai
~~~
如果重寫了\_\_init\_\_時，要繼承父類的構造方法，可以使用super關鍵字：
~~~
super(子類，self).__init__(參數1，參數2，....)
~~~
還有一種經典寫法：
```
父類名稱.__init__(self,參數1，參數2，...)
```
## 實例
```
class Father(object):
def __init__(self, name):
self.name=name
print ( "name: %s" %( self.name))
def getName(self):
return 'Father ' + self.name
class Son(Father):
def __init__(self, name):
super(Son, self).__init__(name)
print ("hi")
self.name = name
def getName(self):
return 'Son '+self.name
if __name__=='__main__':
son=Son('yingtai')
print ( son.getName() )
```
輸出結果為：
~~~
name: yingtai
hi
Son yingtai
~~~
## 方法重寫
如果你的父類方法的功能不能滿足你的需求，你可以在子類重寫你父類的方法：
實例：
```
#!/usr/bin/python
# -*- coding: UTF-8 -*-
class Parent: # 定義父類
def myMethod(self):
print '調用父類方法'
class Child(Parent): # 定義子類
def myMethod(self):
print '調用子類方法'
c = Child() # 子類實例
c.myMethod() # 子類調用重寫方法
```
執行以上代碼輸出結果如下：
~~~
調用子類方法
~~~
## 基礎重載方法
下表列出了一些通用的功能，你可以在自己的類重寫：
## 運算符重載
Python同樣支持運算符重載，
? ? ? ? ? ? __add__(self,rhs) ? ? ?? self + rhs ? ? ?? 加法
? ? ? ? ? ? __sub__(self,rhs) ? ? ?? self - rhs ? ? ? ? 減法
? ? ? ? ? ? __mul__(self,rhs) ? ? ?? self * rhs ? ? ? ? 乘法
? ? ? ? ? ? __truediv__(self,rhs) ? self / rhs ? ? ? ?? 除法
? ? ? ? ? ? __floordiv__(self,rhs) ?self //rhs ? ? ? ?? 地板除
? ? ? ? ? ? __mod__(self,rhs) ? ? ? self % rhs ? ? ? 取模(求余)
? ? ? ? ? ? __pow__(self,rhs) ? ? ? self **rhs ? ? ? ? 冪運算
實例如下：
```
#!/usr/bin/python
class Vector:
def __init__(self, a, b):
self.a = a
self.b = b
def __str__(self):
return 'Vector (%d, %d)' % (self.a, self.b)
def __add__(self,other):
return Vector(self.a + other.a, self.b + other.b)
v1 = Vector(2,10)
v2 = Vector(5,-2)
print v1 + v2
```
以上代碼執行結果如下所示:
~~~
Vector(7,8)
~~~
## 類屬性與方法
### 類的私有屬性
**\_\_private\_attrs**：兩個下劃線開頭，聲明該屬性為私有，不能在類的外部被使用或直接訪問。在類內部的方法中使用時**self.\_\_private\_attrs**。
### 類的方法
在類的內部，使用def關鍵字可以為類定義一個方法，與一般函數定義不同，類方法必須包含參數 self,且為第一個參數
### 類的私有方法
**\_\_private\_method**：兩個下劃線開頭，聲明該方法為私有方法，不能在類的外部調用。在類的內部調用**self.\_\_private\_methods**
## 實例
```
#!/usr/bin/python
# -*- coding: UTF-8 -*-
class JustCounter:
__secretCount = 0 # 私有變量
publicCount = 0 # 公開變量
def count(self):
self.__secretCount += 1
self.publicCount += 1
print self.__secretCount
counter = JustCounter()
counter.count()
counter.count()
print counter.publicCount
print counter.__secretCount # 報錯，實例不能訪問私有變量
```
Python 通過改變名稱來包含類名:
~~~
1
2
2
Traceback (most recent call last):
File "test.py", line 17, in <module>
print counter.__secretCount # 報錯，實例不能訪問私有變量
AttributeError: JustCounter instance has no attribute '__secretCount'
~~~
Python不允許實例化的類訪問私有數據，但你可以使用object.\_className\_\_attrName（**對象名.\_類名\_\_私有屬性名**）訪問屬性，參考以下實例：
```
#!/usr/bin/python
# -*- coding: UTF-8 -*-
class Yingtai:
__site = "www.yingtai.com"
yingtai= Yingtai()
print yingtai._Yingtai__site
```
執行以上代碼，執行結果如下：
~~~
www.yingtai.com
~~~
### 單下劃線、雙下劃線、頭尾雙下劃線說明：
* **\_\_foo\_\_**: 定義的是特殊方法，一般是系統定義名字 ，類似\_\_init\_\_()之類的。
* **\_foo**: 以單下劃線開頭的表示的是 protected 類型的變量，即保護類型只能允許其本身與子類進行訪問，不能用于from module import \*
* **\_\_foo**: 雙下劃線的表示的是私有類型(private)的變量, 只能是允許這個類本身進行訪問了。
