Python——面向对象（初级篇）

1.如何创建类

class 类名:
    pass

2.如何创建方法

构造方法：
    __init__
obj = 类名('a1')

普通方法：
obj = 类名('xxx')
obj.普通方法名（）

3.图解面向对象的创建和执行

4.面向对象三大特性之一：封装

'''定义'''
class bar:
    def __init__(self,name,age):
        self.n = name
        self.a = age

'''执行'''
b1 = bar('admin',26)
b2 = bar('qq',48)

　　4.1 普通方法与构造方法对比：

 

5.面向对象三大特性之二：继承

#*****创建父系类******
class beast:    #动物的功能
    def eat(self):
        print(' %s吃'%(self.name))
    def drink(self):
        print(' %s喝'%(self.name))
    def shit(self):
        print(' %s拉'%(self.name))
    def pee(self):
        print(' %s撒' % (self.name))

#********创建猫的 类******
class cat(beast):   #猫继承动物的功能
    def __init__(self,name):
        self.name = name
        self.breed = '猫'
    def fig(self):
        print('%s\n'%(self.name),'喵喵叫')

#******* 创建狗的 类********
class dog(beast):   #狗继承动物的功能
    def __init__(self,name):
        self.name = name
        self.breed = '狗'
    def fig(self):
        print('%s\n'%(self.name),'汪汪叫')


'''执行'''

'''猫的部分功能执行'''
a = cat('猫')
a.fig()
a.eat()


'''狗的部分功能执行'''
b =  dog('狗')
b.fig()
b.drink()

 6.面向对象三大特性三：多态继承

 　　6.1 多态继承案列一：

 1 class f_0:
 2     def a(self):
 3         print('f_0.a')
 4 class f0(f_0):
 5     def a1(self):
 6         print('f0.a')
 7 
 8 class f1(f0):
 9     def a1(self):
10         print('f1.a')
11 
12 class f2():
13     def a(self):
14         print('f2.a')
15 
16 class s(f1,f2):
17     pass
18 
19 #*****执行*****
20 
21 obj = s()
22 obj.a()     # f_0.a

　　过程：对象obj 现在f1中找a(),f1中没有，在f1的父系（f0）中找，如果f0中没有，再去f0的父系（f_0）中找，如果有，就打印，不在去f2中找，如果没有，就去f2中找。执行过程：左侧优先，一条道走到黑。具体如图展示：

　　6.2 多态继承案列二：（两个类有交集的类）

 1 class base:
 2     def a2(self):
 3         print('base.a')
 4 class f0(base):
 5     def a1(self):
 6         print('f0.a')
 7 
 8 class f1(f0):
 9     def a1(self):
10         print('f1.a')
11 
12 class f2(base):
13     def a(self):
14         print('f2.a')
15 
16 class s(f1,f2):
17     pass
18 
19 obj = s()
20 obj.a()    # f2.a
21 obj.a2()   #base.a

　　base 类是类f1和f2的交集。过程：对象obj 现在f1中找a(),f1中没有，在f1的父系（f0）中找，如果f0中没有；开始从f2中找，f2中没有就去f2的父系（base）中找。

结论：base 如果是两个类的交集，那么执行过程是先执行左边的，再执行右边的，从右边执行过程中打印。如图所示：

 　　6.3 多态继承案列三：

 1 class basereuquest():
 2     pass
 3 
 4 class requesthandler(basereuquest):
 5     def serve_forever(self):
 6         #self 是obj
 7         print('requesthandler.serve_forever')
 8         self.process_request()
 9     def process_request(self):
10         print('requesthandler.process_request')
11 
12 class minx:
13     def process_request(self):
14         print('minx.process_request')
15 
16 
17 class son(minx,requesthandler):
18     pass
19 
20 obj = son()
21 obj.serve_forever()

　　过程： 创建4个类，执行obj.serve_forever()语句，根据左侧优先，先执行 类 minx ，没有就执行右侧的 类 requesthandler ，在类 requesthandler 中找server_forever()方法执行，这时候会打印 print('requesthandler.serve_forever')；由于方法里面有self.process_request()，故而会执行 类 minx 中 process_request() 的方法。原因是 self 是对象 obj ，所以：self.process_request() 也就是obj.process_request(),根据左侧优先，所以会现在 类minx 中找process_request() 方法。如图所示：