面向对象的编程03

最新推荐文章于 2022-09-25 19:00:20 发布

沈奕阳

最新推荐文章于 2022-09-25 19:00:20 发布

阅读量100

点赞数 1

本文链接：https://blog.csdn.net/syy6321/article/details/90232621

版权

封装继承多态

封装：

1.将数据和行为包装到类对象中，在方法内部对属性进行操作在类对象的外部调用方法
2.在类对象的内部通过访问控制把某些属性和方法影藏起来不允许在类对象外部直接访问而是在类对象的内部对外提供公开的接口方法以访问隐藏信息

继承：

单继承子类只有一个直接父亲时
多继承子类有多个直接父亲时
子类继承父类所有属性和对象

#封装
class Student(object):
    def __init__(self):
        self.__score = 90
    def get_score(self):
        return self.__score
    def set_score(self, score):
        if 0<= score  <=100:
            self.__score = score
        else:
            raise ValueError

s = Student()
s.get_score()
s.set_score(88)
s.get_score()

#继承
class Dog(object):
    def eat(self):
        print('xxx')
    def drink(self):
        print('xxx')
    def swim(self):
        print('xxx')

class Bird(object):
    def eat(self):
        print('xxx')
    def drink(self):
        print('xxx')
    def fly(self):
        print('xxx')
s=Dog()
s.drink()

class Animal(object):
    def eat(self):
        print('xxx')
    def drink(self):
        print('xxx') 


class Dog(Animal):
    def swim(self):
        print('xxx')
class Bird(Animal):
    def fly(self):
        print('xxx')


s=Dog()
s.drink()

重写

如果子类对继承父类的某个属性或方法不满可以在子类中对其进行重写从而提供自定义的实现重写子类中定义与父类中同名的属性或方法
子类重写父类的属性后通过子类或其实例对象只能访问子类中重写后的属性而无法访问父亲中被重写的属性
子类重写父亲的方法后通过子类或其实例对象只能调用子类中重写后的方法而无法在调用父类中被重写的方法

class ParentClass(object):
    ca ='ca(父亲)'
    def __init__(self):
        print('__init__()调用了(父亲)')
    def im(self):
        print('im()调用了(父亲)')
    @classmethod
    def cm(cls):
        print('cm()调用了(父亲)')
    


class ChildClass(ParentClass):
    ca ='ca(子类)'
    def __init__(self):
        print('__init__()调用了(子类)')
    def im(self):
        print('im()调用了(子类)')
    @classmethod
    def cm(cls):
       print('cm()调用了(子类)')

cc = ChildClass()
print(ChildClass.ca)
print(cc.ca)
cc.im()
ChildClass.cm()
cc.cm()

#父亲中被重写的名为xxx的方法 在子类重写后的方法中科可以通过super().xxx()
class ParentClass(object):
    ca ='ca(父亲)'
    def __init__(self):
        print('__init__()调用了(父亲)')
    def im(self):
        print('im()调用了(父亲)')
    @classmethod
    def cm(cls):
        print('cm()调用了(父亲)')
    
 

class ChildClass(ParentClass):
    ca ='ca(子类)'
    def __init__(self):
        super().__init__()
        print('__init__()调用了(子类)')
    def im(self):
        super().im()
        print('im()调用了(子类)')
    @classmethod
    def cm(cls):
        super().cm()
        print('cm()调用了(子类)')

cc = ChildClass()
print(ChildClass.ca)
print(cc.ca)
cc.im()
ChildClass.cm()
cc.cm()

MRO的全称是Method ResoLution Order (方法解析顺序) ，它指的是对于一颗类继承树，当调用底层类对象所对应实例对象的方法时， Python解释器在类继承树上搜索方法的顺序。
对于一棵类继承树，可以调用最底层类对象的方法mro()或访问最底层类对象的特殊属性mro ，获得这棵类继承树的MRO.

class A(object):
def f(self):
print(“A.f”)

class B(A):
def f(self):
print(“B.f”)

class C(A):
def f(self):
print(“C.f”)

class D(B,C):
def f(self):
print(“D.f”)

class E(B,C):
pass

d = D()
d.f()
D.f
e = E()
e.f()
B.f