python面向对象编程5（封装、继承、多态）

python面向对象编程

面向对象编程有三大重要特征：封装、继承和多态

一、封装

封装是指将数据与具体操作的实现代码放在某个对象内部，使这些代码的实现细节不被外界发现，外界只能通过接口使用该对象，而不能通过任何形式修改对象内部实现，正是由于封装机制，程序在使用某一对象时不需要关心该对象的数据结构细节及实现操作的方法。使用封装能隐藏对象实现细节，使代码更易维护，同时因为不能直接调用、修改对象内部的私有信息，在一定程度上保证了系统安全性。类通过将函数和变量封装在内部，实现了比函数更高一级的封装.。

函数是对语句的封装；类是对函数和变量的封装。

二、继承

继承来源于现实世界，一个最简单的例子就是孩子会具有父母的一些特征，即每个孩子都会继承父亲或者母亲的某些特征，当然这只是最基本的继承关系，现实世界中还存在着更复杂的继承。继承机制实现了代码的复用，多个类公用的代码部分可以只在一个类中提供，而其他类只需要继承这个类即可。

在OOP程序设计中，当我们定义一个新类的时候，新的类称为子类（Subclass），而被继承的类称为基类、父类或超类（Base class、Super class）。继承最大的好处是子类获得了父类的全部变量和方法的同时，又可以根据需要进行修改、拓展。

class Animal:
    def __init__(self,name):
        self.name=name

    def sleep(self):
        print(self.name+'正在睡觉！')

class Dog(Animal):
    def bark(self):
        print(self.name + '正在叫')

class Student(Animal):
    def study(self):
        print(self.name + '正在好好学习')

#Dog()调用__new__ 方法，再调用__init__方法
#Dog()里没有__new__方法，会查看父类是否重写了__new__方法
#父类里也没有重写__new__方法，查找父类的父类，找到了object

#调用__init__方法，Dog类没有此方法，会自动找Animal父类的__init__方法
d=Dog('小花狗')
print(d.name)  #父类里定义的属性，子类可以直接使用
d.sleep()      #父类的方法子类实例对象可以直接调用
d.bark()

运行结果：

小花狗
小花狗正在睡觉！
小花狗正在叫

1、多继承的特点

a、类为经典类时，多继承情况下，会按照深度优先查找

b、类为新式类时，多继承情况下，会按照广度优先查找

#新式类
class D:
    def test(self):
        print("D")


class C(D):
    # def test(self):
    #     print("C")
    pass

class B(D):
    def test(self):
        print("B")


class A(B, C):
    # def test(self):
    #     print("A")
    pass

a = A()
a.test()   #B

print(A.__mro__)

#(<class '__main__.A'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.D'>, <class 'object'>)

　　在新式类（python3）中，搜索的次序应该是这样的：

在经典类中，搜索的次序应该是这样的：

2、私有属性和方法的继承

私有属性和方法，子类不会继承，但可以通过：对象名._父类名__私有属性（或方法名）调用。

class Animal:
    def __init__(self,name,age):
        self.name=name
        self.age=age
        self.__money=1000

    def eat(self):
        print(self.name+'正在吃东西')

    def __test(self):
        print('我是Animal类里的test方法')

class Person(Animal):
    def __demo(self):
        print('我是Person类的demo方法')

p=Person('zhangsan',18)
p._Person__demo()  #自己类里定义的私有方法   对象名._类名.__私有方法名()
p._Animal__test()  #可以通过  对象名._父类名.__私有方法名()
# p._Person__test()      报错，父类的私有方法，子类没有继承

print(p._Animal__money)   #可以通过  对象名._父类名.__私有属性名
# print(p._Person__money)    报错，父类的私有方法，子类没有继承

三、多态

就是多个对象调用父类的相同的方法但结果不一样强调的是执行相同的功能的时候多态就是继承的一种表现形式。

多态是基于继承，通过子类重写父类的方法
达到不同的子类对象调用相同的父类方法，得到不同的结果
提高代码的灵活度

class Dog:
    def work(self):
        print('狗正在工作')

class ArmyDog(Dog):
    def work(self):
        print('军犬正在追击敌人')

class DrugDog(Dog):
    def work(self):
        print('缉毒犬正在追查毒品')

class Policeman:
    def __init__(self):
        self.dog = None

    def work_with_dog(self):
        self.dog.work()

p1 = Policeman()

ad = ArmyDog()  # ad是条军犬
p1.dog = ad  # 给警察一条狗
p1.work_with_dog()

dd = DrugDog()
p1.dog = dd
p1.work_with_dog()

多态总结：

定义：多态是一种使用对象的方式，子类重写父类方法，调用不同子类对象的相同父类方法，可以产生不同的执行结果。
好处：调用灵活，有了多态，更容易编写通用的代码，做出通用的编程，以适应需求的不断变化。
实现步骤

1、定义父类，并提供公共方法

2、定义子类，并重写父类方法

3、传递子类对象给调用者，可以看到不同子类执行效果不同

posted @ 2021-02-28 21:04 wangshanglinju 阅读(125) 评论(0) 编辑收藏举报

刷新页面返回顶部

wangshanglinju

python面向对象编程5（封装、继承、多态）

公告