封裝的含義：對屬性進行操作
將資料（屬性）和行為（方法）包裝到類物件中。在方法內部對屬性進行操作，早類物件的外部呼叫方法。這樣，無須關心方法內部的具體實現細節，從而隔壁了複雜度。
在類物件的內部通過訪問控制把某些屬性和方法隱藏起來，不允許在類物件的外部直接訪問，而是在類物件的內部對外提供公開的介面方法（例如getter和setter）以訪問隱藏的資訊。這樣，就對隱藏的資訊進行了保護。
class student(object):
def __init__(self):
self._score = 90
def get_score(self):
return self.__score
def set_score(self,score):
if 0 <= score <= 100:
self.__score = score
else :
raise valueerror("成績必須在0~100之間")
s = student()
s.get_score()
返回結果：90
s = student()
s.get_score(88)
print(s.get_score())
返回結果：88
python中的所有類物件都繼承自乙個統一的基類：object。這就是為什麼我們在定義類物件時要在類物件後面新增（object）。
class animal(object):
def eat(self):
print("吃飯" )
def drink(self):
print("喝水")
class dog(animal):
def swim(seif) :
print(" 游泳』)
dog = dog()
dog. eat ()#返回結果：吃飯
dog. drink()#返回結果：喝水
dog. swim()#返回結果：游泳
class bird(animal):
def fly(seif):
print(」飛翔")
bird = bird()
bird. eat ()#返回結果：吃飯
bird. drink ()#返回結果：喝水
bird. fly()#返回結果：飛翔
class childclass (parentclass) :
pass
class childclass ( parentclassl, parentclass2, ..., parentclassn):
pass
class parentclass (object) :
ca = "ca (父類)"
def __ init__ (self):
print("__ init__ ()被凋用了 (父類)」)
def im(self):
print("im()被凋用了(父類) ")
@classmethod
def cm(cls):
print(" cm()被凋用了(父類)」)
class childclass (parentclass) :
ca="ca（子類)」
def __ init__ (self):
print("__ init__ ()被呼叫了 (子類)")
def im(self):
print(" im()被呼叫了(子類)」)
@classmethod
def cm(cls):
print(」cm(被凋用了(子類)「)
cc = childclass ()
print (childclass. ca)
print(cc. ca)
cc. im()
childclass. cm()
cc. cm()
返回結果：
__init__ ()被呼叫了(子類)
ca(子類)
ca(子類)
im()被呼叫了(子類)
cm()被呼叫了(子類)
cm()被呼叫了(子類)
class a(object):
def f(self):
print("a.f")
class b(a):
def f(self):
print("b.f")
class c(a):
def f(self):
print("c.f")
class d(b, c):
def f(self):
#super(). f()
super(b, self).f()
d=d()
d. f()
#返回結果：c. f
class parentclass (object):
def do_sth(self) :
print("do_sth() in parentclass" )
class childclassl (parentclass) :
def do_sth(self) :
print(do_sth() in childclassl")
class childclass2(parentclass):
def do_ ,sth(self):
print("do_sth() in childclass2' )
def f (parent):
parent. do_sth()
f(parentclass())
f(childclass1())
f(childclass2())
#返回結果：
do_sth() in parentclass
do_sth() in childclass1
do_sth() in childclass2
class someclass (object):
def do_ sth(self) :
print("do_sth() in someclass" )
f(someclass())
#返回結果：do_sth() in someclass
Go 物件導向程式設計之繼承
package main import fmt 編寫乙個學生考試系統 小學生 type pupil struct 顯示他的成績 func p pupil showinfo func p pupil setscore score int func p pupil testing 大學生,研究生。大學生...
物件導向程式設計（封裝 繼承 多型）
1 保證 資料的安全性 2 遮蔽 複雜性 3 封裝型別 普通 封裝成方法 方法都封裝在乙個類中。using system namespace lesson01 public void close class mainclass 1 被繼承類 父類 基類 繼承類 子類 派生類 2 子類可以擁有父類的全...
物件導向程式設計03（封裝 繼承 多型 重寫 MRO）
根據需求將屬性和方法封裝到乙個抽象的類中 在使用的時候，只要按照自己的需求去呼叫，不必了解實現的細節 封裝 封裝是物件導向程式設計的三大特徵之一。封裝有兩方面的含義 1.將資料 屬性 和行為 方法 包裝到類物件中。在方法內部對屬性進行操作，在類物件的外部呼叫方法。這樣，無需關心方法內部的具體實現細節...