oop面向物件的程式開發

用幾大特征表達這一類事務稱為一個類,類更像是一張圖紙,表達的是一個抽象概念

物件是類的具體實作,更像是由這種圖紙產出的具體物品,類只有一個,但物件可以通過這個類實體化出多個

物件是類的實體,類是物件的模板

*類中的成員只有方法和屬性,不要裸露的把判斷和回圈直接寫在類中,而是用方法包起來

(1)類的定義

# 1
class Car:
    pass
    
# 2 推薦
class Car():
    pass
    
# 3.
class Car(object):
    pass

(2)類的實體化

class Car():
    pass
    
obj = Car()
print(obj)

(3)類的基本結構

class Car():
    # 成員屬性
    color = "白色"
    # 成員方法
    def didi():
        print("小車會嚓嚓的叫")
        

# 語法上不報錯,但是嚴禁使用,破壞了類中的結構,不要裸露的把判斷和回圈直接寫在類中,而是用方法包起來
class Car():
    if 5 ==5 :
        print(11223344)

(4)類的命名

"""類的命名 : 推薦使用大駝峰命名法,每個單詞的首字母都要大寫"""
"""
mycar => MyCar
zhangbaozhang => ZhangBaoZhang
"""

面向物件三大特征: 封裝 繼承 多型

封裝:對類中成員屬性和方法的保護,控制外界對內部成員的訪問,修改,洗掉等操作
繼承:一個類除了自身所擁有的屬性方法之外,還獲取了另外一個類的成員屬性和方法
多型:不同的子類物件,呼叫相同的父類方法,產生不同的執行結果

面向物件的封裝 - 物件的操作

封裝:
　　1.私有 : 在類內可以互相訪問,在類外不能訪問
　　2.公有 : 在類內或者類外都可以訪問

類中成員:
　　1.成員屬性
　　2.成員方法

系結方法:
　　1.系結到物件 : 當物件去呼叫類中成員方法時,系統會默認把該物件當成引數傳遞給該方法
　　2.系結到類 : 當物件或者類去呼叫類中成員方法時,系統會默認把該類當成引數傳遞給該方法

使用方式:
　　物件.成員屬性
　　物件.成員方法

class MyCar():
    # 公有屬性
    logo = "布加迪威龍"
    
    # 私有屬性
    __price = "2000萬"
    
    # 公有方法
    def run(self):
        print("百公里油耗300L,logo={} , price={}".format(self.logo, self.__price))

    # 私有方法
    def __info(self):
        print("車主資訊保密,據說是某個房地產大佬的兒子")

# 實體化物件(類的實體化)
obj = MyCar()

# (1)實體化的物件訪問成員屬性和方法
# 公有
print(obj.logo)
obj.run()

# 私有 (私有成員無法在類外訪問,類內可以)
# obj.__price error
# obj.run()
# obj.__info() error


#(2)實體化的物件動態添加公有成員屬性
obj.color = "尿黃色"
obj.logo = "五菱宏光" 
print(obj.color)
print(obj.logo)

# __dict__ 獲取類物件的內部成員
print(obj.__dict__)
print(MyCar.__dict__)

#(3)實體化的物件動態添加公有成員方法

# 1.無參方法
def dahuangfeng():
    print("請加我大黃蜂")

obj.dahuangfeng = dahuangfeng
obj.dahuangfeng()

# 2.有參方法
# 基本版
def qingtianzhu(name):
    print("請叫我一柱擎天么,{}".format(name))
    
obj.qingtianzhu = qingtianzhu
obj.qingtianzhu("擎天柱")

# 升級版
def qingtianzhu(obj,name):
    print("請叫我一柱擎天么,{},我的顏色是{}".format(name,obj.color))

obj.qingtianzhu = qingtianzhu
obj.qingtianzhu(obj,"擎天柱")

# 究極版
"""如果要創建系結方法,引數的順序,self物件本身要放到第一位."""
def qingtianzhu(obj,name):
    print("請叫我一柱擎天么,{},我的顏色是{}".format(name,obj.color))

import types
# 創建系結方法,系統自動把該物件當成引數傳遞給方法;
# types.MethodType(方法,物件) => 系結方法   
res = types.MethodType(qingtianzhu,obj)
print(res)

obj.qingtianzhu = types.MethodType(qingtianzhu,obj)
obj.qingtianzhu("擎天柱")

# 3.lambda運算式
obj.weizhentian = lambda : print("我是威震天")
obj.weizhentian()

面向物件的封裝 - 類的操作

使用方式:
　　類.成員屬性
　　類.成員方法

class MyCar():
    
    # 公有成員屬性
    platenum = "京A7758BB"
    
    # 私有成員屬性
    __earning = "月收入6000"
    
    # 公有成員方法
    def car_info():
        print("牌照資訊可以公開")
        print("<======>")
        MyCar.__money_info()
    
    # 私有成員方法
    def __money_info():
        print( "收入資訊保密" , MyCar.__earning )
        

# (1)定義的類訪問公有成員屬性和方法
print(MyCar.platenum)
MyCar.car_info()

# MyCar.__money_info() error
    
# (2)定義的類動態添加公有成員屬性
MyCar.oil = "1000L"
print(MyCar.oil)
print(MyCar.__dict__)

# (3)定義的類動態添加公有成員方法
# 1.無參方法
def car_light():
    print("我是造車燈的方法")
MyCar.car_light = car_light
MyCar.car_light()

# 2.有參方法
def car_engine(name):
    print("我是造{}發動機的方法".format(name))
MyCar.car_engine = car_engine
MyCar.car_engine("三缸發動機")

# 3.lambda運算式
MyCar.luntai = lambda : print("我是造輪胎的方法")
MyCar.luntai()


# 對比 物件和類之間的不同
"""
1.類中的無參方法默認只能類來呼叫,物件無法調取
2.物件可以呼叫類中的成員,反過來,類不能呼叫物件中的成員
3.每創建一個物件都會在記憶體中占用一份空間,物件之間是彼此獨立的;
"""
obj = MyCar()
# obj.car_info() error
MyCar.car_info()


obj.price = "10萬"
print(MyCar.price)

python對成員的保護分為兩個等級

私有的: private
　　在本類內部可以訪問,類的外部不可以訪問.(python中 屬性或者方法前面加上兩個下劃線__)
公有的: public
　　在本類的內部和外部都可以訪問.
在其他高級語言當中,如java php c++等語言,有三個等級 private public protected

私有成員的改名策略 [_類名__成員名]
物件的相關操作
　　(1)實體化的物件訪問公有成員屬性和方法
　　(2)實體化的物件動態添加公有成員屬性和方法
　　(3)實體化的物件洗掉公有成員屬性和方法
類的相關操作
　　(1)定義的類訪問公有成員屬性和方法
　　(2)定義的類動態添加公有成員屬性和方法
　　(3)定義的類洗掉公有成員屬性和方法

普通方法: 沒有任何引數傳遞,只能類呼叫
系結方法: 把默認傳參的方法叫做系結方法,系結到物件(默認傳物件),系結到類(默認傳類)
非系結方法:靜態方法(無需傳任何引數,物件和類都能呼叫)

私有的：只能載類或者物件的結構中訪問
公有的：可以載任何位置訪問
受保護：可以載當前類或者物件 和子類或者子類物件中訪問

類內 子類中 類外部
公有的： √ √ √
私有的： √ X X
受保護： √ √ X (python語言不支持)

1.如何在類外訪問私有成員

class Plane():
    # 公有成員
    captian = "趙沈陽"
    
    # 私有成員
    __air_sister = "3名空姐"
    
    # 公有系結方法
    def fly(self):
        print("飛機要非要平流層,才能減少震動",self.__air_sister)
        
    # 私有系結方法
    def __age(self):
        print("空姐年齡保密")
        
    # 公有無參方法
    def fly2():
        print("航天飛機飛到天空層,翱翔太空")
    
    # 私有無參方法
    def __earn():
        print("機長的收入保密")
        
    def pub_get1(self):
        print(self.__air_sister)
        self.__age()
        
    def pub_get2():
        print(Plane.__air_sister)
        Plane.__earn()

# 實體化物件
obj = Plane()

# 方法一.訪問私有成員 (不推薦)
# python私有化: 采取了改名策略 =>  _類名 + __air_sister
# print(obj.__air_sister)
print(obj._Plane__air_sister)
print(Plane.__dict__)
"""
{'__module__': '__main__', 'captian': '趙沈陽', 
'_Plane__air_sister': '3名空姐', 
'fly': <function Plane.fly at 0x7f2774616158>, '_Plane__age': <function Plane.__age at 0x7f27746161e0>, 'fly2': <function Plane.fly2 at 0x7f2774616268>, '_Plane__earn': <function Plane.__earn at 0x7f27746162f0>, '__dict__': <attribute '__dict__' of 'Plane' objects>, '__weakref__': <attribute '__weakref__' of 'Plane' objects>, '__doc__': None}
"""

# 方法二.訪問私有成員 (使用類中的公有方法,間接訪問私有成員) (推薦)
obj = Plane()
obj.pub_get1()
Plane.pub_get2()

2.使用類物件洗掉相應的成員

1.物件可以訪問類中的公有成員,但是無權修改或者洗掉該類中的成員
2.物件在訪問成員時,優先訪問該物件自己的成員,如果沒有在訪問類的,類如果也沒有直接報錯;

# 洗掉物件成員屬性
obj.captian = "趙世超"
del obj.captian
print(obj.captian)

# 洗掉物件成員方法
obj.basketball = lambda : print("我的私人飛機可以在天上打籃球")
print(obj.__dict__)
obj.basketball()
del obj.basketball
print(obj.__dict__)
# obj.basketball() error

# 洗掉類中成員屬性
del Plane.captian
print(Plane.__dict__)
# Plane.captian
# print(obj.captian) error

# 洗掉類中成員方法
del Plane.fly2
# Plane.fly2() error

# 注意: 物件無法調無參方法!! 回傳來,類可以呼叫物件的系結方法么? 可以!!
Plane.fly(obj)

標籤：Python

上一篇：JVM | 第2部分：虛擬機執行子系統《深入理解 Java 虛擬機》

下一篇：Python獲取微信好友資料