2024.5.22 类 对象

类内的函数叫方法

class stu:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def say(self,para1,para2...):
        print(self.name)

python类可以使用__init__()方法，即构造方法

在构建类对象时自动执行，将传入的参数自动传递给__init()__方法使用

构造方法是python类的内置方法，其他内置方法还有

__str__字符串方法：
class Student:
    def __init__(self,name,age):
        self.name = name
        self.age = name
    def __str__(self):
        return f"student类对象，name={self.name},age={self.age}"
student = Student(.......)
print(student)
print(str(student))
若没有定义__str__方法，会直接打印出来类对象在内存内的地址，若写了__str__，则可以控制将类对象转化为字符串的行为，可以自己决定直接print对象的时候输出什么东西

__lt__小于号比较方法
def __lt__(self,other)
    return self.age < other.age
print(stu1 < stu2)
可用于两个对象之间的比较

__le__小于等于比较符号方法
比__lt__多个等于的判断，定义了这个方法，就可以在外面直接用于两个对象之间的比较

__eq__等于比较方法
同上，如果没有定义，默认比较内存地址，结果两个对象之间肯定不同，只有定义了才是自己的方法

 面对对象编程三大主要特征：封装 继承 多态

封装：类的私有属性和私有方法 调用私有方法和打印私有属性都会报错，给私有属性赋值不会报错但无效，但是可以被类内的方法使用，使用时用self.__...。私有属性和方法要在前面加上__

class phone:
    __current_voltage = None   私有属性
    
    def __keep_single_core(self):
        print(...)
phone = Phone()
phone.__keep_single_core()  报错
print(phone.__current_voltage)   报错

继承：

class Phone :
    IMEI = None
    producer = None
    def call(self):
        print(...)
单继承：
class Phone2022(Phone):
    face_id = None
    def call_pro(self):
        print(...)
多继承：
同上，继承自多个类，输出同名的父类成员，子类调用时输出最先继承的那个父类的内容

复写父类的属性：
class Phone :
    IMEI = None
    producer = None
    def call(self):
        print(...)
class Phone2024(Phone):
    producer = "abc"    复写
    def call(self):
        print(***)       复写
这样外部对象调用的时候，使用的就是复写之后的子类方法
若还要使用父类的属性和方法，有两种办法：父类名访问，或super访问
class Phone2024(Phone):
    producer = "abc"    复写
    def call(self):
        #1
        print(Phone.producer)
        Phone.call(self)
        #2
        print(super.producer)
        super.call()   

        print(***)       复写

多态：多种状态，即完成某个行为时，使用不同的对象会得到不同的状态，同样的函数，传入不同的对象，得到不一样的状态。以父类做声明，以子类做实际工作，

、

class animal:
    def speak(self):
        pass
class dog(animal):
    def speak(self):
        print(...)
class cat(animal):
    def speak(self):
        print(***)

def make_noise(animal:animal)
    animal.speak()

dog = dog()
cat = cat()

make_noise(dog)
make_nosie(cat)
父类中的方法是空实现，这种设计的含义是：父类用来确定有哪些方法，晶体的方法实现，由子类自行决定，这种写法，也叫抽象类，或接口，因为父类中的方法只是定义了抽象方法