Python学习之旅--封装、继承、多态

最新推荐文章于 2024-11-02 16:28:26 发布

赵jc

最新推荐文章于 2024-11-02 16:28:26 发布

阅读量211

点赞数

分类专栏： Python 文章标签： python 开发语言后端

本文链接：https://blog.csdn.net/qq_45661125/article/details/122210583

版权

Python 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

1, 私有属性

目的: 知道私有属性方法的作用, 格式

操作流程

"""
私有属性:
    1,格式: self.__变量 = 值
    2,私有属性在类的外部不能访问
    3,在类的内部可以访问

私有方法:
    1,格式: def __方法名(参数)
    2,私有方法在类的外部不能访问
    3,在类的内部可以访问

作用:
    1, 隐藏内部的实现,封装的一种体现
    2, 提高代码的安全性
"""

#1,动物类
class Animal(object):
    def __init__(self,name,age):
        self.name = name
        self.__age = age # 私有属性

    def get_age(self):
        self.__age += 1
        return self.__age

    def __show_info(self): # 私有方法
        return f"{self.name},{self.__age}"

    def __str__(self):
        return self.__show_info()

ani = Animal("哈巴狗",18)
# print(ani.name,ani.get_age())
# print(ani.__show_info())
print(ani)

2,继承

目的: 知道继承的作用,和编写格式

操作流程

#1, 员工类
class Employee(object):
    #1,通用属性
    def __init__(self,name,id):
        self.name = name
        self.id = id

    #2,输出对象的属性
    def __str__(self):
        return self.name

    #3,自我介绍方法
    def show_info(self):
        print("我是{},工号是{}".format(self.name,self.id))

#2,定义讲师类,继承自员工类
class JiangShi(Employee):
    pass

#3,定义班主任类,继承自员工类
class BanZhuRen(Employee):
    pass

#4,创建对象
js = JiangShi("王宝强","001")
js.show_info()

bzr = BanZhuRen("林志玲","002")
bzr.show_info()

3,多继承

目的: 知道多继承的写法和调用顺序

操作流程

#1, 父亲类
class Father(object):
    def __init__(self,name,age):
        self.name = name
        self.age = age
        print("Father name = {}".format(name))

    def give_money(self):
        print("亲爹给钱你用")


# 2, 干爹类
class GanFather(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age
        print("GanFather name = {}".format(name))

    def give_money(self):
        print("干爹给钱你用")

    def play_game(self):
        print("玩大保健的游戏")

#3, 儿子类,同时继承自父类,干爹类
class Son(Father,GanFather):
    pass

son = Son("儿子",18)
son.give_money() # 先在自己的类里面找 -> 找左边的父类 -> 依次向右寻找,找到为止,找不到报错
son.play_game()
# son.hahaha()

4,方法重写

目的: 知道重写的目的, 以及重写的格式

操作流程

"""
方法重写: 当父类方法满足不了子类要求的时候进行重写
重写注意点: 重写的时候,子类方法的名称和参数和父类保持一致
"""""
#1, 父亲类
class Father(object):
    def __init__(self,name,age):
        self.name = name
        self.age = age
        print("Father name = {}".format(name))

    def give_money(self):
        print("亲爹给钱你用")


# 2, 干爹类
class GanFather(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age
        print("GanFather name = {}".format(name))

    def give_money(self):
        print("干爹给钱你用")

    def play_game(self):
        print("玩大保健的游戏")

#3, 儿子类,同时继承自父类,干爹类
class Son(Father,GanFather):

    # 方法重写
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex
        print("=============son=======")

    def __str__(self):
        return "我是{},性别是{},今年{}岁了".format(self.name,self.sex,self.age)

    # 方法重写
    def give_money(self):
        print("我自己给钱自己用")

#4,创建对象使用
son = Son("王宝强",18,"Man")
son.give_money()

5,多层继承

目的: 知道多层继承的格式和方法调用顺序

操作流程

#1, 祖父类
class GranderFather(object):
    def show(self):
        print("=======GranderFather=======")

#2, 父亲类
class Father(GranderFather):
    def show(self):
        print("=======Father=======")
    
#3, 父亲类
class Son(Father):
    def show(self):
        print("=======Son=======")

# 测试
son = Son()
son.show()

6,super

目的: 知道super的作用, 以及如何去调用父类的属性方法
super作用: 用来初始化父类属性, 用来调用父类方法

操作流程

#1, 动物类
class Animal(object):
    def __init__(self,name):
        self.name = name

    def eat(self):
        print("动物吃饭")

#2,狗类
class Dog(Animal):
    def __init__(self,name,color):
        # 如果父类中有对应的属性可以继承子类只需要调用就可以了,不需要自己写
        # self.name = name
        super(Dog, self).__init__(name) # 替换上面这一句话

        self.color = color

    def eat(self):
        # 使用super调用父类方法,保留了父类的方法
        super(Dog, self).eat()
    
        # 增加了自己额外的方法
        print("狗吃骨头")

# 使用
dog = Dog("旺财","绿色")
print(dog.name,dog.color)
dog.eat()

7, 多态

目的: 知道多态的特点和作用

操作流程

"""
多态特点:
    1, 必须有继承关系
    2, 子类必须重写父类的方法
    
好处:
    1, 不关心业务逻辑的实现
    2, 增加了程序的扩展性
    
面向对象的三大特性:
1, 继承
2, 封装(私有属性,私有方法)
3, 多态
"""""
#1,父亲类
class Father(object):
    def cure(self):
        print("....")
        print("父亲给病人看病")

# 2,父亲类
class Son(Father):
    def cure(self):
        print(".......")
        print("儿子给病人看病")

#3, 需求
def see_docter(docter):
    # 不关心docter传递的是什么进来的,只要能看病就可以了
    docter.cure()

#4,测试
# see_docter(Father())
see_docter(Son())