python--------面向对象【私有属性和私有方法、继承、多态】

最新推荐文章于 2024-03-01 21:12:00 发布

GYH_xr

最新推荐文章于 2024-03-01 21:12:00 发布

阅读量245

点赞数

分类专栏： # Python基础

本文链接：https://blog.youkuaiyun.com/guoxiaorui666/article/details/100106763

版权

Python基础专栏收录该内容

22 篇文章

订阅专栏

这篇博客介绍了Python面向对象的三大特性：封装、继承和多态。详细讲解了如何定义私有属性和私有方法，以及单继承和多继承的概念、方法重写和多态的实现。强调了私有属性和方法的访问限制，以及多继承时的方法搜索顺序。最后通过案例展示了多态的应用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

面向对象三大特性

封装根据职责将属性和方法封装到一个抽象的类中
继承实现代码的重用，相同的代码不需要重复的编写
多态不同的对象调用相同的方法，产生不同的执行结果，增加代码的灵活度

私有属性和私有方法

在实际开发中，对象的 某些属性或方法 可能只希望 在对象的内部被使用，而 不希望在外部被访问到
私有属性 就是对象不希望公开的属性
私有方法 就是对象不希望公开的方法

定义方式
在 定义属性或方法时，在 属性名或者方法名前 增加 两个下划线，定义的就是私有属性或方法

class Women:

    def __init__(self, name):
        self.name = name
        # 不要问女生的年龄
        self.__age = 18  #私有属性

    def secret(self):
        print("我的年龄是 %d" % self.__age)


xiaofang = Women("小芳")

# 私有属性，外部不能直接访问
#print(xiaofang.__age)   #会报错

xiaofang.secret()   #我的年龄是 18

class Women:

    def __init__(self, name):
        self.name = name
        # 不要问女生的年龄
        self.__age = 18  #私有属性

    def __secret(self):
        print("我的年龄是 %d" % self.__age)


xiaofang = Women("小芳")
# 私有属性，外部不能直接访问
#print(xiaofang.__age)

# 私有方法，外部不能直接调用
xiaofang.__secret()

class Women:

    def __init__(self, name):
        self.name = name
        # 不要问女生的年龄
        self.__age = 18  #私有属性

    def __secret(self):
        print("我的年龄是 %d" % self.__age)


xiaofang = Women("小芳")
# 私有属性，外部不能直接访问
#print(xiaofang.__age)   #会报错

# 私有方法，外部不能直接调用
# xiaofang.__secret()  #会报错

继承

单继承

继承的概念：子类拥有父类的所有方法和属性
在这里插入图片描述

1) 继承的语法

class 类名(父类名):

    pass

子类继承自父类，可以直接享受父类中已经封装好的方法，不需要再次开发
子类中应该根据职责，封装 子类特有的 属性和方法

2) 专业术语

Dog 类是 Animal 类的子类，Animal 类是 Dog 类的父类，Dog 类从 Animal 类继承
Dog 类是 Animal 类的派生类，Animal 类是 Dog 类的基类，Dog 类从 Animal 类派生

3) 继承的传递性

C 类从 B 类继承，B 类又从 A 类继承
那么 C 类就具有 B 类和 A 类的所有属性和方法

class Animal:
    def eat(self):
        print('吃....')
    def drink(self):
        print('喝....')
    def run(self):
        print('跑....')
    def sleep(self):
        print('跑....')

class Dog(Animal):
    def bark(self):
        print('汪汪汪....')

class XiaoTianQuan(Dog):
    def fly(self):
        print('我飞....')

class Cat(Animal):
    def catch(self):
        print('抓老鼠....')

wangcai=Dog()
xiaotainquan=XiaoTianQuan()
miaomiao=Cat()

wangcai.run()   #跑....
wangcai.bark()    #汪汪汪....
xiaotainquan.eat()   #吃....
xiaotainquan.bark()   #汪汪汪....
xiaotainquan.fly()    #我飞....
miaomiao.sleep()    #跑....
miaomiao.catch()   #抓老鼠....

方法重写

应用场景

当父类的方法实现不能满足子类需求时，可以对方法进行 重写(override)

重写父类方法有两种情况：

覆盖父类的方法
对父类方法进行扩展

1) 覆盖父类的方法

如果在开发中，父类的方法实现和子类的方法实现，完全不同
就可以使用覆盖的方式，在子类中重新编写父类的方法实现

具体的实现方式，就相当于在 子类中 定义了一个 和父类同名的方法并且实现

重写之后，在运行时，只会调用子类中重写的方法，而不再会调用父类封装的方法

class Animal:
    def eat(self):
        print('吃....')
    def drink(self):
        print('喝....')
    def run(self):
        print('跑....')
    def sleep(self):
        print('跑....')

class Dog(Animal):
    def bark(self):
        print('汪汪汪....')

class XiaoTianQuan(Dog):
    def fly(self):
        print('我飞....')
    #哮天犬和普通的狗交的方式不一样
    def bark(self):
        print('我和普通的狗叫的不一样....')

xiaotiaquan=XiaoTianQuan()

xiaotiaquan.bark()   #我和普通的狗叫的不一样....

2) 对父类方法进行扩展

如果在开发中，子类的方法实现中包含父类的方法实现
父类原本封装的方法实现是子类方法的一部分
就可以使用扩展的方式
在子类中重写父类的方法
在需要的位置使用 super().父类方法 来调用父类方法的执行
代码其他的位置针对子类的需求，编写 子类特有的代码实现

关于 super

在 Python 中 super 是一个特殊的类
super() 就是使用 super 类创建出来的对象
最常使用的场景就是在重写父类方法时，调用在父类中封装的方法实现

class Animal:
    def eat(self):
        print('吃....')
    def drink(self):
        print('喝....')
    def run(self):
        print('跑....')
    def sleep(self):
        print('跑....')

class Dog(Animal):
    def bark(self):
        print('汪汪汪....')

class XiaoTianQuan(Dog):
    def fly(self):
        print('我飞....')
    #哮天犬和普通的狗交的方式不一样
    def bark(self):
        #1.针对自雷特有的需求，编写代码
        print('我和普通的狗叫的不一样....')

        #2.使用super(). 调用原本在父类封装的方法
        super().bark()
        #Dog.bark(self)   和上面的使用方法一样

        # 3.增加其它代码
        print('#$^&*6￥$')

xiaotiaquan=XiaoTianQuan()

xiaotiaquan.bark()

运行结果

我和普通的狗叫的不一样....
汪汪汪....
#$^&*6￥$

调用父类方法的另外一种方式
在 Python 2.x 时，如果需要调用父类的方法，还可以使用以下方式：

父类名.方法(self)

这种方式，目前在 Python 3.x 还支持这种方式
这种方法不推荐使用，因为一旦父类发生变化，方法调用位置的类同样需要修改提示
在开发时，父类名和super()两种方式不要混用
如果使用当前子类名调用方法，会形成递归调用，出现死循环

父类的私有属性和私有方法

子类对象不能在自己的方法内部，直接访问父类的私有属性或私有方法
子类对象可以通过父类的公有方法间接访问到私有属性或私有方法

私有属性、方法是对象的隐私，不对外公开，外界以及子类都不能直接访问
私有属性、方法通常用于做一些内部的事情

class Women:

    def __init__(self, name):
        self.name = name
        # 不要问女生的年龄
        self.__age = 18  #私有属性

    def secret(self):
        print("我的年龄是 %d" % self.__age)


xiaofang = Women("小芳")
# 私有属性，外部不能直接访问
#print(xiaofang.__age)

xiaofang.secret()    #我的年龄是 18

class Women:

    def __init__(self, name):
        self.name = name
        # 不要问女生的年龄
        self.__age = 18  #私有属性

    def __secret(self):
        print("我的年龄是 %d" % self.__age)


xiaofang = Women("小芳")
# 私有属性，外部不能直接访问
#print(xiaofang.__age)

# 私有方法，外部不能直接调用
#xiaofang.__secret()

class A:
    def __init__(self):
        self.num1=100
        self.__num2=200

    def __test(self):
        print('私有方法 %d %d'%(self.num1,self.__num2))

    def test(self):
        print('父类的公有方法%d'% self.__num2)
        self.__test()

class B(A):
    def demo(self):

        #1.在子类的对象方法中，不能访问父类的私有属性
        # print('访问父类的私有属性%d'%self.__num2)

        #2.在子类的对象方法中，不能调用父类的私有方法
        # self.__test()

        #3. 访问父类的公有方法
        print('子类方法 %d'%self.num1)

        #4. 调用父类的公有方法
        self.test()
        pass


#创建一个子类对象
b=B()
print(b)

b.demo()

#在外界能直接访问父类的公有属性/调用公有方法
print(b.num1)
b.test()

#在外界不能直接访问对象的私有属性/调用私有方法
# print(b.__num2)
# b.__test()

运行结果

<__main__.B object at 0x01680E50>
子类方法 100
父类的公有方法200
私有方法 100 200
100
父类的公有方法200
私有方法 100 200

多继承

概念

子类可以拥有多个父类，并且具有所有父类的属性和方法
例如：孩子会继承自己父亲和母亲的特性

语法

class 子类名(父类名1, 父类名2…)
pass

class A:

    def test(self):
        print('test 方法')

class B:
    def demo(self):
        print('demo 方法')

class C(A,B):
    pass


#创建子类对象
c=C()

c.test()   #test 方法
c.demo()    #demo 方法

多继承的使用注意事项

开发时，应该尽量避免不同的父类中存在同名的方法，这种容易产生混淆的情况！ —— 如果父类之间存在同名的属性或者方法，应该尽量避免使用多继承

class A:

    def test(self):
        print('A-----test 方法')

    def demo(self):
        print('A------demo 方法')

class B:
    def test(self):
        print('B-----test 方法')

    def demo(self):
        print('B------demo 方法')

#先继承A再继承B
class C(A,B):
     pass

#创建子类对象
c=C()

c.test() #A-----test 方法
c.demo()  #A------demo 方法

class A:

    def test(self):
        print('A-----test 方法')

    def demo(self):
        print('A------demo 方法')

class B:
    def test(self):
        print('B-----test 方法')

    def demo(self):
        print('B------demo 方法')

#先继承A再继承B
# class C(A,B):
#      pass

#先继承B再继承A
class C(B,A):
     pass
#创建子类对象
c=C()

c.test()  #B-----test 方法
c.demo()   #B------demo 方法

Python 中的 MRO —— 方法搜索顺序

Python 中针对类提供了一个内置属性 __mro__ 可以查看方法搜索顺序
MRO 是 method resolution order，主要用于在多继承时判断方法、属性的调用路径

print(C.__mro__)

输出结果

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

在搜索方法时，是按照 __mro__ 的输出结果从左至右的顺序查找的
如果在当前类中找到方法，就直接执行，不再搜索
如果没有找到，就查找下一个类中是否有对应的方法，如果找到，就直接执行，不再搜索
如果找到最后一个类，还没有找到方法，程序报错

多态

多态不同的子类对象调用相同的父类方法，产生不同的执行结果

多态可以增加代码的灵活度
以继承和 重写父类方法 为前提
是调用方法的技巧，不会影响到类的内部设计

多态案例演练
需求
在 Dog 类中封装方法 game
普通狗只是简单的玩耍
定义 XiaoTianDog 继承自 Dog，并且重写 game 方法
哮天犬需要在天上玩耍
定义 Person 类，并且封装一个和狗玩的方法

在方法内部，直接让狗对象调用 game 方法

class Dog(object):

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

    def game(self):
        print("%s 蹦蹦跳跳的玩耍..." % self.name)


class XiaoTianDog(Dog):

    def game(self):
        print("%s 飞到天上去玩耍..." % self.name)


class Person(object):

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

    def game_with_dog(self, dog):

        print("%s 和 %s 快乐的玩耍..." % (self.name, dog.name))

        # 让狗玩耍
        dog.game()


# 1. 创建一个狗对象
# wangcai = Dog("旺财")
wangcai = XiaoTianDog("飞天旺财")

# 2. 创建一个小明对象
xiaoming = Person("小明")

# 3. 让小明调用和狗玩的方法
xiaoming.game_with_dog(wangcai)

当狗对象是旺财时，运行结果

小明 和 旺财 快乐的玩耍
旺财 蹦蹦跳跳的玩耍...

当狗对象是飞天旺财时，运行结果：

小明 和 飞天旺财 快乐的玩耍
飞天旺财 飞到天上去玩耍...