面向对象编程（3）

最新推荐文章于 2022-11-15 18:55:43 发布

DS_zxm123

最新推荐文章于 2022-11-15 18:55:43 发布

阅读量169

点赞数 1

本文链接：https://blog.csdn.net/DS_zxm123/article/details/90342270

版权

面向对象编程的三大特征：封装、继承、多态

封装

将数据和行为包装到类对象中，在方法内部对属性进行操作，在类对象的外部调用方法，这样无须关心方法内部的具体实现细节，从而隔离了隔离了复杂度。
在类对象的内部通过访问控制把某些属性和方法隐藏起来，不允许在类对象的外部直接访问，而是在类对象的内部对外提供公开的接口方法（例如getter和setter）已访问隐藏的信息。这样，就对隐藏的信息进行了保护。

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("成绩必须在0~100之间")
            
s = Student()
s.get_score()
#结果
90

继承

当几个类对象中有共同的属性和方法时，就可以把这些属性和方法抽象并提取到一个基类中，每个类对象特有的属性和方法还是在本类对象中定义，这样，只需要让每个类对象都继承这个基类，就可以访问基类中的属性和方法了。继承基类的每个类对象被称为派生类。基类也被称为父类或超类，派生类也被称为子类。Python中的所有类对象都继承自一个统一的基类: object。这就是为什么我们在定义类对象时要在类名后面添加(object)。

class Dog(object):
    def eat(self):
        print("吃饭")
        
    def drink(self):
        print("喝水")
        
    def swim(self):
        print("游泳")      
class Bird(object):
    def eat(self):
        print("吃饭")
        
    def drink(self):
        print("喝水")
        
    def fly(self):
        print("飞翔")


class Animal(object):
    def eat(self):
        print("吃饭")
        
    def drink(self):
        print("喝水")    
class Dog(Animal):
    def swim(self):
        print("游泳")
class Bird(Animal):
    def fly(self):
        print("飞翔")

dog = Dog()
dog.eat()
dog.drink()
dog.swim()
##结果
吃饭
喝水
游泳

bird = Bird()
bird.eat()
bird.drink()
bird.fly()
##结果
吃饭
喝水
飞翔

单继承
子类只有一个直接父亲成为单继承。
子类和父类分别为Chileclass和Parentclass。
多继承
子类有多个直接父类时称为多继承。
子类会继承所有的父类（包括直接父类和所有间接父类）的所有属性和方法。

class ParentClassA(object):
    ca = 18
    def im(self):
        print("im()被调用了")
class ParentClassB(object):
    __pca = 23
    def __pim(self):
        print("__pim()被调用了")
class ParentClassC(ParentClassA,ParentClassB):
    @classmethod
    def cm(cls):
        print("cm()被调用了")
        
class PrintClassD(object):
    @staticmethod
    def sm():
        print("sm()被调用了")
class ChildClass(ParentClassC,PrintClassD):
    pass
print(dir(ChildClass))#查看子类所继承的属性和方法
##结果
['_ParentClassB__pca', '_ParentClassB__pim', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'ca', 'cm', 'im', 'sm']

子类可以添加父类中没有的方法和属性

class BaseClass(object):
    ca_base = 5
    
    def im_base(self):
        print("im_base()被调用了")
        
class SubClass(BaseClass):
    ca_sub = 8
    
    def im_sub(self):
        print("im_sub()被调用了")
        
print(dir(SubClass))
##结果
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'ca_base', 'ca_sub', 'im_base', 'im_sub']

重写（overwriting）

如果子类対继承自父类的某个属性或方法不满意，可以在子类中对其进行重写从而提供自定义的实现，重写的方式为：在子类中定义与父类同名的属性和方法（包括装饰器）。

子类重写父类的属性后，通过子类或其实例对象只能访问重写后的属性，而无法再访问父类中被重写的属性。

子类重写父类的方法后，通过子类或其实例对象只能调用子类中重写后的方法，而无法再访问父类中被重写的方法。

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()
##结果
__init__()被调用了(子类)
ca(子类)
ca(子类)
im()被调用了(子类)
cm()被调用了(子类)
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()
##结果
__init__()被调用了(父类)
__init__()被调用了(子类)
ca(子类)
ca(子类)
im()被调用了(父类)
im()被调用了(子类)
cm()被调用了(父类)
cm()被调用了(子类)
cm()被调用了(父类)
cm()被调用了(子类)

MRO(方法解析顺序）

MRO的全称是Method Resolution Order,他指的是对于一棵类继承树，当调用最底层类对象所。

对应实例对象的方法时，python解释器在类继承树上搜索方法的顺序。

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")
        
d = D()
d.f()
##结果
D.f

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):
    pass
    
d = D()
d.f()
##结果
B.f

class A(object):
    def f(self):
        print("A.f")
        
class B(A):
    pass
        
class C(A):
    def f(self):
        print("C.f")
        
class D(B,C):
    pass
    
d = D()
d.f()
##结果
C.f

class A(object):
    def f(self):
        print("A.f")
        
class B(A):
    pass
        
class C(A):
    pass
        
class D(B,C):
    pass
    
d = D()
d.f()
##结果
A.f

对于一棵类继承树，可以调用最底层类对象的方法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")
        
print(D.__mro__)#列表形式
##结果
(<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>)

print(D.mro())#字典形式
[<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]

在子类重写后的方法中通过super调用父类中被重写的方法时，在父类中搜索方法的顺序基于以该子类为最底层类对象的类继承树的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):
        super().f()#调用重写后的子类
        
d = D()
d.f()
##结果
B.f

如果想要调用指定父类中被重写的方法，可以给super()传入两个参数：super(a_type,obj),其中，第一个实参a_type是个类对象，第二个实参obj是个实例对象，这样被指定的父类是：obj所对应类对象的MRO中，a_type后面那个类对象。

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):
        #super().f()
        super(B,self).f()
        
d = D()
d.f()
##结果
C.f

多态——在不考虑对象类型的情况下使用对象

简单地说，多态就是“具有多种形态”。它指的是：即便不知道一个变量所引用的对象到底是什么类型，仍然可以通过这个变量调用方法，在运行过程中根据变量所引用对象的类型，动态的决定调用那个对象中的方法。

class ParentClass(object):
    def do_sth(self):
        print("do_sth() in ParentClass")
        
class ChildClass1(ParentClass):
    def do_sth(self):
        print("do_sth() in ChildClass1")
        
class ChildClass2(ParentClass):
    def do_sth(self):
        print("do_sth() in ChildClass2")
        
def f(parent):
    parent.do_sth()

f(ParentClass())
f(ChildClass1())
f(ChildClass2())
##结果
do_sth() in ParentClass
do_sth() in ChildClass1
do_sth() in ChildClass2

如果子类中不存在指定名称的方法，回到父类中去查找，如果在父类中找到了，则调用父类中的方法。

class ChildClass3(ParentClass):
    pass

f(ChildClass3())
##结果
do_sth() in ParentClass

python是动态语言，在调用函数时不会检查参数的类型。

动态语言的多态崇尚（鸭子类型）：如果一只生物走起路来像鸭子，游起泳来像鸭子，叫起来也像鸭子，那么它就可以被当作鸭子。

也就是说，它不关注对象的类型，而是关注对象具有的行为。

在上面的程序中，我们并不关心变量parent所引用的对象是什么类型，到底是不是ParentClass或其子类类型，只关心变量parent所引用的对象是否有do_sth这个方法。

DS_zxm123

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
面向对象编程（3）

面向对象编程的三大特征：封装、继承、多态封装将数据和行为包装到类对象中，在方法内部对属性进行操作，在类对象的外部调用方法，这样无须关心方法内部的具体实现细节，从而隔离了隔离了复杂度。在类对象的内部通过访问控制把某些属性和方法隐藏起来，不允许在类对象的外部直接访问，而是在类对象的内部对外提供公开的接口方法（例如getter和setter）已访问隐藏的信息。这样，就对隐藏的信息进行了保护。...
复制链接

扫一扫