Python编程进阶——面向对象2

---

1.继承:顾名思义 拿来吧你 依法接受

# 面向对象三个特征:封装、继承、多态
# 封装在一个类中 用的时候 实例化 对象名=类() 方法 属性
# 生活中：子女继承父母的基因 子女继承父母的财产
# 面向对象中：子类继承父类的属性和方法 儿子 父亲有钱
# 单继承 多继承
# 作用: 实现代码的重用，相同的代码不需要重复编写

# 两个类
# 动物类：吃 睡
# 狗类：吃 睡 跑 叫
# 封装 写 动物类 狗类 动物类 吃睡跑叫

class Animal:
    def eat(self):
        print('动物有吃的方法')

    def sleep(self):
        print('动物有睡的方法')

#不写吃和睡 继承
class Dog(Animal):
    def run(self):
        print('动物有跑的方法')

    def bark(self):
        print('动物有叫的方法')

# 可以 正常逻辑
ergou=Dog()
ergou.eat()
ergou.sleep()
ergou.run()
ergou.bark()

# 继承可以直接享用父类的方法，不需要再次开发
# 子类按照自己的需求，封装自己的方法

# 扩展专业术语
# Dog类是Animal类的 子类 Animal类是Dog类的父类 Dog类从Animal类 继承
# Dog类是Animal类的派生类 Animal类是Dog类的基类 Dog类从Animal类进行派生

# 狗类下面可以还有子类吗？可以有子类
# 继承可以一直继承下去
# A-B-C-D d具有所有父类的特征 单继承

class Animal:
    def eat(self):
        print('动物有吃的方法')

    def sleep(self):
        print('动物有睡的方法')

#不写吃和睡 继承
class Dog(Animal):
    def run(self):
        print('动物有跑的方法')

    def bark(self):
        print('动物有叫的方法')

class GodDog(Dog):
    def fly(self):
        print('啸天狗会飞')

# 哮天犬具有了所有父类的特征
xtq = GodDog()
xtq.eat()
xtq.sleep()
xtq.run()
xtq.bark()
xtq.fly()

class CommonDog(Dog):
    def catch(self):
        print('会抓老鼠')

# 问题:定义一个普通狗继承狗类 普通狗会有哪些方法?
# 除了会飞都有
# 没有会飞是为什么？没有继承 Dog类 2个儿子 1个儿子 天狗 1个儿子 普通狗
pt = CommonDog()
pt.run()
pt.sleep()

1.1多继承

# 能拥有两个爸爸吗? 多继承 有一个爸爸 有一个妈妈
# 可以多继承,子类可以拥有多个父类，并且具有父类所有的属性和方法
# 多继承 类名(父类，父类）

class A:
    def demoA(self):
        print('这是父类A的方法')

class B:
    def demoB(self):
        print('这是父类A的方法')

class C(A,B):
    def demoC(self):
        print('这是父类A的方法')

c=C()
c.demoA()
c.demoB()
c.demoC()

# 项目中不会使用多继承
# 如果说用了多继承 那我会以哪个为主
# 你爸爸会缝衣服，你妈妈也会缝衣服 想要继承缝衣服 先继承你爸爸缝衣服的技术 还是你妈妈

# 我现在想学蛋糕技术，一个是拜人家为师，学习人家祖传秘方
# 另外一个 去培训学校培训蛋糕技术
class Master:
    def __init__(self):
        self.peifang = '师傅的蛋糕配方'

    def make_cake(self):
        print(f'使用{self.peifang}技术')

class School:
    def __init__(self):
        self.peifang = '学校的蛋糕配方'

    def make_cake(self):
        print(f'使用{self.peifang}技术,学习蛋糕')

class Tudi(Master,School):
    pass

# 是以哪个配方为主 师傅 就近
xiaxia = Tudi()
xiaxia.make_cake()

# 结论: 一个类继承多个父类，会优先继承第一个类的属性和方法

# 随着时间的流逝，徒弟蛋糕就学会了。自己创新了一个蛋糕技术。徒弟他也有制作蛋糕的方法了

class Master:
    def __init__(self):
        self.peifang = '师傅的蛋糕配方'

    def make_cake(self):
        print(f'使用{self.peifang}技术')

class School:
    def __init__(self):
        self.peifang = '学校的蛋糕配方'

    def make_cake(self):
        print(f'使用{self.peifang}技术,学习蛋糕')

class Tudi(Master,School):
    def __init__(self):
        self.peifang='自己的蛋糕配方'

    def make_cake(self):
        print(f'使用{self.peifang}技术，学习蛋糕')

xiaxia = Tudi()
xiaxia.make_cake()

# 结论:子类和父类拥有同名的方法和属性，会覆盖父类的方法和属性

# 剧情继续发展,徒弟学出来之后，自己开了一个店,结合三个口味推出了
# 师傅的配方拿出来,学校的配方拿出来，自己创建的配方拿出来 整出3个口味
# super()指向的是父类 拿到父类的属性和方法
class Master:
    def __init__(self):
        self.peifang = '师傅的蛋糕配方'

    def make_cake(self):
        print(f'使用{self.peifang}技术')

class School(Master):
    def __init__(self):
        self.peifang = '学校的蛋糕配方'

    def make_cake(self):
        print(f'使用{self.peifang}技术,学习蛋糕')
        super().__init__()
        super().make_cake()

class Tudi(School):
    def __init__(self):
        self.peifang='自己的蛋糕配方'


    def make_cake(self):
        print(f'使用{self.peifang}技术，学习蛋糕')
        super().__init__()
        super().make_cake()


xiaxia = Tudi()
xiaxia.make_cake()

2.多态:不明显 不需要继承

# 指的是同一类型的事物,有不同的形态
# 传入不同的对象,产生不同的结果 动物都会吃 吃的东西不一样
# 猪吃饭,猫吃猫粮,狗吃狗粮,动物都有吃的方法，干脆创建吃的方法
# 创建好的对象使用吃的方法 猪吃 猫吃 狗吃 吃的方法 不同的形态
class Pig:
    def eat(self):
        print('猪吃饭')

class Cat:
    def eat(self):
        print('猫吃猫粮')

class Dog:
    def eat(self):
        print('狗吃狗粮')

# 传入不同对象
def eat(a):
    a.eat()

p = Pig()
c = Cat()
d = Dog()

eat(p)
eat(c)
eat(d)

# 可以往方法里面传入一个类对象
# 调用不同类对象的相同方法名，产生不同的结果
class Dog:
    def __init__(self,name):
        self.name = name

    def work(self):
        print('看守家门')

class BigDog(Dog):
    def work(self):
        print('抓小偷')

class SmartDog(Dog):
    def work(self):
        print('缉毒')

class Person:
    def with_dog(self,obj):
        print('警员和%s一起去--'%(obj.name))
        obj.work()

xiaoqi = BigDog('神犬小七')
erha = SmartDog('二哈')

p = Person()
p.with_dog(xiaoqi)

#调用不同类对象的相同方法名，产生不同的结果

3.各种方法

# 方法里面可以传入对象进去
# 类方法:实例方法 静态方法
# 实例方法：类中的函数带有self
# 类方法:需要用到@classmethod装饰，参数命名cls
# 静态方法：需要用到@staticmethod装饰,参数没有self也没有cls 参数
class Stu:
    school = '测码课堂'
    def __init__(self,name,age):
        self.name = name
        self.age = age

    # 实例方法
    def play_ball(self):
        print(f'{self.name}打篮球')

    @classmethod
    def sport(cls):
        print(f'{cls.school}的同学都喜欢打羽毛球')

    # 静态方法内部里面没有用到类相关的内容，可以把这个函数定位成静态方法
    # 定义成静态方法可以不用对象.方法名。可以类.方法名
    # 静态方法要求，你想要把你的普通方法定义成静态方法，要求你的这个方法，不要去引用到外部的东西
    @staticmethod
    def clean():
        print('打扫卫生')

3.1实例方法

# 对象名.方法名() 类.方法名(对象名)
stu1 = Stu('cxk',18)
stu1.play_ball()
Stu.play_ball(stu1)

3.2类方法

# 类方法: 对象名.方法名() 类.方法名
# 你的整个类都可以拥有的一个方法，可以设计成类方法
stu1 = Stu('cxk',18)
stu1.sport()
Stu.sport()

3.3静态方法

# 不会访问类的任何属性或其他方法，可以设计成静态方法
Stu.clean()