Python——面向对象基础（上）：析构、继承、类and实例属性和方法、多态（day08）

最新推荐文章于 2024-06-03 22:59:47 发布

清园暖歌

最新推荐文章于 2024-06-03 22:59:47 发布

阅读量352

点赞数 1

分类专栏： Python 文章标签： python 开发语言人工智能

本文链接：https://blog.csdn.net/qq_47941078/article/details/125370412

版权

Python 专栏收录该内容

19 篇文章 2 订阅

订阅专栏

在python中展现面向对象的三大特征:
封装、继承、多态
封装:指的是把内容封装到某个地方，便于后面的使用
他需要:
把内容封装到某个地方
从另外一个地方去调用被封装的内容
对于封装来说其实就是使用初始化构造方法将内容封装到对象中，然后通过对象直接或者self来获取被封装的内容

继承: 和现实生活当中的继承是一样的：也就是子可以继承父的内容【属性和行为】（爸爸有的儿子都有，相反儿子有的爸爸不一定有）
所以对于面向对象的继承来说其实就是将多个类共有的方法提取到父类中子类仅需继承父类而不必一一去实现
这样就可以极大的提高效率减少代码的重复编写，精简代码的层级结构便于拓展

class 类名(父类):
'''
子类就可以继承父类中公共的属性和方法
'''
pass

为什么要使用静态方法呢
# 由于静态方法主要来存放逻辑性的代码，本身和类以及实例对象没有交互，
# 也就是说，在静态方法中，不会涉及到类中方法和属性的操作
# 数据资源能够得到有效的充分利用

从方法定义的形式可以看出来
1.类方法的第一个参数是类对象 cls 进而去引用类对象的属性和方法必须用装饰器 @classmethod来修饰
2.实例方法的第一个参数必须是self，通过这个self 可以去引用类属性或者实例属性，若存在相同名称实例属性和类属性的话，实例属性的优先级最高
3.静态方法不需要定义额外的参数，若是要引用属性的话则可以通过类对象或者是实例对象去引用即可必须用装饰器 @staticmethod来修饰

多态：顾名思义就是多种状态、形态，就是同一种行为对于不同的子类【对象】有不同的行为表现

要想实现多态必须的有两个前提需要遵守：
1、继承：多态必须发生在父类和子类之间
2、重写: 子类重写父类的方法

多态有什么用:
增加程序的灵活性
增加程序的拓展性

一、析构方法

class Animal:
    def __init__(self,name):
        self.name=name
        print('这是构造初始化方法')
        pass
    def __del__(self):
        # 主要的应用就是来操作 对象的释放  一旦释放完毕  对象便不能在使用
        print('当在某个作用域下面 没有被使用【引用】的情况下 解析器会自动的调用此函数 来释放内存空间')
        print('这是析构方法')
        print('%s 这个对象 被彻底清理了 内存空间也释放了'%self.name)
    pass

cat=Animal('小花猫')
# del cat  #手动的去清理删除对象  会指定__del__函数
print(cat.name)
input('程序等待中.....')
# print('*'*40)
# dog=Animal('柯基小狗')

没写del方法，程序自己也会有，程序运行结束后自动调用并释放内存

二、单继承

class Animal:
    def  eat(self):
        '''
        吃
        :return:
        '''
        print('吃饭了')
        pass
    def drink(self):
        '''
        喝
        :return:
        '''
        pass

class Dog(Animal): #继承了Animal 父类 此时dog就是子类
    def wwj(self):
        '''
        子类独有的实现
        :return:
        '''
        print('小狗汪汪叫')
    pass
class Cat(Animal):
    def mmj(self):
        '''
         子类独有的实现
        :return:
        '''
        print('小猫喵喵叫')
    pass

d1=Dog()
d1.eat() #具备了吃的行为  是继承了父类的行为
d1.wwj()
print('**************cat 的行为**********************')
c1=Cat()
c1.eat()
c1.mmj()

三、多继承

可以将类C继承别的类方法不变，如果是广度优先则会输出类C中的方法也就是C.eat.深度优先的会就会输出类D的方法即D.eat.结果是D.eat.所以是深度优先

这里遵从的虽然是广度优先，不是深度优先，但是输出C还是因为类C将类D中的eat方法重写了导致类B继承D类的eat方法变成了C.eat

class shenxian:
    def fly(self):
        print("神仙都会飞")
    pass
class Monkey:
    def chitao(self):
        print('猴子喜欢吃桃')
    pass
class Sunwukong(shenxian,Monkey): #即使神仙  同时也是猴子
    pass

# swk=Sunwukong()
# swk.chitao()
# swk.fly()
# 问题是  当多个父类当中存在相同方法的时候  应该去调用哪一个呢
class D(object):
    def eat(self):
        print('D.eat')
        pass
    pass
class C(D):
    def eat(self):
        print('C.eat')
        pass
    pass
class B(D):
    pass
class A(B,C):
    pass
a=A()
a.eat()
print(A.__mro__) #可以显示类的依次继承关系
#在执行eat的方法时 查找方法的顺序是
# 首先到A里面去查找  如果A中没有 则继续的去B类中去查找 如果B中没有
# 则去C中查找 如果C类中没有 则去D类中去查找，如果还是没有找到 就会报错
# A-B-C-D  也是继承的顺序

四、间接继承

class GrandFather:
    def eat(self):
        print('吃的 方法')
        pass
    pass
class Father(GrandFather):
    def eat(self): #因为父类中已经存在这个的方法 在这里相当于 方法重写【方法覆盖了】
        print('爸爸经常吃海鲜')
    pass

class Son(Father):
    pass

son=Son()
print(Son.__mro__)
son.eat() #此方法 是从GrandFather继承过来的

一般不超多三级传递。

五、重写（方法覆盖）和调用父类方法

# 所谓重写，就是子类中，有一个和父类相同名字的方法，在子类中的方法会覆盖掉父类中同名的方法
# 为什么要重写， 父类的方法已经不满足子类的需要，那么子类就可以重写父类或者完善父类的方法
class Dog:
    def __init__(self,name,color):
        self.name=name
        self.color=color

    def bark(self):
        print('汪汪叫....')
        pass
    pass
class kejiquan(Dog):
    def __init__(self,name,color):#属于重写父类的方法
        # 针对这种需求  我们就需要去调用父类的函数了
        # Dog.__init__(self,name,color) #手动调用  调用父类的方法了 执行完毕就可以具备name,color这两个实例属性了\
        super().__init__(name,color) #super是自动找到父类 进而调用方法, 假设继承了多个父类，那么会按照顺序逐个去找 然后在调用
        # 这样写还可以拓展其他的属性，如下
        self.height=90
        self.weight=20
        pass
    def __str__(self):
        return '{}的颜色会{} 它的身高是{}cm 体重是:{}'.format(self.name,self.color,self.height,self.weight
                                                  )
    def bark(self): #属于重写类的方法
        super().bark() #调用父类的方法
        print('叫的跟神一样')
        print(self.name)
    pass

kj=kejiquan('柯基犬','红色')
kj.bark()
print(kj)

六、类属性和实例属性

# 属性：类属性和实例属性
# 类属性 就是类对象所拥有的属性
class Student:
    name='李明' #属于类属性  就是student类对象所拥有的
    def __init__(self,age):
        self.age=age #实例属性
        pass
    @staticmethod
    def aaa(x,y):
        print(x+y)
    pass

Student.name='李易峰' #通过类对象去修改数据 可以修改的  因为name的所拥有的权利属于类对象

lm=Student(18)
print(lm.name) #通过实例对象去访问类属性
# lm.name='刘德华'  #通过实例对象 对类属性进行修改 可以吗? 不可以的，只是增加一个实例属性，不能修改类属性
print(lm.name)
print(lm.age)
Student.aaa(4,6)
print('---------xh的数据---------------')
xh=Student(28)
print(xh.name)
print(xh.age)
print('---------通过类对象 student 去访问name---------------')
# print(Student.name)  如 类名.属性名 形式去访问
# print(Student.age)
# 小结
# 类属性是可以 被类对象和实例对象共同访问使用的
# 实例属性只能由实例对象所访问

调用时，现在自己这个实例对象中找，没有再去上一级类中去找，类对象中也没有时会报错

通过：类名.属性名的形式也可以访问类属性

七、类方法和静态方法

（1）类方法

（2）静态方法

声明静态方法后，就没必要通过实例对象调用了，即使可以这样调用

# 为什么要使用静态方法呢
# 由于静态方法主要来存放逻辑性的代码，本身和类以及实例对象没有交互，
# 也就是说，在静态方法中，不会涉及到类中方法和属性的操作
# 数据资源能够得到有效的充分利用

class  People:
    country='china'
    #类方法 用 classmethod 来进行修饰
    @classmethod
    def get_country(cls):
        return cls.country #访问类属性
        pass
    @classmethod
    def change_country(cls,data):
        cls.country=data #修改类属性的值  在类方法中
        pass
    @staticmethod
    def getData():
        return People.country  #通过类对象去引用
        pass
    @staticmethod
    def add(x,y):
        return x+y
        pass


print(People.add(10,56)) #带有参数的静态方法

# print(People.getData())

# print(People.get_country()) #通过类对象去引用
p=People()
print(p.getData()) #注意 一般情况下 我们不会通过实例对象去访问静态方法
# print('实例对象访问 %s'%p.get_country())
# print('-----------------修改之后---------------------------')
# People.change_country('英国')
# print(People.get_country()) #通过类对象去引用

# 为什么要使用静态方法呢
# 由于静态方法主要来存放逻辑性的代码，本身和类以及实例对象没有交互，
# 也就是说，在静态方法中，不会涉及到类中方法和属性的操作
# 数据资源能够得到有效的充分利用

# demo  返回当前的系统时间
import  time # 引入第三方的时间模块
class TimeTest:
    def __init__(self,hour,min,second):
        self.hour=hour
        self.min = min
        self.second = second

    @staticmethod
    def showTime():
        return time.strftime("%H:%M:%S",time.localtime())
        pass
    pass

print(TimeTest.showTime())
t=TimeTest(2,10,15)
print(t.showTime()) #没有必要通过这种方式去访问 静态方法

八、多态

# 案例演示
class Animal:
    '''
    父类【基类】
    '''
    def say_who(self):
        pri# 案例演示
class Animal:
    '''
    父类【基类】
    '''
    def say_who(self):
        print('我是一个动物....')
        pass
    pass
class Duck(Animal):
    '''
      鸭子类 【子类】 派生类
    '''
    def say_who(self):
        '''
        在这里重写父类的方法
        :return:
        '''
        print('我是一只漂亮的鸭子')
        pass
    pass
class Dog(Animal):
    '''
     小狗类 【子类】 派生类
    '''
    def say_who(self):
        print('我是一只哈巴狗')
        pass
    pass

class Cat(Animal):
    '''
        小猫类 【子类】 派生类
    '''
    def say_who(self):
        print('我是一只小花猫 喵喵喵喵')
        pass
    pass


class Bird(Animal):
    '''
    新增鸟类 无需修改原来的代码
    '''
    def say_who(self):
        print('我是一只黄鹂鸟')
    pass

class People:
    def say_who(self):
        print('我是人类')
    pass


class student(People):
    def say_who(self):
        print('我是一年级的学习 张明')
    pass

def commonInvoke(obj):
    '''
    统一调用的方法
    :param obj: 对象的实例
    :return:
    '''
    obj.say_who()

# duck1=Duck()
# duck1.say_who()
# dog1=Dog()
# dog1.say_who()
# cat1=Cat()
# cat1.say_who()

listObj=[Duck(), Dog(),Cat(),Bird(),student()]
for item in listObj:
    '''
     循环去调用函数
    '''
    commonInvoke(item)


nt('我是一个动物....')
        pass
    pass
class Duck(Animal):
    '''
      鸭子类 【子类】 派生类
    '''
    def say_who(self):
        '''
        在这里重写父类的方法
        :return:
        '''
        print('我是一只漂亮的鸭子')
        pass
    pass
class Dog(Animal):
    '''
     小狗类 【子类】 派生类
    '''
    def say_who(self):
        print('我是一只哈巴狗')
        pass
    pass

class Cat(Animal):
    '''
        小猫类 【子类】 派生类
    '''
    def say_who(self):
        print('我是一只小花猫 喵喵喵喵')
        pass
    pass


class Bird(Animal):
    '''
    新增鸟类 无需修改原来的代码
    '''
    def say_who(self):
        print('我是一只黄鹂鸟')
    pass

class People:
    def say_who(self):
        print('我是人类')
    pass


class student(People):
    def say_who(self):
        print('我是一年级的学习 张明')
    pass

def commonInvoke(obj):
    '''
    统一调用的方法
    :param obj: 对象的实例
    :return:
    '''
    obj.say_who()

# duck1=Duck()
# duck1.say_who()
# dog1=Dog()
# dog1.say_who()
# cat1=Cat()
# cat1.say_who()

listObj=[Duck(), Dog(),Cat(),Bird(),student()]
for item in listObj:
    '''
     循环去调用函数
    '''
    commonInvoke(item)