面向对象（6）— 多继承、多态、类方法和静态方法、类属性

*Heygirl

于 2020-07-14 16:18:49 发布

阅读量152

点赞数

分类专栏：面向对象

本文链接：https://blog.csdn.net/qq_44372971/article/details/107337716

版权

面向对象专栏收录该内容

12 篇文章 0 订阅

订阅专栏

继承

父类的私有属性和方法

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

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

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()


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

b.demo()


输出结果：
子类方法  100
父类的公有方法 200
私有方法 100 200

多继承

概念

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

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

代码

class A:
    def test(self):
        print('A----test')


class B:
   
    def demo(self):
        print('B----demo')


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


c=C()
c.test()
c.demo()


输出结果：
A----test
B----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')


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


c=C()
c.test()
c.demo()

# 确定C类对象调用方法的顺序
print(C.__mro__)


输出结果：
A----test
A----demo
(<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>)

python中的 MRO ---- 方法搜索顺序

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

print(C.__mro__)

输出结果：

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

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

新式类与旧式（经典）类

object 是python 为所有对象提供的基类，提供有一些内置的方法和属性，可以使用 dir 函数查看

新式类：以 object 为基类的类，推荐使用
经典类：不以 object 为基类的类，不推荐使用
在 python 3.x中定义类时，如果没有指定父类，会默认使用 object 作为该类的基类 ---- python 3.x 中定义的类都是新式类
在 python 2.x 中，定义类时，如果没有指定父类，则不会以 object 作为基类

新式类 和 经典类 在多继承时 — 会影响到方法的搜索顺序

为了保证编写的代码能够同时在 python 2.x 和 python 3.x 中运行！
今后在定义类时，如果没有指定父类，建议统一继承自 object

class 类名(object):
    pass

多态

面向对象的三大特性
1.封装根据职责将属性和方法封装在一个抽象的类中

定义类的准则

2.继承实现代码的重用，相同的代码不需要重复的编写

设计类的技巧
子类针对自己特有的需求，编写特定的代码

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

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

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('旺财')
xtq = XiaoTianDog('飞天旺财')

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

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


输出结果：
小明 和 飞天旺财 一起快乐的玩耍
飞天旺财 飞到天上玩耍

类的结构

术语 — 实例

1.使用面向对象开发，第一步是设计类
2.使用类名()创建对象，创建对象的动作有两步：

1）在内存中为对象分配空间
2）调用初始化方法 __ init __为对象初始化

3.对象创建后，内存中就有了一个对象实实在在的存在— 实例

因此，通常也会把：

1.创建出来的对象，叫做类的实例
2.创建对象的动作叫做实例化
3.对象的属性叫做实例的属性
4.对象调用的方法叫做实例方法
结论

每一个对象都有自己独立的内存空间，保存各自不同的属性
多个对象的方法，在内存中只有一份，需要把对象的引用传递到方法内部

类是一个特殊的对象

python 中一切皆对象

class AAA：定义的类属于 类对象
obj1 = AAA() 属于实例对象

在程序运行时，类同样会被加载到内存
在python中，类是一个特殊的对象 — 类对象
在程序运行时，类对象在内存中只有一份，使用一个类可以创建出很多个对象实例
除了封装实例的属性和方法外，类对象还可以拥有自己的属性和方法
- 类属性
- 类方法
通过 类名. 的方式可以访问类的属性或者调用类的方法

类属性和类方法

概念和使用

类属性就是给类对象中定义的属性
通常用来记录与这个类相关的特征
类属性不会用于记录具体对象的特征

类属性代码

class Tool(object):

    # 使用赋值语句定义类属性，记录所有对象的数量
    count = 0

    def __init__(self, name):
        self.name = name   # self.属性名 代表对象的属性

        # 让类属性的值+1
        Tool.count += 1  # 类名.属性名 代表类属性


# 1.创建工具对象
tool1 = Tool('斧头')
tool2 = Tool('榔头')
tool3 = Tool('水桶')

# 2.输出工具对象的总数
# 访问类属性：类名.类属性
print(Tool.count)

输出结果：
3

属性的获取机制

在 python 中，属性的获取存在一个向上查找机制
因此，要访问类属性有两种方式：

1>类名.属性名
2>对象.类属性（不推荐）

注意

如果使用 对象.类属性 = 值 赋值语句，只会给对象添加一个属性，而不会影响到类属性的值


class Tool(object):

    # 使用赋值语句定义类属性，记录所有对象的数量
    count = 0

    def __init__(self, name):
        self.name = name   # self.属性名 代表对象的属性

        # 让类属性的值+1
        Tool.count += 1  # 类名.属性名 代表类属性


# 1.创建工具对象
tool1 = Tool('斧头')
tool2 = Tool('榔头')
tool3 = Tool('水桶')

# 2.输出工具对象的总数
tool3.count = 99
print('工具对象总数 %d' % tool3.count)
print('===> %d' % Tool.count)


输出结果：
工具对象总数 99
===> 3

从输出结果可以看出使用 对象.类属性 = 值 赋值语句，只会给对象添加一个属性，而不会影响到类属性的值

类方法和静态方法

类方法

类属性就是针对类对象定义的属性
- 使用赋值语句在 class 关键字下可以定义类属性
- 类属性用于记录与这个类相关的特征
类方法就是针对类对象定义的方法
- 在类方法内部可以直接访问类属性或者调用其他的类方法

语法如下

@classmethod
def 类方法名(cls):
    pass

类方法需要用修饰器 @classmethod 来标识，告诉解释器这是一个类方法
类方法的第一个参数应该是 cls
- 由哪一个类调用的方法，方法内的 cls 就是哪一个类的引用
- 这个参数和实例方法的第一个参数与self 类似
- 提示：使用其他名称也可以，不过习惯用 cls
通过类名. 调用类方法，调用方法时，不需要传递 cls 参数
在方法内部
- 可以通过 cls. 访问类的属性
- 也可以通过 cls. 调用其他的类方法

class Tool(object):

    # 使用赋值语句定义类属性，记录所有对象的数量
    count = 0

    # 定义类方法
    @classmethod
    def show_tool_count(cls):
        print('工具对象的数量 %d' % cls.count)

    def __init__(self, name):
        self.name = name   # self.属性名 代表对象的属性

        # 让类属性的值+1
        Tool.count += 1  # 类名.属性名 代表类属性


# 创建工具对象
tool1 = Tool('斧头')

# 调用类方法
Tool.show_tool_count()


输出结果：
工具对象的数量 1

静态方法

在开发时，如果需要在类中封装一个方法，这个方法：
- 既不需要访问实例属性或者调用实例方法
- 也不需要访问类属性或者调用类方法
这个时候，可以把这个方法封装成一个静态方法

语法如下：

@staticmethod
def 静态方法名(cls):
    pass

类方法需要用修饰器 @staticmethod 来标识，告诉解释器这是一个类方法
通过 类名. 调用静态方法

class Dog(object):

    # 定义静态方法
    @staticmethod
    def run():

        # 不访问实例属性/类属性
        print('小狗要跑...')


# 通过 类名.调用静态方法 - 不需要创建对象
Dog.run()

输出结果：
小狗要跑...

方法综合案例

在这里插入图片描述

class Game(object):

    # 类属性：历史最高分
    top_score = 0

    # 实例(对象)属性
    def __init__(self, player_name):
        self.player_name = player_name

    # 静态方法
    @staticmethod
    def show_help():
        print('帮助信息：让僵尸进入大门')

    # 类方法
    @classmethod
    def show_top_score(cls):
        print('历史记录 %d' % Game.top_score)

    # 实例(对象)方法
    def start_game(self):
        print('%s 开始玩游戏了...' % self.player_name)


# 1.查看游戏的帮助信息 ->调用静态方法
Game.show_help()

# 2.查看历史最高分 ->调用类方法
Game.show_top_score()

# 3.创建游戏对象
xiaoming = Game('小明')

# 4.调用实例方法
xiaoming.start_game()


输出结果：
帮助信息：让僵尸进入大门
历史记录 0
小明 开始玩游戏了...

案例小结

1.实例方法 - - 方法内部需要访问实例属性

实例方法内部可以使用类名. 访问类属性

2.类方法 - - 方法内部只需要访问类属性

3.静态方法 - - 方法内部不需要访问实例属性和类属性

提问：

如果方法内部既需要访问实例属性，又需要访问类属性，应该定义成什么方法？

答案

应该定义实例方法
因为，类只有一个，在实例方法内部可以使用 类名. 访问类属性

*Heygirl

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
面向对象（6）— 多继承、多态、类方法和静态方法、类属性

继承父类的私有属性和方法1.子类对象不能在自己的方法内部，直接访问父类的私有属性或私有方法2.子类对象可以通过父类的公有方法间接访问到私有属性或私有方法私有属性、方法是对象的隐私，不对外公开，外界以及子类都不能直接访问私有属性、方法通常用于做一些内部的事情class A: def __init__(self): self.num1 = 100 self.__num2 = 200 def __test(self): p
复制链接

扫一扫