python面向对象：封装，继承，多态、静态方法

对于庞大复杂的功能，一般采用面向对象的编程方式。

面向对象编程具有以下优点：
1，易维护
采用面向对象思想设计的结构，可读性高，由于继承的存在，即使改变需求，那么维护也只是在局部模块，所以维护起来是非常方便和较低成本的。
2，易扩展
通过继承，我们可以大幅减少多余的代码，并扩展现有代码的用途；
我们可以在标准的模块上（这里所谓的”标准”指程序员之间彼此达成的协议）构建我们的程序，而不必一切从头开始。这可以减少软件开发时间并提高生产效率；
,3，模块化
封装可以定义对象的属性和方法的访问级别，通过不同的访问修饰符对外暴露安全的接口，防止内部数据在不安全的情况下被修改。这样可以使程序具备更高的模块化程度，方便后期的维护和修改。
同时，面向对象语言允许一个对象的多个实例同时存在，而且彼此之间不会相互干扰；

4，方便建模
虽然面向对象语言中的对象与现实生活中的对象并不是同个概念，但很多时候，往往可以使用现实生活中对象的概念抽象后稍作修改来进行建模，这大大方便了建模的过程。

面向对象三大特点：封装，继承，多态

1. 封装的目的是为了方便调用与安全。使其更容易抽象为一个类别，使用其属性。
2. 继承的目的是父类提炼出通用的方法给子类节省代码量，子类写专用的方法。实现不更改旧代码增加新功能。继承关系规范是不能超出三层，超出说明你的代码设计不够好。
3. 多态的本质是重写父类的函数，例如：类是猫，子类重写父类猫的状态，比如原本是健康的猫，修改为受伤的猫。可以简单理解为多种状态。

封装

# 学生类
class Students:
    # 构造函数              ：后面的是限制参数输入的类型
    def __init__(self, stature: int, weight: int, age: int):
        # 身高 正常属性
        self.stature = stature
        # 体重 单下划线，代表私有属性，在类外面可以直接访问
        self._weight = weight
        # 年龄 双下划线，代表私有属性，在类外面无法直接访问
        self.__age = age
        # 函数也可以设置私有属性的函数,这里都不举例子了


# 实例化对象
n = Students(180, 160, 20)
# 正常访问类的属性：身高
print(n.stature)
print(n._weight)
# 访问私有属性：年龄 正常是无法访问的
# 实例.类名__属性
print(n._Students__age)
# 访问所有
print(n.__dict__)

继承与多态

class Father1:
    def __init__(self, martial_art=10):
        # 武力值10
        self.martial_art = martial_art

    def addition(self, a, b):
        return a + b


class Father2:
    def __init__(self, martial_art=0):
        # 武力值0
        self.martial_art = martial_art

    def addition(self, a, b):
        return a * b


# 多继承,如果属性、方法相同, 默认使用第一个父类的
# 若重写父类方法,调用时使用重写的函数方法
class Son(Father1, Father2):
    # 子类独有的方法
    def subtraction(self, a, b):
        return a - b

    # 多态
    # # 重写函数,只要函数名一样就会重写
    # def addition(self, a, b):
    #     return a / b


n = Son()
# 子类可以调用父类的属性
print(n.martial_art)
# 子类可以调用父类的方法
print(n.addition(1, 2))
# 子类独有的方法
print(n.subtraction(2, 1))

# 查看继承关系  顺序：子->父->祖父
print(Son.__mro__)

特例1

# 祖
class Father1:
    def __init__(self, martial_art=10):
        # 武力值10
        self.martial_art = martial_art

    def addition(self):
        print("武力值:", self.martial_art)


# 父
class Father2(Father1):
    def __init__(self, martial_art=9):
        # 武力值9
        self.martial_art = martial_art

    def addition(self):
        print("武力值:", self.martial_art)
        # 如果只想调用父类的方法 那就注释掉下面的两行
        super().__init__()
        super().addition()


# 子
class Son(Father2):
    def __init__(self, martial_art=8):
        # 武力值9
        self.martial_art = martial_art

    # 重写父类方法
    def addition(self):
        print("武力值：999")

    # 使用祖类方法
    def add(self):
        super().__init__()
        super().addition()


n = Son()
# 同时调用父类祖类方法
n.add()
# 调用重写方法
n.addition()

静态方法

# 静态方法 意义：此方法属于这个类中，实际和类没有关系
class Dog():
    @staticmethod
    def info_print():
        print("这是一个狗类，用于创建实例")


# 静态方法使用类访问
Dog.info_print()
you = Dog()
# 静态方法使用对象访问
you.info_print()

其他@property

语法糖就是一种便捷写法，为了避免coder出现错误并提高效率的语法层面的一种优雅的解决方案

class A():
    # 方法变属性 调用就无需加括号
    @property
    def n(self):
        return 0


m = A()
print(m.n)