封装、继承、多态及重载

1.封装

​ 封装是面向对象的核心思想，将对象的属性和行为封装起来，不需要让外界知道具体实现细节，避免了外界直接访问对象属性而造成耦合度过高及过度依赖，同时也阻止了外界对对象内部数据的修改而可能引发的不可预知错误。

例子1：封装后通过实例化来访问类里边的变量

例子2：封装后通过实例化来访问类中的函数

封装后，外部访问类中的变量和函数时需要实例化类，才能访问类中的方法和变量

2.继承

​ 继承最大的好处就是增强了代码复用性，提高了开发效率，降低了创建对象、类的工作量。

class TBase_Stope(TBase):
    def __init__(self):
        self.pub_gzm_no = ''
        self.pub_gzm_name = ''
        self.pub_gzm_cg_h = 0.0
        self.pub_gzm_qj = 0.0 
    
    def fun_base_jsdata(self, data):
        self.pub_gzm_no = data['pub_gzm_no']
        self.pub_gzm_name = data['pub_gzm_name']
        self.pub_gzm_cg_h = data['pub_gzm_cg_h']
        self.pub_gzm_qj = data['pub_gzm_qj']
        
    def fun_base_output(self):
        data = {
            'pub_gzm_no': self.pub_gzm_no,
            'pub_gzm_name': self.pub_gzm_name,
            'pub_gzm_cg_h': self.pub_gzm_cg_h,
            'pub_gzm_qj': self.pub_gzm_qj
        }
        return data
        
class TExp_Stope(TBase_Stope): # 继承TBase_Stope类
    def __init__(self):
        super().__init__()
        self.pub_gzm_day_speed = 0.0
        self.pub_gzm_sx_qj = 0.0
        self.pub_gzm_sh_up = 0.0

    def fun_exp_jsdata(self, data):
        self.fun_base_jsdata(data) # 调用了TBase_Stope类的fun_base_jsdata函数
        self.pub_gzm_day_speed = data['pub_gzm_day_speed']
        self.pub_gzm_sx_qj = data['pub_gzm_sx_qj']
        self.pub_gzm_sh_up = data['pub_gzm_sh_up']
        
    def fun_exp_output(self):
        data = {
            'pub_gzm_no': self.pub_gzm_no,
            'pub_gzm_name': self.pub_gzm_name,
            'pub_gzm_cg_h': self.pub_gzm_cg_h,
            'pub_gzm_day_speed': self.pub_gzm_day_speed,
            'pub_gzm_qj': self.pub_gzm_qj,
            'pub_gzm_sx_qj': self.pub_gzm_sx_qj,
            'pub_gzm_sh_up': self.pub_gzm_sh_up
        }
        return data

在self.fun_base_jsdata(data)调用中，由于TExp_Stope类继承了TBase_Stope类，因此TExp_Stope对象可以调用TBase_Stope类中定义的fun_base_jsdata方法，输出结果将是TExp_Stope类不需要复写pub_gzm_no,pub_gzm_name,pub_gzm_cg_h，pub_gzm_qj这四个变量，且可以调用fun_base_jsdata()这个函数。

3.多态

​ 多态是指同一个方法名可以根据不同的对象类型表现出不同的行为。简而言之，多态允许使用不同的对象来调用相同的方法，产生不同的结果

class Animal:
    def sound(self):
        pass

class Dog(Animal):
    def sound(self):
        print("汪汪汪！")

class Cat(Animal):
    def sound(self):
        print("喵喵喵！")

class Duck(Animal):
    def sound(self):
        print("嘎嘎嘎！")

# 创建不同的动物实例
dog = Dog()
cat = Cat()
duck = Duck()

# 使用相同的方法名调用不同的对象
dog.sound()  # 输出: 汪汪汪！
cat.sound()  # 输出: 喵喵喵！
duck.sound()  # 输出: 嘎嘎嘎！

不同的类中可以有相同的函数名，每个类调用自己的函数输出结果是不同的，互不干预

4.多态之重载

​ 函数重载是指定义多个同名函数，每一个都有不同的参数列表。调用函数时，会根据传递的参数类型、数量等信息，选择对应的函数执行。

​ Python不支持函数重载，但是可以使用其他方法达到类似的功能。

​ Python中可以使用默认参数来实现函数重载的功能。例如：

def add(a, b=0, c=0):
    return a + b + c

result1 = add(1)
result2 = add(1, 2)
result3 = add(1, 2, 3)
print(result1) # 输出：1
print(result2) # 输出：3
print(result3) # 输出：6

在上述例子中，定义了一个名为add的函数，它有三个参数：a、b和c。其中b和c有默认值0，如果调用add时只传入一个参数，那么b和c都将使用默认值0来计算。