Python--面向对象--多继承和多肽

　一、多继承　

　　1.概念：所谓多继承，就是一个类同时有多个父类 

　　2.语法

　　　　class 子类(父类1，父类2):

　　　　　　方法... 

　　3.案例

class AAA():
    def methodAAA(self):
        print("a的方法a")
class BBB():
    def methodBBB(self):
        print("b的方法b")
class CCC(AAA,BBB):
    def methodCCC(self):
        self.methodAAA()
        self.methodBBB()
        print("c的方法c")
ccc = CCC()
ccc.methodCCC()

　　4.如果父类中有同名的方法，继承谁，取决于继承的顺序，靠前的先继承，靠后的被遮挡

　　　如果是继承父类中的属性，第一个父类的属性会被直接继承，后面的属性忽略

class AAA():
    def methodAAA(self):
        print("a的方法a")    # 新增方法，BBB类中有同名方法
    def methodBBB(self):
        print("a的方法b")
class BBB():
    def methodBBB(self):
        print("b的方法b")
class CCC(AAA,BBB):
    def methodCCC(self):
        self.methodAAA()
        self.methodBBB()
        print("c的方法c")
ccc = CCC()
ccc.methodCCC(）

二、方法重写

　　所谓重写,就是在子类中，有一个和父类相同名字的方法，子类中的方法会覆盖掉 父类中的同名方法。 

　　优先调用当前类中的方法，如果没有，找父类，顺着继承链直到找到object。如果再没有，抛出异常。

class SuperClass():
    def __init__(self,name):
        self.name = name
    def test(self):
        print("父类的测试方法")
class SubClass(SuperClass):
    def __init__(self,name,age):
       # SuperClass.__init__(self,name)
# super(SubClass, self).__init__(name)
super().__init__(name)
        self.age  = age
    # 子类重写父类方法
    def test(self):
        print("子类的测试方法")
        print('name:'+self.name+",age:"+str(self.age))
 
sub = SubClass('aa',12)
sub.test()

三、多肽

　　用一个函数来调用类里面的对象，但是不确定掉用的是哪个对象。

class F1(object):
    def show(self):
        print("F1.show")
class S1 (F1):
    def show(self):
        print("S1.show")
class S2(S1):
    def show(self):
        print("S2.show")
#创建一个函数
def func(obj):
    obj.show()
#创建一个对象
obj1 = F1()
#函数的调用
func(obj1)

 三、类属性，类方法　

类属性
    定义位置：
        写在方法外
    特点
        属于类所有，所有对象共享一个类变量
    访问方式：
        成员变量的访问方式：
            类外访问：
                对象名.属性名
            类内访问：
                使用self.属性名
        类变量的访问方式：
            类外：
                对象名.类变量名
                如果是用于赋值的时候，会增加新的成员变量
                如果是用于获取值的，则是有成员变量默认访问成员变量，如果没有，访问的为类变量

                注意： 成员变量名不要与类变量名一致

            类内：
                可以使用    self.类属性名
                也可以使用   类名.类属性名(推荐使用)

类方法
    什么方法是类方法？
        使用关键字@classmethod修饰的方法属于成为类方法，参数为cls
        在类方法中不能使用self关键字
        类方法属于类所有，不同于成员方法属于对象

    调用方法：1.  类名.方法名()  2. 对象名.方法名()

　　 　　通常使用方式1进行调用
        使用技巧：一般情况下：  工具类中的方法  使用类方法、

class Student():
    schoolname = "西三旗校区"
    def __init__(self,name,age,gender):
        self.name = name
        self.age = age
        self.gender = gender
    def introduce(self):
        print("我叫:%s,今年%d岁，性别:%s"%(self.name,self.age,self.gender))
        print("校区名:%s"%self.schoolname)
        print("校区名:%s"%Student.schoolname)
    # 使用类方法展示个人信息
    @classmethod
    def showinfo(cls,stu):
        print("学校名：%s"%cls.schoolname)
        print("我叫:%s,今年%d岁，性别:%s" % (stu.name, stu.age, stu.gender))
　　

stu1 = Student('奥斯特洛夫斯基',16,'男')
stu2 = Student('奥斯特洛夫朱莉',17,'女')
print(stu1.schoolname)
print(stu2.schoolname)
# 对象stu1中增加新的成员变量，赋值为“上海校区”
stu1.schoolname = "上海校区"
# 优先访问成员变量，类变量被屏蔽
print(stu1.schoolname)
# stu2中没有成员变量schoolname，访问的为类变量schoolname
print(stu2.schoolname)

# 默认初始化的类属性
print(Student.schoolname)
# 修改类属性的值
Student.schoolname = '广州校区'
print(Student.schoolname)
print(stu1.schoolname)
print(stu2.schoolname)

stu1.introduce()
# 类方法如何调用:1.对象名.类方法名(参数)   2.类名.类方法名(参数)
stu1.showinfo(stu1)
Student.showinfo(stu1)

　　静态方法：　　　　　

　　　　定义方式：
　　　　@staticmethod
　　　　不需要任何参数
　　　　不需要对象，或者类进行参与，内存占用较低，类似与函数

#     静态方法
    @staticmethod
    def testmehtod(stu):
        # 能否访问成员变量?
        # self.name = 'aaa'
        # cls.schoolname = '深圳校区'
        print(Student.schoolname)
        print("我叫:%s,今年%d岁，性别:%s" % (stu.name, stu.age, stu.gender))
　　　　　

#1. 类名.静态方法名()
Student.testmehtod(stu1)
#2. 对象名.静态方法名()
stu1.testmehtod(stu1)

四、总结　

类：
    默认规则表示私有属性跟私有方法：
        self.__age = age

    类属性
        属于类所有，访问：类名.属性名, 所有对象可以共享

    成员变量
        属于对象所有
        对象名.属性名
    成员方法
        默认参数self,对象参与
        self:代表当前类的一个对象

    类方法
        默认参数cls，类参与
        cls:代表的是当前类
    静态方法
        没有默认参数，没有对象或者类参与，等价与函数，出场率比较低