類與物件,面向物件與面向過程的對比,面向物件的三大特徵
阿新 • • 發佈：2018-12-27
類: 就是圖紙. 建立物件的第一步. 先畫圖紙. 先寫類.
物件: 物件就是車. 通過圖紙造出來的具體的東西. 通過類來建立物件
類與物件的關係:
類是對xxx事物的歸類.
寫:
__init__(self, 引數) 引數一般作為屬性設定給物件. 物件就是self,
對屬性的封裝.
def 方法(self, 引數): 方法. 第一個引數一般是固定的self. 當前類的物件.
pass
物件是xx型別的一個具體
建立物件: 類名()
建立類:
class 類名:
def __init__(self): # 初始化方法. 又被成為構造方法
self.屬性 = 值
self.屬性 = 值
self.屬性 = 值
def fangfa(self):
方法體(函式體, return)
建立物件:
變數 = 類名() # 例項化 <-> 建立物件
變數.屬性 # 訪問物件的屬性資訊
變數.方法() # 訪問類中的方法
# class Car: #類名首字母大寫.
# pass
#
# # 造車
# c = Car()
# # 出場之後進行改裝
# c.color = "red" # 物件.屬性 點:的
# c.pai = "京A88888" # 物件.屬性
# c.pailiang = "555L" # 排量
#
# print(c.color)
# print(c.pai)
# print(c.pailiang)
# c.color = "green" # 當屬性存在的時候是修改屬性資訊
# 物件.屬性 = xxxx 設定屬性資訊
# class Car:
# # __init__ 方法是一個特殊的方法,初始化方法(構造方法)
# # 在建立物件的時候會自動的呼叫__init__()
# # self 就是你創建出來的那個物件
#
# def __init__(self, color, pai, pailiang): # init初始化方法,在建立物件的時候預設執行這個函式
# self.color = color
# self.pai = pai
# self.pailiang = pailiang
#
# # 跑:動作,功能 -> 函式
# # 在類中寫的函式 -> 方法
# # self 當前類的物件
#
# def pao(self): # self是自動傳遞的,不用管它
# print("%s我的車能跑" % self.color) # self.color
#
# def jump(self):
# print("%s牛砸能蹦高" % self.color)
#
#
#
#
# c = Car("紅色", '京A88888', '555L')
# c2 = Car('藍色', '京B66666', '1.6T')
# print(c.color)
# print(c2.color)
#
# c.pao()
# c2.pao()
# c.jump()
# c2.jump()
面向物件與面向過程的對比
# 大象裝冰箱
# 指令碼 此時程式碼最簡單,不需要構思整個程式的概況
# print("開門")
# print("裝大象")
# print("關門")
# 函數語言程式設計,比指令碼麻煩,對功能有了概況
# def kai():
# print('開門')
# def zhuang():
# print("裝大象")
# def guan():
# print('關門')
#
# kai()
# zhuang()
# guan()
# 面向物件程式設計,對整個系統進行分析,分析出需要哪些物件然後給物件進行歸類.
# 先寫類,然後使用類建立物件,最後用物件去執行相關的操作
# class Elephant:
# def __init__(self):
# print("建立了一個大象")
#
# def kai(self):
# print("開門")
#
# def zuan(self):
# print("大象進冰箱")
#
# def guan(self):
# print("大象把門帶上")
#
# dx = Elephant()
# dx.kai()
# dx.zuan()
# dx.guan()
# 第一回合
# 指令碼勝
# 函式側重的是功能
# 面向物件側重的是 歸類
# PK2
# 小豬佩奇. 使用嘴巴嘟嘟技能攻擊 超人
# 小豬佩奇. 使用嘴巴嘟嘟技能攻擊 蝙蝠俠
# 小豬佩奇. 使用嘴巴嘟嘟技能攻擊 蜘蛛俠
#
# # 面向過程: 程式碼非常的冗餘. 尤其是引數
# def fight_superman(name, jineng):
# print("%s使用%s攻擊超人" % (name, jineng))
#
# def fight_batman(name, jineng):
# print("%s使用%s攻擊蝙蝠俠" % (name, jineng))
#
# def fight_spiderman(name, jineng):
# print("%s使用%s攻擊蜘蛛俠" % (name, jineng))
#
#
# fight_superman('小豬佩奇', "嘴巴嘟嘟")
# fight_batman('小豬佩奇', "嘴巴嘟嘟")
# fight_spiderman('小豬佩奇', "嘴巴嘟嘟")
#
#
# class Pig:
# def __init__(self, name, jineng):
# self.name = name
# self.jineng = jineng
#
# def fight_superman(self):
# print("%s使用%s攻擊超人" % (self.name, self.jineng))
#
# def fight_batman(self):
# print("%s使用%s攻擊蝙蝠俠" % (self.name, self.jineng))
#
# def fight_spiderman(self):
# print("%s使用%s攻擊蜘蛛俠" % (self.name, self.jineng))
#
#
# pg = Pig("小豬佩奇", "嘴巴嘟嘟")
# 不需要向原來一樣傳遞一樣的引數了
# 面向物件的程式: 結果相對清晰. 缺點: 程式碼量比原來大, 上手太難
# pg.fight_batman()
# pg.fight_spiderman()
# pg.fight_superman()
# 如果寫一個定時任務, 半夜12點. 給老闆傳送財務報表(一張圖)
# def send_email(address, name, title, content):
# print("傳送郵件")
#
# def send_wechat(wechat_num, name, title, content):
# print("傳送微信")
#
# def send_chat(phone_num, name, title, content):
# print("傳送簡訊")
#
# def send_dd(dd_num, name, title, content):
# print("傳送釘釘")
#
# def send_oa(oa_num, name, title, content):
# print("傳送OA")
# class Messager:
# def __init__(self, name, title, content):
# self.name = name
# self.title = title
# self.content = content
#
# def send_email(self, address):
# print("傳送郵件")
#
# def send_wechat(self, wechat_num):
# print("傳送微信")
#
# def send_chat(self, phone_num):
# print("傳送簡訊")
#
# def send_dd(self, dd_num):
# print("傳送釘釘")
#
# def send_oa(self, oa_num):
# print("傳送OA")
# 用面向物件就比面向過程稍微好一些.
# 可維護性比原來好
# python同時支援面向物件和麵向過程:
# 面向過程: 應用程式相對比較小. 不需要大規模的設計
# 面向物件: 程式非常大. 專案管理 維護成本很高. 此時更適合用面向物件(結構)
# java : 純面向物件 => 可以把一個微型專案. 做成巨型專案
面向物件的三大特徵
封裝:
1. 對屬性的封裝(__init__())
self.xxx = xxx
2. 對方法和功能的封裝
繼承
子類自動擁有父類中除了私有內容外的其他所有內容
class Bar(Foo): Bar對Foo進行了擴充套件
pass
當出現x是一種y的時候. 推薦使用繼承關係
python支援多繼承. 查詢順序: 先找離他近的.
多型(python原生直接就是多型)
python更多的支援的是鴨子模型, 只要會嘎嘎叫就是好鴨子