面向對象

面向對象編程

之前學的都都是面向過程編程，我理解的面向過程就是寫好流程圖，跟着流程圖一步一步走，實現功能。

面向對象是你是一個上帝，滴尿成湖，潑尿成海，創造萬物，賦予他們屬性，調用他們的功能，實現咱們的目的。

面向對象的幾個核心特性以下

Class 類
一個類便是對一類擁有相同屬性的對象的抽象、藍圖、原型。在類中定義了這些對象的都具有的屬性（variables(data)）、共同的方法

class a: #經典類

class a（object）#新式類

 

Object 對象 
一個對象便是一個類的實例化後實例，一個類必須通過實例化後方可在程序中調用，一個類能夠實例化多個對象，每一個對象亦能夠有不一樣的屬性，就像人類是指全部人，每一個人是指具體的對象，人與人以前有共性，亦有不一樣

就是實力話一個對象。。。。。

 

Encapsulation 封裝
在類中對數據的賦值、內部調用對外部用戶是透明的，這使類變成了一個膠囊或容器，裏面包含着類的數據和方法

 

經常使用方法：

析構函數

在實例釋放、銷燬的時候執行，一般進行收尾工做，若是關閉一些數據庫鏈接，打開的臨時文件

語法:

    def __del__(self):
        print('%s 完全死了'%self.name)

 

私有方法

內部執行的方法，避免外部調用，例如cs見血經過被人攻擊

語法： 

def __init__(self,name,role,weapon,life_value=100,money=800):
    #構造函數
    self.name=name #實例變量，靜態屬性
    self.role=role
    self.weapon =weapon
    self.__life_value=life_value #這裏設置的私有屬性，只能經過特定的方法調用
    self.money=money

 

Inheritance 繼承
一個類能夠派生出子類，在這個父類裏定義的屬性、方法自動被子類繼承

python2 經典類是按照深度優先來繼承，新式類是按照廣度來繼承的。

python3經典類跟新式類都是統一按照廣度優先來繼承的

 

Polymorphism 多態
一種接口多種實現。

 

 

類的實例，裏邊含有類的基本語法，默認參數，私有屬性（方法） 

在運行那塊有函數的運行機制，　　

 1 class role:
 2     n=123  #默認參數
 3     n_list=[]
 4     def __init__(self,name,role,weapon,life_value=100,money=800):
 5         #構造函數
 6         self.name=name #實例變量，靜態屬性
 7         self.role=role
 8         self.weapon =weapon
 9         self.__life_value=life_value #這裏設置的私有屬性，只能經過特定的方法調用
10         self.money=money
11 
12 
13     def buy_gun(self): #類的方法，功能，動態屬性
14         print('%s buy gun %s'%(self.name,self.weapon))
15 
16     def __shot(self):
17         print('%s shooting'%self.name)
18 
19     def got_shot(self):  #運行一次，value就減小20
20         self.__life_value -= 20 #私有屬性-20
21         print('%s : I got shot...   '%self.name)
22 
23     def show_status(self):
24         print('name:%s weapon:%s life_value：%s'%(self.name,self.weapon,self.__life_value))
25 r1=role('qiangql','ploice','m4')
26 r2=role('w33','T','b12')
27 
28 print(r1.n,r1.name)
29 print(role.n)
30 r1.n ='333'
31 print(r1.n)  #r1裏n=333，可是r2裏的n仍是123
32 print(r2.n)
33 r1.n_list.append('444')
34 print('r1.n_list添加了444',r1.n_list,r2.n_list)
35 r2.n_list.append('5555')
36 print('r2.n_list 添加了5555',r1.n_list,r2.n_list,role.n_list)
37 r1.n_list.append('www')   #先用r1.list添加www,
38 r1.n_list=['313','33156'] #給r1.list 賦值
39 role.n_list.append('yy')
40 print('打印賦值後的r1.list，以及用r1添加www，用role.n_list 添加yy',r1.n_list,r2.n_list,role.n_list)
41 #沒有賦值就用就用默認參數，若是單獨賦值，就等於建立了一個單獨的參數保存
42 r1.buy_gun() #買槍
43 r1.show_status() #打印狀態
44 r1.got_shot() #收到傷害
45 r1.got_shot() #收到傷害
46 r1.show_status() #打印狀態

 1 C:\Users\qiangql\AppData\Local\Programs\Python\Python36-32\python.exe C:/Users/qiangql/PycharmProjects/untitled1/lei.py
 2 123 qiangql
 3 123
 4 這裏讓r1=333 333
 5 123
 6 r1.n_list添加了444 ['444'] ['444']
 7 r2.n_list 添加了5555 ['444', '5555'] ['444', '5555'] ['444', '5555']
 8 打印賦值後的r1.list，以及用r1添加www，用role.n_list 添加yy ['313', '33156'] ['444', '5555', 'www', 'yy'] ['444', '5555', 'www', 'yy']
 9 qiangql buy gun m4
10 name:qiangql weapon:m4 life_value：100
11 qiangql : I got shot...   
12 qiangql : I got shot...   
13 name:qiangql weapon:m4 life_value：60
14 
15 Process finished with exit code 0

執行結果

 

繼承實例

裏邊有重構父類的方法，繼承父類的方法。還有經過第三個類，將兩個子類聯繫在一塊兒。

class People:
    def __init__(self,name,age):
        self.name=name
        self.age=age
        self.friends=[]
    def sleep(self):  #父類裏邊有睡覺吃飯的共有屬性
        print('%s sleeping'%self.name)
    def eat(self):
        print('%s chi TMD'%self.name)

class Relation(object): #交朋友
    def make_friends(self,obj): #這裏obj指的是一個實例
        print('%s is making friends with %s'%(self.name,obj.name))
        self.friends.append(obj)  #將obj全部的信息添加到表裏

class Man(People,Relation):  #這裏繼承兩個類，把兩個子類連接起來，relation裏邊沒有名字參數，可是people有
    def __init__(self,name,age,money):
        #People.__init__(self,name,age)    #這裏經典類的繼承方法，統一用新式類的
        super(Man,self).__init__(name,age)  #這裏是新式類的繼承方法
        self.money=money                  #由於多了一個屬性，重構了一下。若是沒有多餘的屬性，就不須要額外重構
    def piao(self):  #特定的屬性
        print('%s go heiheihei'%self.name)
    def sleep(self):
        People.sleep(self)  #重構了方法,先執行父類的
        print('%s with woman sleeping'%self.name)

class Woman(People,Relation):
    def huazhuang(self): #特定的屬性
        print('%s go change haed '%self.name)
    def sleep(self):
        print('%s with man sleeping'%self.name)

m1=Man('qiangql',17,20)
m1.piao()
m1.eat()  #繼承父類的吃
m1.sleep() #這裏sleep有一個是執行了父類，一個是重構的

w1=Woman('dadagouquan',23)
w1.huazhuang()
w1.sleep()


m1.make_friends(w1)  #原本兩個子類沒有聯繫，經過一個共有的方法，聯繫在了一塊兒
print(m1.friends[0],'裏邊儲存的是全部信息')
print(m1.friends[0].name) #能夠額外調用名字，年齡等
print(m1.friends[0].age)

w1.make_friends(m1)
print(w1.friends[0].name)

 

 

多態實例1

 1 # _*_coding:utf-8_*_
 2 
 3 
 4 class Animal(object):
 5     def __init__(self, name):  # Constructor of the class
 6         self.name = name
 7 
 8     def talk(self):  # Abstract method, defined by convention only
 9         pass
10 
11 
12 class Cat(Animal):
13     def talk(self):
14         print('%s: 喵喵喵!' % self.name)
15 
16 
17 class Dog(Animal):
18     def talk(self):
19         print('%s: 汪！汪！汪！' % self.name)
20 
21 
22 def talk_animal(obj):  # 一個接口，多種形態
23     obj.talk()
24 
25 
26 d=Dog('www')
27 c=Cat('mmm')
28 d.talk()  　　　　　　　　#一種接口
29 
30 talk_animal(d)  　　　  #另外一個接口
31 talk_animal(c)

多態實例2，類裏開了接口

 1 # _*_coding:utf-8_*_
 2 
 3 
 4 class Animal(object):
 5     def __init__(self, name):  # Constructor of the class
 6         self.name = name
 7 
 8     def talk(self):  # Abstract method, defined by convention only
 9         pass
10     @staticmethod  #還沒講，這是個裝飾器
11     def talk_animal(obj):  # 這裏加了個接口，放到類裏了
12         obj.talk()
13 
14 class Cat(Animal):
15     def talk(self):
16         print('%s: 喵喵喵!' % self.name)
17 
18 
19 class Dog(Animal):
20     def talk(self):
21         print('%s: 汪！汪！汪！' % self.name)
22 
23 
24 d=Dog('www')
25 c=Cat('mmm')
26 d.talk()  #一種接口
27 
28 Animal.talk_animal(d)
29 Animal.talk_animal(c)