day16一起来学习“面向对象特性"

面向对象的特性

继承的概念
单继承
多继承
⼦类重写⽗类的同名属性和⽅法
⼦类调⽤⽗类的同名属性和⽅法
多层继承
super()
私有属性和私有⽅法

继承的概念

⽣活中的继承，⼀般指的是⼦⼥继承⽗辈的财产。

Python⾯向对象的继承指的是多个类之间的所属关系，即⼦类默认继承⽗类的所有属性和⽅法，具体如下

class A(object):
    def __init__(self):
        self.num = 1

    def demo(self):
        print(self.num)


class B(A):
    pass

result = A()
result.demo()

在Python中，所有类默认继承object类，object类是顶级类或基类；其他⼦类叫做派⽣类。

单继承

枯荣大师只有一个弟子叫张三，他马上要与世长辞，现在，他想把自己的功夫传授给自己唯一的关门弟子

代码实现

# -*- coding:utf-8 -*-
class Master(object):
    def __init__(self):
        self.kunfu = "一阳指，狮吼功，六脉神剑"

    def demo(self):
        print(f"枯荣大师的功夫：{self.kunfu}")

class Apprentice(Master):
    pass

func = Apprentice()
print(func.kunfu)
func.demo()

多继承

张三不满足枯荣大师的功夫，现在他又拜在了张三丰的门下，想学太极

# -*- coding:utf-8 -*-

class Kurong_Master(object):
    def __init__(self):
        self.kunfu_kurong = "一阳指，狮吼功，六脉神剑"

    def demo_kurong(self):
        print(f"枯荣大师的功夫：{self.kunfu}")

class Sanfeng_Master(object):
    def __init__(self):
        self.kunfu_sanfeng = "太极"

    def demo_sanfeng(self):
        print(f"张三丰的功夫：{self.kunfu}")


class Apprentice(Kurong_Master,Sanfeng_Master):
    def __init__(self):
        Kurong_Master.__init__(self)
        Sanfeng_Master.__init__(self)

func = Apprentice()
print(func.kunfu_kurong)
print(func.kunfu_sanfeng)

所谓多继承意思就是⼀个类同时继承了多个⽗类。

⼦类重写⽗类⽅法和属性

张三觉得师傅的功夫都有一定的不足，决定改善师傅的功夫

# -*- coding:utf-8 -*-

class Kurong_Master(object):
    def __init__(self):
        self.kunfu_kurong = "六脉神剑"

    def demo_kurong(self):
        print(f"枯荣大师的功夫：{self.kunfu}")

class Sanfeng_Master(object):
    def __init__(self):
        self.kunfu_sanfeng = "太极"

    def demo_sanfeng(self):
        print(f"张三丰的功夫：{self.kunfu}")


class Apprentice(Kurong_Master,Sanfeng_Master):
    def __init__(self):
        Kurong_Master.__init__(self)
        Sanfeng_Master.__init__(self)
        self.kunfu_kurong = "万剑归宗"
        self.kunfu_sanfeng = "醉拳"

    def demo_zhangsan(self):
        print(f"张三自己研制的功夫{self.kunfu_kurong}---{self.kunfu_sanfeng}")

func = Apprentice()

func.demo_zhangsan()

⼦类调⽤⽗类的⽅法和属性

张三在两位师傅功夫的基础上创建了新的功夫，但是他想在使用自己功夫的时候也可以用到师傅的功夫

同名的情况下，只能使用子类里面的方法

# -*- coding:utf-8 -*-

class Kurong_Master(object):
    def __init__(self):
        self.kunfu_kurong = "六脉神剑"

    def demo_kurong(self):
        print(f"枯荣大师的功夫：{self.kunfu_kurong}")

class Sanfeng_Master(object):
    def __init__(self):
        self.kunfu_sanfeng = "太极"

    def demo_sanfeng(self):
        print(f"张三丰的功夫：{self.kunfu_sanfeng}")


class Apprentice(Kurong_Master,Sanfeng_Master):
    def __init__(self):
        self.kunfu_kurong = "万剑归宗"
        self.kunfu_sanfeng = "醉拳"

    def demo_zhangsan(self):
        print(f"张三自己研制的功夫{self.kunfu_kurong}---{self.kunfu_sanfeng}")

    def demo_zhangsan_kurong(self):
        Kurong_Master.__init__(self)
        Kurong_Master.demo_kurong(self)

    def demo_zhangsan_sanfeng(self):
        Sanfeng_Master.__init__(self)
        Sanfeng_Master.demo_sanfeng(self)


func = Apprentice()
func.demo_zhangsan()
func.demo_zhangsan_kurong()
func.demo_zhangsan_sanfeng()

多层继承

多年之后，张三老了，想把自己的毕生所学，传给李四

# -*- coding:utf-8 -*-

class Kurong_Master(object):
    def __init__(self):
        self.kunfu_kurong = "六脉神剑"

    def demo_kurong(self):
        print(f"枯荣大师的功夫：{self.kunfu_kurong}")

class Sanfeng_Master(object):
    def __init__(self):
        self.kunfu_sanfeng = "太极"

    def demo_sanfeng(self):
        print(f"张三丰的功夫：{self.kunfu_sanfeng}")


class Apprentice(Kurong_Master,Sanfeng_Master):
    def __init__(self):
        self.kunfu_kurong = "万剑归宗"
        self.kunfu_sanfeng = "醉拳"

    def demo_zhangsan(self):
        print(f"张三自己研制的功夫{self.kunfu_kurong}---{self.kunfu_sanfeng}")

    def demo_zhangsan_kurong(self):
        Kurong_Master.__init__(self)
        Kurong_Master.demo_kurong(self)

    def demo_zhangsan_sanfeng(self):
        Sanfeng_Master.__init__(self)
        Sanfeng_Master.demo_sanfeng(self)

class Disciple(Apprentice):
    pass

func = Disciple()
func.demo_zhangsan_sanfeng()
func.demo_zhangsan_kurong()
func.demo_zhangsan()

super()

调用父类方法

# -*- coding:utf-8 -*-

class Kurong_Master(object):
    def __init__(self):
        self.kunfu_kurong = "六脉神剑"

    def demo_kurong(self):
        print(f"枯荣大师的功夫：{self.kunfu_kurong}")

class Sanfeng_Master(object):
    def __init__(self):
        self.kunfu_sanfeng = "太极"

    def demo_sanfeng(self):
        print(f"张三丰的功夫：{self.kunfu_sanfeng}")


class Apprentice(Kurong_Master,Sanfeng_Master):
    def __init__(self):
        self.kunfu_kurong = "万剑归宗"
        self.kunfu_sanfeng = "醉拳"

    def demo_zhangsan(self):
        print(f"张三自己研制的功夫{self.kunfu_kurong}---{self.kunfu_sanfeng}")

    def demo_sanfeng_kurong(self):
        # 写法一
        # Kurong_Master.__init__(self)
        # Kurong_Master.demo_kurong(self)
        # Sanfeng_Master.__init__(self)
        # Sanfeng_Master.demo_sanfeng(self)
        # ⽅法2 super().函数()

        # super().__init__()
        # super().demo_kurong()
        
        super().demo_sanfeng()

func = Apprentice()
func.demo_sanfeng_kurong()

私有权限

定义私有属性和方法

在Python中，可以为实例属性和⽅法设置私有权限，即设置某个实例属性或实例⽅法不继承给⼦类。

枯荣大师还有一招狮吼功，不想传授给他的徒弟，这个时候，可以吧狮吼功这个属性设置为私有

设置私有权限的⽅法：在属性名和⽅法名前⾯加上两个下划线 __。

# -*- coding:utf-8 -*-

class Kurong_Master(object):
    def __init__(self):
        self.kunfu_kurong = "六脉神剑"
        self.__kurong = "狮吼功"

    def demo_kurong(self):
        print(f"枯荣大师的功夫：{self.kunfu_kurong}")

    def __demo_kurong(self):
        print(f"枯荣大师的功夫：{self.__kurong}")

class Sanfeng_Master(object):
    def __init__(self):
        self.kunfu_sanfeng = "太极"

    def demo_sanfeng(self):
        print(f"张三丰的功夫：{self.kunfu_sanfeng}")


class Apprentice(Kurong_Master,Sanfeng_Master):
    def __init__(self):
        self.kunfu_kurong = "万剑归宗"
        self.kunfu_sanfeng = "醉拳"

    def demo_zhangsan(self):
        print(f"张三自己研制的功夫{self.kunfu_kurong}---{self.kunfu_sanfeng}")

    # def demo_sanfeng_kurong(self):

        # Kurong_Master.__init__(self)
        # Kurong_Master.demo_kurong(self)
        # Sanfeng_Master.__init__(self)
        # Sanfeng_Master.demo_sanfeng(self)


func = Apprentice()
func.__demo_kurong()  # 报错

私有属性和私有⽅法只能在类⾥⾯访问和修改。

获取和修改私有属性值

在Python中，⼀般定义函数名 get_xx ⽤来获取私有属性，定义 set_xx ⽤来修改私有属性值。

# -*- coding:utf-8 -*-

class Kurong_Master(object):
    def __init__(self):
        self.kunfu_kurong = "六脉神剑"
        self.__kurong = "狮吼功"

    def demo_kurong(self):
        print(f"枯荣大师的功夫：{self.kunfu_kurong}")

    def get_demo(self):
        return self.__kurong

    def set_demo(self):
        self.__kurong = "一阳指"


class Sanfeng_Master(object):
    def __init__(self):
        self.kunfu_sanfeng = "太极"

    def demo_sanfeng(self):
        print(f"张三丰的功夫：{self.kunfu_sanfeng}")


class Apprentice(Kurong_Master, Sanfeng_Master):
    def __init__(self):
        self.kunfu_kurong = "万剑归宗"
        self.kunfu_sanfeng = "醉拳"

    def demo_zhangsan(self):
        print(f"张三自己研制的功夫{self.kunfu_kurong}---{self.kunfu_sanfeng}")


func = Kurong_Master()
print(func.get_demo())
func.set_demo()
print(func.get_demo())

面向对象的三大特征

封装
将属性和⽅法书写到类的⾥⾯的操作即为封装
封装可以为属性和⽅法添加私有权限
继承
⼦类默认继承⽗类的所有属性和⽅法
⼦类可以重写⽗类属性和⽅法
多态
传⼊不同的对象，产⽣不同的结果

多态

多态指的是⼀类事物有多种形态

定义：多态是⼀种使⽤对象的⽅式，⼦类重写⽗类⽅法，调⽤不同⼦类对象的相同⽗类⽅法，可以产⽣不同的执⾏结果

好处：调⽤灵活，有了多态，更容易编写出通⽤的代码，做出通⽤的编程，以适应需求的不断变化！
实现步骤：

定义⽗类，并提供公共⽅法

定义⼦类，并重写⽗类⽅法

传递⼦类对象给调⽤者，可以看到不同⼦类执⾏效果不同

代码实现

# -*- coding:utf-8 -*-

class Father(object):
    def func(self):
        print("下达命令：出兵剿匪")


class Son1(Father):
    def func(self):
        print("正面迎击")


class Son2(Father):
    def func(self):
        print("背后突袭")

class Main(object):
    def func_demo(self,demo):
        demo.func()


demo1 = Son1()
demo2 = Son2()

func = Main()
func.func_demo(demo1)
func.func_demo(demo2)

类属性和实例属性

类属性就是类对象所拥有的属性，它被该类的所有实例对象所共有。

类属性可以使⽤类对象或实例对象访问

# -*- coding:utf-8 -*-

class Demo(object):
    num = 10
	def __init__(self):
        self.number = 10
func = Demo()
print(Demo.num)
print(func.num)

修改类属性

类属性只能通过类对象修改，不能通过实例对象修改，如果通过实例对象修改类属性，表示的是创建了⼀个实例属性。

# -*- coding:utf-8 -*-

class Demo(object):
    num = 10

func = Demo()
func1 = Demo()
Demo.num = 20

print(Demo.num)
print(func.num)
# 不能通过对象修改属性，如果这样操作，实则是创建了⼀个实例属性
func.num = 30
print(Demo.num)
print(func.num)
print(func1.num)

类方法和静态方法

了解即可

需要⽤装饰器 @classmethod 来标识其为类⽅法，对于类⽅法，第⼀个参数必须是类对象，⼀般以cls 作为第⼀个参数。

# -*- coding:utf-8 -*-

class Demo(object):
    __num = 10

    @classmethod
    def get_num(cls):
        return cls.__num


func = Demo()
print(func.get_num())

静态方法

当⽅法中既不需要使⽤实例对象(如实例对象，实例属性)，也不需要使⽤类对象 (如类属性、类⽅法、创建实例等)时，定义静态⽅法

取消不需要的参数传递，有利于减少不必要的内存占⽤和性能消耗

class Demo(object):

    @staticmethod
    def get_info():
        print("我是一个静态方法")

func = Demo()
func.get_info()

作业

编写两个老师类,

老师类一：琴棋书画，样样精通

老师类二：文韬武略，他啥都会

编写学生类继承两个老师的方法

posted @ 2025-04-12 10:40 Lovcsy 阅读(9) 评论(0) 收藏举报

刷新页面返回顶部

kk-sy