python面向对象

一、封装

#面向对象：封装
class Person:
    def __init__(self,name,age):
        """
        构造函数，类被调用的时候自动被执行。可以用来封装各种通用的参数等.
        self:调用方法的调用者的对象是谁就是谁
        """
        self.name = name
        self.age = age
        self.gender = "man"
    def show(self):
        print("He is %s ,age: %s" %(self.name,self.age))

p1=Person("xiaofan",20)
p1.show()

二、继承

#面向对象：继承
class F:  #父类，基类
    def f1(self):
        print('F.f1 . self： %s' %self)   # 调用父类要给他传self ，要么自动传，要么手动传
    def f2(self):
        print('F.f2')

class S(F):   # 子类 ，派生类 ,继承自 F 。 先在自己的类中找，没有再去父类中找
    def s1(self):
        print('S.s1')
    def f2(self):   #重写
        pass
    def f3(self):
        super(S,self).f2()
        #方法1：执行父类中的f2方法 。 super(子类名，调用者self)
        F.f2(self)
        # 方法2：执行父类中的f2方法 。执行对象self自动创建，执行分类方法要自己给他传self
        print('S.f3')
a = S()
a.s1()
a.f1()  # 执行父类方法
a.f2()
a.f3()

# python多继承:
# 当父类中有相同的方法时，继承顺序优先级从左到右，找到则停止
# 继承关系： a -> b -> c  , a -> d
    # 继承顺序: 从左（左边的所有）-->右
# 继承关系：a -> b -> c -> z  , a -> d -> e -> z
    # 继承顺序：从左（最上面的z，不找）-->右 --> 最后才找z


#多继承：

class BaseReuqest:
    def __init__(self):
        print('BaseReuqest.init')
class RequestHandler(BaseReuqest):
    def __init__(self):
        print('RequestHandler.init')
        BaseReuqest.__init__(self)
    def serve_forever(self):
        print('RequestHandler.serve_forever')
        self.process_request()
        #此处会调用哪个process_request()呢
        # self,是obj ， obj== 调用者 。 那么肯定是执行Minx中的process_request()的
        # 注意看 self 是哪个类的对象，然后回到那里去找
    def process_request(self):
        print('RequestHandler.process_request')
class Minx:
    def process_request(self):
        print('minx.process_request')
class Son(Minx, RequestHandler):
    pass

obj=Son()
# 实例化Son的对象，Son()继承Minx,和RequestHandler。
# 执行 RequestHandler的初始化方法
obj.serve_forever()
# 执行RequestHandler父类BaseReuqest的初始化方法
# 执行RequestHandler的server_forever()
# 执行 Minx的process_request() 方法

三、多态

#多态：传入的参数不同类型执行的方法不一样
#在python中不需要考虑多态，python原生就是多态的