15.封装,继承,多态

可以使程序更加灵活.
1.封装
优势:提高了代码的安全性,外部无法直接修改对象内部数据,只能通过接口进行访问和操作
将数据和操作封装成对象,更加模块化和可复用.其他部分代码可以通过调用对象的接口使用.无需关心内部的具体实现.
降低耦合性,对象之间通过接口进行通信,而不是直接访问和修改其内部状态.更灵活金额易于维护.
封装的实现:
封装在类中,公有属性和方法,可以正常访问
私有属性和方法,__双下划表示私有,外部不能直接访问,必须通过接口
受保护的属性和方法: 单下划线,外部可以访问.

class Student:

    def __init__(self, name, age):
        self.__name = name
        self.__age = age

    def introduce(self):
        print(f'我是{self.__name},{self.__age}岁')

    def get_name(self):
        return self.__name

    def get_age(self):
        return self.__age

    def set_name(self, name):
        self.__name = name

    def set_age(self, age):
        self.__age = age


stu = Student('王五', 20)
stu.set_name('李四')
new_name = stu.get_name()
print(new_name)

stu.set_age(25)
new_age = stu.get_age()
print(new_age)

私有实际上变量改了一个名字
2.继承
子类从父类继承属性和方法.
优势:
1.代码重用,避免重复编写代码,提高代码的重用性,
2.代码组织和扩展,继承可以使代码的层次结构更加清晰,子类直接从父类继承,再写特定的.
3.复杂性降低.
class 子类(父类), 单继承 class 子类(父类)多继承
子类可以重写父类的方法,即在子类中重新实现与父类相同的方法

class Singer():

    def __init__(self, name):
        self.name = name

    def sing(self):
        print(f'{self.name}正在唱歌')


class Dancer():

    def __init__(self, name):
        self.name = name

    def dance(self):
        print(f'{self.name}正在跳舞')


class Person(Singer, Dancer):

    pass

person = Person('张三')
person.sing()
person.dance()

super()用于调用父类的成员,可以在子类中调用父类的成员

class Person(Singer, Dancer):
    
    def __init__(self, name, age):
    	#super().__init__(name)
        #Singer.__init__(self, name)
        super(Singer, self).__init__(name)

mro
方法解析顺序,链
子类.mro()
print(SingerDancer.mro())
继承与自定义异常

class LessEighteenError(ValueError):
    pass


def check_age(age):
    if age < 18:
        raise LessEighteenError('年龄小于18岁,禁止注册')
    else:
        pass
    print('年龄大于等于18岁,可以注册')


try:
    age = input('请输入年龄: ')
    check_age(int(age))
except Exception as e:
    print(e)

多继承实际上是按照mro的顺序进行的,
一般不建议用很复杂的.
mixin 混合
功能要单一,
不要跟真正的基类有关联,mixin的类需要可以和任意类组合
基类要在脱离了mixin的类,也可以单独完成初始化
再mixin的类中不要使用super
3.多态
允许不同的对象对相同的方法做出不同的响应.
同一个方法名可以在不同的类中实现,并且根据对象的类型调用不同类的方法

class Dog:

    def say(self):
        print('汪汪汪')


class Cat:

    def say(self):
        print('喵喵喵')


# animal = Dog()
animal = Cat()
animal.say()

抽象基类,允许定义抽象类和抽象方法,从而可以规范子类的行为,抽象基类并不能被实例化,只能用于继承,子类必须实现抽象基类中定义的所有方法

class Animal:
    def say(self):
        raise NotImplemented


class Dog:

    def say(self):
        print('汪汪汪')


class Cat:
    pass
    # def say(self):
    #      print('喵喵喵')


# animal = Dog()
animal = Cat()
animal.say()

abc模块
from abc import ABCMeta, abstractmethod
(metclass=ABCmeta):
元类创建类的类
使用抽象基类的作用:
规范子类行为,允许定义一组接口或者方法,子类必须实现这些方法
约束方法命名:强制子类必须事先指定的方法,避免方法名拼写错误,或者忘记实现方法的问题.
多态性支持,抽象基类实现了多态性,可以在使用抽象基类的地方接收不同的子类对象,实现更灵活的代码设计
文档化接口: 可以帮助文档化接口,让开发者了解哪些方法是必须实现的,哪些是可选的.

from abc import ABCMeta, abstractmethod

class Animal(metaclass=ABCMeta):
    def say(self):
        raise NotImplemented


@abstractmethod
class Cat:
    pass

animal = Cat()
animal.say()