类的所有知识

1.类方法、静态方法

创建一个Dog类

类变量为{'黄色'：30；'白色'：10；'黑色'：20}，

初始化构造函数里，要传入name,color,weight.

再创建一个实例方法bark打印self.name叫了起来

再定义一个类方法对类变量的各种颜色的value进行加和统计

定义一个静态方法对创建的object的weight进行加和统计

class Dog:
    # 类属性
    colors = {'黄色': 30, '白色': 10, '黑色': 20}
    id = 1
    
    # 无需手动调用该方法
    def __init__(self, name, color, weight):#实例属性
        self.name = name
        self.color = color
        self.weight = weight
        self.dog_id = Dog.id
        Dog.id += 1

    # 实例方法，必须传入self参数，只对实例属性进行操作，只能通过实例名手动调用
    def bark(self):
        print(f"{self.name}叫了起来")

    # 必须第一个参数传入cla,对类变量进行操作，类名、实例名都可以访问
    @classmethod
    def total_color_value(cls):
        total = 0
        for value in cls.colors.values():
            total += value
        return total
    
    @classmethod
    def get_next_id(cls):
        return cls.id

    # 一个无辜的方法，甚至不必传入参数，2个变量都不能访问，类名、实例名都可以访问它，存在的意义：与该类密切相关，必须有object后才能调用该函数
    @staticmethod
    def total_weight(dogs):
        total = 0
        for dog in dogs:
            total += dog.weight
        return total


# 测试示例
dog1 = Dog('旺财', '黄色', 15)
dog2 = Dog('小白', '白色', 8)
dog3 = Dog('黑狗', '黑色', 12)

dog1.bark()  # 输出：旺财叫了起来

# 使用类调用类方法
total_color_value = Dog.total_color_value()
print(total_color_value)  #60
# 使用实例dog2调用类方法
total_color_value = dog2.total_color_value()
print(total_color_value)  # 输出：60

# 使用静态方法
dogs = [dog1, dog2, dog3]
total_weight = Dog.total_weight(dogs)    #必须传入要统计的object的列表
print(total_weight)  # 输出：35

# 访问每个狗狗对象都有一个名为dog_id的属性
print(dog1.dog_id)  # 输出：1
print(dog2.dog_id)  # 输出：2
print(dog3.dog_id)  # 输出：3

# get_next_id()的类方法，它返回Dog类的id属性的当前值，表示下一个要分配的狗狗编号
next_id = Dog.get_next_id()
print(next_id)  # 输出：4，表示下一个要分配的狗狗编号

2.

装饰器 @property 在 Python 中用于将类方法转换为属性访问，它提供了一种简洁的方式来定义属性，并且在使用属性时可以像访问普通属性一样，而不需要显式地调用方法。

@property 装饰器的作用是将一个方法转换为只读属性，通过该属性可以获取对应的值。它提供了对属性的访问和计算的控制，使得属性的访问更加直观、简洁，同时可以在属性的获取过程中执行一些额外的逻辑。

下例：可以像访问属性一样访问 circle.circumference，而无需使用函数调用的括号。当你访问 circle.circumference 时，它会自动调用 circumference 方法，并返回计算得到的周长值。这使得代码更具可读性，使得周长的计算过程在使用时更加简洁。

使用 @property 装饰器将 circumference 方法定义为属性，使其能够像访问属性一样访问；而对于 area 方法，需要使用函数调用的方式来获取计算得到的面积值。

class Circle:
    def __init__(self, radius):
        self.radius = radius

    def area(self):
        return 3.14 * self.radius * self.radius

    @property
    def circumference(self):
        return 2 * 3.14 * self.radius


# 测试示例
circle = Circle(5)
print(circle.radius)         # 输出：5
print(circle.area)           # 输出：Output: <bound method Circle.area of 
# <__main__.Circleobject at 0x...>>
print(circle.circumference)  # 输出：31.4

 

 3.类的继承是面向对象编程中的一种重要概念，它允许一个类（称为子类或派生类）从另一个类（称为父类或基类）继承属性和方法。子类可以继承父类的属性和方法，并且可以添加自己特定的属性和方法，或者覆盖父类的方法。

子类可以通过super()函数调用父类的__init__方法来继承父类的属性。此外，子类还可以重写（覆盖）父类的方法，以提供自己特定的实现。

下例：Dog对象调用的是子类中重写的方法，输出"狗在汪汪叫"。 

class Animal:
    def __init__(self, name):
        self.name = name

    def sound(self):
        print("动物发出声音")


class Dog(Animal):
    def __init__(self, name):
        super().__init__(name)

    def sound(self):
        print("狗在汪汪叫")


# 测试示例
animal = Animal("动物")
animal.sound()  # 输出：动物发出声音

dog = Dog("小狗")
dog.sound()  # 输出：狗在汪汪叫

4.多态是面向对象编程中的一个另重要概念，它允许不同的对象对同一个方法做出不同的响应。通过多态，我们可以使用统一的接口来处理不同的对象类型，而不需要关注具体的对象类型。 

class Animal:
    def sound(self):
        pass


class Dog(Animal):
    def sound(self):
        print("狗在汪汪叫")


class Cat(Animal):
    def sound(self):
        print("猫在喵喵叫")


# 接受一个Animal类型的参数，并调用其sound方法。这里我们使用了多态的概念，无论传递的是Dog对象还是Cat对象，它们都是Animal的子类，都有sound方法。

def make_sound(animal):
    animal.sound()


animals = [Dog(), Cat()]

for animal in animals:
    make_sound(animal)

# 狗在汪汪叫
# 猫在喵喵叫