面向对象初级

Posted 2020-07-18

面向对象编程是一种编程方式，此编程方式的落地需要使用 “类” 和 “对象” 来实现，所以，面向对象编程其实就是对 “类” 和 “对象” 的使用。

　　类就是一个模板，模板里可以包含多个函数，函数里实现一些功能

　　对象则是根据模板创建的实例，通过实例对象可以执行类中的函数

• 面向对象编程不是所有的情况都适用 
• class是关键字，表示类
• 创建对象，类名称后加括号即可

• class Foo:                            #创建类名 
      def bbb(self):                   #创建类的函数，也叫作方法
          print(\'bbbbbbbbb\')        
      def ccc(self,name):           #（self） 特殊参数 必填的
          print(name)
  obj = Foo()                          # 创建对象 （创建类的实例）
  obj.bbb()                             #  调用对象 执行bbb方法
  obj.ccc(\'kaixin\')

       面向对象：【创建对象】【通过对象执行方法】

　　  函数编程：【执行函数】

        场景不同那么适用编程的方式也不同

总结：函数式的应用场景 --> 各个函数之间是独立且无共用的数据

面向对象的三大特性是指：封装、继承和多态。

1，封装

封装，顾名思义就是将内容封装到某个地方，以后再去调用被封装在某处的内容。

所以，在使用面向对象的封装特性时，需要：

class oldoby:
    def fetch(self):
        print(self.zzzz)
obj = oldoby()
obj.zzzz = \'www.000000.com\'   #将值封装到类对象中，不需要再传参数了
obj.fetch()

    将内容封装到某处：

class oldoby:
    def __init__(self,bk):       #构造方法
        self.name = \'开心\'
        self.xixi = bk
        print(self.name,self.xixi)
obj = oldoby(\'zzzzzzzzz\')      
obj1 = oldoby(\'xxxxxxxx\')

特殊的参数：（self）self，形式参数，代指执行方法的对象。python内部传递

也就是说执行类中某一个方法，哪一个对象调用他，他就传递哪个对象！

obj = Foo()
obj.fetch(\'zz\') ==> self:obj, backend:"zz"
obj1.fetch(\'xx\') ==> self:obj1, backend:"xx"

类+括号 =》 自动执行类中的 __init__方法；创建了一个对象，在__init__方法中执行具体封装的操作

__init__ 有一个特殊名字：构造方法

__del__ 解释器销毁对象时候自动调用，特殊的名： 析构方法

 

   从某处调用被封装的内容：

调用被封装的内容时，有两种情况：

• 通过对象直接调用
• 通过self间接调用

1、通过对象直接调用被封装的内容

上图展示了对象 obj1 和 obj2 在内存中保存的方式，根据保存格式可以如此调用被封装的内容：对象.属性名

class oldoby:
    def __init__(self,bk):
        self.bobo = bk
foo = oldoby(\'xxxxxxxxx\')
print(foo.bobo)
foo1 = oldoby(\'ssss\')
print(foo1.bobo)

class oldboy:
    def __init__(self,name,age):
        self.Name = name
        self.Age = age

    def ren(self):
        print(self.Name)
        print(self.Age)
obj = oldboy(\'kaixin\',20)
obj.ren()

综上所述，对于面向对象的封装来说，其实就是使用构造方法将内容封装到 对象 中，然后通过对象直接或者self间接获取被封装的内容。

函数式编程
def jieshao(self,tian,qi,hao):
    print(\'%s,%s%s,%s,喝酒去\'%(self,tian,qi,hao))
jieshao(\'今天\',\'心情\',\'好\',\'走\')

面向对象
class lianxi:
    def kaiche(self,name,arg,gender):
        print("%s,%s岁，%s ,开车去山沟" %(name,arg,gender))
obj = lianxi()
obj.kaiche("老头",80,"男")

函数编程 与 面向对象

小明，18，体重
吃 加 20 
减肥 减 10
喝  加   5   

class Person:
    def __init__(self,name,age,zhong):
        self.Name = name
        self.Age = age
        self.Zhong = zhong
    def chi(self):
        self.Zhong = self.Zhong + 20
    def jian(self):
        self.Zhong = self.Zhong - 10
    def he(self):
        self.Zhong = self.Zhong + 5
doo = Person(\'小明\',18,150)
doo.chi()
doo.jian()
doo.jian()
doo.he()
print(doo.Name,doo.Age,doo.Zhong)

小练习

继承：面向对象中的继承和现实生活中的继承相同，即：子可以继承父的内容。

派生类（子类）可以继承基类（父类）的功能

class Foo:
    def fun(self):
        print(\'xxxxxxxx\')

class XXX(Foo):
    def ccc(self):
        print(23212)
obj = XXX()
obj.fun()
obj.ccc()

继承

 

派生类 和基类同时存在，优先找派生类

class Aii:
    def chi(self):
        print(self.name + \'吃\')
class Bii(Aii):
    def __init__(self,name):
        self.name = name
    def chi(self):
        print(self.name + \'叫\')
    def jiao(self):
        print(\'爽歪歪\')
bb = Bii(\'小明真会\')
bb.chi()
bb.jiao()

执行结果：
小明真会叫
爽歪歪
python

asd

 

类可以同时继承多个类。而在（c#，Java）不可以

class Aii:
    def f1(self):
        print(\'Aii\')
class A(Aii):
    def f(self):
        print(\'A\')
class B(Aii):
    def f1(self):
        print(\'B\')
class C(A):
    def f1(self):
        print(\'C\')
class D(B):
    def f1(self):
        print(\'D\')
class E(C,D):
    def f(self):
        print(\'E\')
x = E()
x.f1()

多继承

继承的执行顺序

从左到右去执行， 哪个类调用self就传值给那个类 

方法从哪个调用的就执行哪个方法

class A:
    def bar(self):
        print(\'BAR\')
        self.f1()
class B(A):
    def f1(self):
        print(\'B\')
class C:
    def f1(self):
        print(\'C\')
class D(C,B):
    pass
d1 = D()
d1.bar()

View Code

python2.7 继承流程

当未继承object时（经典类）深度优先继承：

继承object（新式类） 顶部最后（广度优先）

class bar:  #python2,7 #不继承一条道走到黑，继承新式类顶部最后 广度优先
    def f1(self):
        print \'bar\'
class A(bar):
    def f(self):
        print \'a\'
class B(bar):
    def f1(self):
        print \'b\'
class C(A):
    def f(self):
        print \'c\'
class D(B):
    def f1(self):
        print \'d\'
class E(C,D):
    def f(self):
        print \'eeee\'

e = E()
e.f1()

继承

     

 

执行父类的构造方式：

super(当前类,self).init()    执行父类的构造方式  类后面加括号自动执行
父类.__init__(self,xxx)     数据的初始化

class A:
    def __init__(self):
        print(\'A构造方法\')
        self.tu = \'000动物000\'

class B(A):
    def __init__(self): 
        print(\'B构造方法\')
        self.n = \'000猫000\'      
        super(B,self).__init__()     super(当前类,self).init()

b1 = B()
b1.tu
print(b1.__dict__)

View Code

 

三、多态 即是说多种形态

Pyhon不支持多态并且也用不到多态，多态的概念是应用于Java和C#这一类强类型语言中，而Python崇尚“鸭子类型”。

 

class F1:
    pass


class S1(F1):

    def show(self):
        print (\'S1.show\')


class S2(F1):

    def show(self):
        print( \'S2.show\')


# 由于在Java或C#中定义函数参数时，必须指定参数的类型
# 为了让Func函数既可以执行S1对象的show方法，又可以执行S2对象的show方法，所以，定义了一个S1和S2类的父类
# 而实际传入的参数是：S1对象和S2对象

def Func(F1 obj):
    """Func函数需要接收一个F1类型或者F1子类的类型"""
    
    print (obj.show())
    
s1_obj = S1()
Func(s1_obj) # 在Func函数中传入S1类的对象 s1_obj，执行 S1 的show方法，结果：S1.show

s2_obj = S2()
Func(s2_obj) # 在Func函数中传入Ss类的对象 ss_obj，执行 Ss 的show方法，结果：S2.show

多态

class F1:
    pass

class S1(F1):

    def show(self):
        print \'S1.show\'

class S2(F1):

    def show(self):
        print \'S2.show\'

def Func(obj):
    print obj.show()

s1_obj = S1()
Func(s1_obj) 

s2_obj = S2()
Func(s2_obj) 

Python “鸭子类型”

 查找源码的 过程：

查找源码的方法 （self.xxx（）从底层开始找）从左到右 

import socketserver   #查找源码的过程
r = socketserver.ThreadingTCPServer()
r.serve_forever()