Python 面向对象

"""
面向对象编程的主要特点：
    多态：不同类的对象对同一消息会做出不同的响应
    封装：对外部世界隐藏对象的工作细节
    继承：以已有的类为基础建立专门的类对象

函数
方法：和实例绑定的函数称之为方法
"""

示例代码：

class Aclass():

    a = '类变量a，它的值将在这个类的所有实例之间共享。可以在内部类或外部类使用 Aclass.a 访问'
    __aa = '类私有属性'

    def __init__(self,b):
        print('_init__()方法是一种特殊的方法，被称为类的构造函数或初始化方法，当创建了这个类的实例时就会调用该方法')
        self.b = b   # 实例化类时传入参数b，即传给self.b
        self.d = Aclass.a   # 把类变量的值传给变量d

    def cls_func_1(self):
        c = '局部变量c'
        print("这是类的方法")
        print(f"c: {c}")
        print(f'Aclass.a：{Aclass.a}')
        print(f'self.b：{self.b}')

    def __cls_func_2(self):
        print("类私有属性方法")


def func1():
    print("这是普通的函数")
    print(f"类外部访问类变量a: {Aclass.a}")


# 实例化类 - 对象
cls = Aclass(100)  # 类里传入的参数其实就是__init__()参数

对象：如代码，cls就是Aclass类实例化后的具体对象

面向对象的作用：把程序进行封装、方便重复利用，提高效率。

继承示例：

class Aclass():

    a = '类变量a，它的值将在这个类的所有实例之间共享。可以在内部类或外部类使用 Aclass.a 访问'
    __aa = '类私有属性'

    def __init__(self,b):
        print('_init__()方法是一种特殊的方法，被称为类的构造函数或初始化方法，当创建了这个类的实例时就会调用该方法')
        self.b = b   # 实例化类时传入参数b，即传给self.b
        self.d = Aclass.a   # 把类变量的值传给变量d

    def cls_func_1(self):
        c = '局部变量c'
        print("这是类的方法")
        print(f"c: {c}")
        print(f'Aclass.a：{Aclass.a}')
        print(f'self.b：{self.b}')


class Bclass(Aclass):
    
    def __init__(self,b):
        super().__init__(b)

cls = Bclass(100)
cls.cls_func_1() 

Bclass类继承了Aclass类所有，可以直接使用Aclass类的属性、方法

可以继承多个类，如Bclass(Aclass, Cclass, Dclass)

重写示例：

class Aclass():

    a = '类变量a，它的值将在这个类的所有实例之间共享。可以在内部类或外部类使用 Aclass.a 访问'
    __aa = '类私有属性'

    def __init__(self,b):
        print('_init__()方法是一种特殊的方法，被称为类的构造函数或初始化方法，当创建了这个类的实例时就会调用该方法')
        self.b = b   # 实例化类时传入参数b，即传给self.b
        self.d = Aclass.a   # 把类变量的值传给变量d

    def cls_func_1(self):
        c = '局部变量c'
        print("这是类的方法")
        print(f"c: {c}")
        print(f'Aclass.a：{Aclass.a}')
        print(f'self.b：{self.b}')


class Bclass(Aclass):

    def __init__(self,b):
        print('重写了__init__')
        self.b = b

    def cls_func_1(self):
        print('重写Aclsss类的cls_func_1()方法，当Bclass调用cls_func_1方法时，就是这个，不再是Aclass的l')

上面代码重写了__init__方法和cls_func_1方法

多态示例：

# ************* 多态 *************
class Animal():
    def __init__(self, name):
        self.name = name

    def sound(self):
        print(f'{self.name}\'s sound')

class Dog(Animal):
    def sound(self):
        print('wang')

class Cat(Animal):
    def sound(self):
        print('miao')

def hello(animal):
    animal.sound()

dog = Dog('dog')
hello(dog)

cat = Cat('cat')
hello(cat)

#cat 和 dog 是两个不同的对象，对它们调用同个方法，它们会自动调用实际类型的sound方法，作出不同的响应。这就是多态的魅力。