關於python中的面向對象

對於面向對象（oop）的理解

在人類的認知中，我們習慣把屬性相近的東西進行歸類。所以，我們寫的class xxx就是一個類，描述了一組屬性的集合。而我們把這組屬性具體實例出來的稱之爲對象

比如：

class Bird(object):
      def __init__(self,feather,call):
          self.feather=feather
          self.call=call

我們定義了一個鳥的類，並且初始化函數定義了它有羽毛，可以叫。這個就是類

bird=Bird("yellow","jiujiu")

我們定義了一個對象。***羽毛的鳥，叫聲是啾啾

當然，面向對象沒有那麼簡單。其中還是涉及到了

繼承，

多繼承，迷信繼承，

方法重寫，

權限，如父類私密的數據能否在子類中讀取跟操作

python中實現繼承的方式，是直接在這個類的括號裏面寫出父類。例如Bird的父類就是object

關於子類繼承父類：

#!/usr/bin/env python
#-*-coding:utf-8-*-
class Birds:
	def __init__(self,name,feather,year):
		self.name=name
		self.feather=feather
		self._year=year
	def call(self):
		print "this is a mether----For bird"
	def get_year(self):
		return self._year
class litteBird(Birds):
	pass

b=litteBird("ll",'yellow','100')

如果子類中定義的是pass，那麼，將會接收的是父類的所有函數和參數。在python中類的所有參數都是在__init__()中定義的，貌似沒有直接在函數外定義。那樣感覺很怪，無奈才疏學淺。還不能很好參透

訪問限制：

__name:這個形式在python中表現是私密數據/方法，python將之轉換爲了_className__name

__name__：這個在python是表示特殊變量的

_name:這個雖然可以訪問，但是表示，我是私密數據，最好不要訪問

所以在父類中設爲私密的，是_fatherName__name。當你在子類想要訪問父類的私密方法，或者數據是，就會提示爲_sonName__name不存在

所以，你直接在子類中直接去調用self.__year是不存在的。因爲被改成了__sonName__year。只有你改成了父類的_fatherName__year纔可以訪問

#!/usr/bin/env python
#-*-coding:utf-8-*-
class Birds:
	def __init__(self,name,feather):
		self.name=name
		self.feather=feather
		self.__year=100
	def call(self):
		print "this is a mether----For bird"
	def __Get_year(self):
		print self.__year

class litteBird(Birds):
	def set_year(self):
		print self.__year #找不到。

b=litteBird("ll",'yellow')
b.set_year()

改成下面就可以訪問到數據：

#!/usr/bin/env python
#-*-coding:utf-8-*-
class Birds:
	def __init__(self,name,feather):
		self.name=name
		self.feather=feather
		self.__year=100
	def call(self):
		print "this is a mether----For bird"
	def __Get_year(self):
		print self.__year

class litteBird(Birds):
	def set_year(self):
		print self._Birds__year

b=litteBird("ll",'yellow')
b._Birds__Get_year()

所以關於訪問限制：

    在一個類中被設爲私密的數據的。都會被改成_className__name這種直白的方式.所以在子類也不能直接訪問。除非你改成這種直白的方式

多態：

關於多態的理解。就是我們可以重寫父類函數。比如

b=litterBird()

    python中沒有強調類型。但是，這裏的b其實既是Birds類型，也是litterBird類型。用isinstance()可以看出來。所以。我們可以再子類定義自己的方法。重複使用父類中共同的方法

多繼承和迷信繼承：

多繼承就是同時繼承多個類。速度會比較快

迷信混入繼承，屬於動態的多繼承。會比較慢

有一點，多繼承如果，繼承的兩個類有相同的方法名？那麼執行排在最前面的方法。

如果子類有方法，執行子類方法

如果子類沒方法，執行父類方法

如果多個父類，執行排在最前面的父類

如果排在最前的父類沒有，但是，這個父類的父類有，那麼會執行這個父類的父類，還是下一個父類？

執行父類的父類

#!/usr/bin/env python
#-*-coding:utf-8-*-
class grandfather:
	def hair(self):
		print "Ghair"

class mother(grandfather):
	pass

class father:
	def hair(self):
		print "No hair"
class son(mother,father):
	pass

s=son()
s.hair()
#Ghair