八、python学习笔记-面向对象-三大特性

# 封装,将多个类方法中调用的相同参数封装为类变量
class Bar:
    def __init__(self, n, a):
        self.name = n
        self.age = a
        self.xue = 'o'


b1 = Bar('alex', 123)
b2 = Bar('eric', 456)

"""使用场景
如果多个函数中有一些相同参数时，使用封装
"""
class DataBaseHelper:

    def __init__(self, ip, port, username, pwd):
        self.ip = ip
        self.port = port
        self.username = username
        self.pwd = pwd

    def add(self, content):
        # 利用self中封装的用户名、密码等   链接数据
        print('content')
        # 关闭数据链接

    def delete(self, content):
        # 利用self中封装的用户名、密码等   链接数据
        print('content')
        # 关闭数据链接

    def update(self, content):
        # 利用self中封装的用户名、密码等   链接数据
        print('content')
        # 关闭数据链接

    def get(self, content):
        # 利用self中封装的用户名、密码等   链接数据
        print('content')
        # 关闭数据链接


s1 = DataBaseHelper('1.1.1.1', 3306, 'user', 'password')

# Python 同样支持类的继承，如果一种语言不支持继承，类就没有什么意义。下面示例中,F类为S类的父类，S类是F类的子类，或者派生类。子类可以有多个父类
class F:
    pass


class S(F):
    pass


"""方法继承
当调用子类中不存在的方法时，会从父类中寻找。
寻找顺序为从左到右，先从左侧的父类中寻找，如果没有继续从左侧父类的父类中寻找，直至最后一个。然后再往右侧父类寻找
当左侧和右侧的父类拥有公共父类时，公共父类方法最后执行
self永远是执行该方法的调用者(类对象)
父类方法中调用的方法，会从子类开始从新查找，并非直接执行父类中的方法
"""


# 示例1，子类中不存在是从父类寻找
class A1:
    def a(self):
        return "这是类A1"


class B1(A1):
    pass


x1 = B1()
print(x1.a())


# 示例2，寻找顺序为从左到右，先从左侧的父类中寻找，如果没有继续从左侧父类的父类中寻找，直至最后一个。然后再往右侧父类寻找
class A2:
    def a(self):
        return "这是类A2"


class B2:
    def a(self):
        return "这是类B2"

    def b(self):
        return "这是类B2"


class C2(A2, B2):
    pass


x2 = C2()
print(x2.a())
print(x2.b())


# 示例3，当左侧和右侧的父类拥有公共父类时，公共父类方法最后执行
class A3:
    def a(self):
        return "这是类A3"

    def b(self):
        return "这是类A3"

    def c(self):
        return "这是类A3"


class B3(A3):
    def b(self):
        return "这是类B3"


class C3(A3):
    def c(self):
        return "这是类C3"


class D3(B3, C3):
    pass


x3 = D3()
print(x3.a())
print(x3.b())
print(x3.c())


# 示例4，self永远是执行该方法的调用者(类对象)
class A4:
    def a(self):
        return self


class B4(A4):
    def b(self):
        return self


x4 = B4()
print(x4.a())
print(x4.b())


# 示例5，父类方法中调用的方法，会从子类开始从新查找，并非直接执行父类中的方法
class A5:
    def a(self):
        return '这是父类'

    def b(self):
        return self.a()


class B5(A5):
    def a(self):
        return '这是子类'


x5 = B5()

# 执行返回‘这是子类’，说明父类方法b返回的执行self.a()，会返回到子类中重新寻找方法a，因此执行子类的方法a
print(x5.b())

"""重写
在子类中重新定义父类中的同名方法，防止执行父类中的方法
"""
class A6:
    def a(self):
        return "这是父类"


class B6(A6):
    def a(self):
        return "这是子类"


x6 = B6()
print(x6.a())

"""supper
在子类中主动调用父类方法
"""
class A7:
    def a(self):
        print('这是父类')


class B7(A7):
    def a(self):
        super(B7, self).a()


x7 = B7()
x7.a()

# 在变量赋值时可是时多种数据类型，Python是原生多态
# Python变量赋值时不指定类型，可以是字符串，数字
# 函数参数arg可以是数字也可以是字符串
def func(arg):
    print(arg)


func(1)
func('alex')