9.类的定义与使用

标签：__ 定义 self 使用 print class def name

类的定义
构造函数(__init__)
实例变量
类变量
方法(实例方法)
类方法(@classmethod)
静态方法(@staticmethod)
属性装饰器(@property)
私有属性与方法
继承
多态
方法重写
super()函数
类的文档字符串
类的属性和方法访问控制

1.类的定义:

如int,list,tuple等等都是类,还可以通过class方法自己创建类,

定义:类是对象的蓝图,包括属性(数据)和方法(行为),在python中使用class关键字定义

用法:类可以用来创建对象(实例),每个对象都可以有自己的属性与方法

例如：游戏角色就是类

亚索就是对象

技能就是对象的方法，数值是对象的属性

2.属性:既他们共有的部分,如建立一个student类,那么他们的学号,年纪,课程,各科成绩都是属性

3.方法:既函数,如:计算他们的总成绩

如下可以创建一个空类

class MyClass:
    pass  # 空类

2.构造函数(init)

定义:构造函数是一个特殊的方法,用于初始化对象的属性,他在创建对象时自动调用.

用法:构造函数的名称是__init__,它接受参数并将这些参数赋值给实例变量.

class Person:
    def __init__(self, name, age):
        self.name = name  # 实例变量
        self.age = age    # 实例变量

说明:在这个例子中,Person类有一个构造函数,他接受name,age作为参数,并将他们赋值给实例变量self.name和self.age,每当创建一个Person对象时,都会调用这个构造函数.

3.实例变量

定义:实例变量是属于特定对象的变量,每个对象都有自己的副本,他们通常在构造函数中定义

用法:通过self关键字访问实例变量

class Dog:
    def __init__(self, name):
        self.name = name  # 实例变量

dog1 = Dog("Buddy")
dog2 = Dog("Max")
print(dog1.name)  # 输出: Buddy
print(dog2.name)  # 输出: Max

说明:在这个例子中,Dog类的每个实例都有自己的name属性,dog1和dog2是两个不同的对象,他们的name属性是独立的.

4.类变量

定义:类变量是属于类的变量,所有实例共享同一个类变量,他们通常在类体中定义.

用法:可以通过类名或实例访问类变量.

class Dog:
    species = "Canis familiaris"  # 类变量

    def __init__(self, name):
        self.name = name  # 实例变量

print(Dog.species,Dog.name)  # 输出: Canis familiaris
dog1 = Dog("Buddy")
print(dog1.species,dog1.name)  # 输出: Canis familiaris Buddy

说明:在这个例子中,species是一个类变量,所有Dog类的实例共享这个变量,无论是通过类名还是实例访问,结果都是相同的.

5.方法(实例方法)

定义:方法是定义在类中的函数,用于描述对象的行为,方法可以访问实例变量和类变量.

用法:通过实例调用方法.

class Dog:
    def __init__(self, name, age):
        self.name = name  # 实例变量
        self.age = age    # 实例变量

    def bark(self):  # 实例方法
        return f"{self.name} says Woof!"

    def get_age(self):  # 实例方法
        return self.age

# 创建实例
dog1 = Dog("Buddy", 3)
dog2 = Dog("Max", 5)

# 调用实例方法
print(dog1.bark())  # 输出: Buddy says Woof!
print(dog2.get_age())  # 输出: 5

说明:

在这个例子中，Dog类有两个实例变量name和age，它们在构造函数中初始化。

bark和get_age是实例方法，分别用于返回狗的叫声和年龄。

通过创建Dog类的实例dog1和dog2，可以调用这些实例方法。

6.类方法(@classmethod)

定义:类方法是绑定到类而不是实例的方法,可以访问类变量,他的第一个参数是类本身,通常被命名为cls.类方法不需要实例化对象就可以调用

用法:使用@classmethod装饰器

class Dog:
    species = "Canis familiaris"  # 类变量

    def __init__(self, name):
        self.name = name  # 实例变量

    @classmethod
    def get_species(cls):
        return cls.species  # 访问类变量

    @classmethod
    def create_dog(cls, name):
        return cls(name)  # 使用类方法创建实例

# 调用类方法
print(Dog.get_species())  # 输出: Canis familiaris

# 使用类方法创建实例
dog1 = Dog.create_dog("Buddy")
print(dog1.name)  # 输出: Buddy

说明:

在这个例子中，Dog类有一个类变量species，它表示狗的物种。

get_species是一个类方法，用于返回类变量species的值。

create_dog是另一个类方法，用于根据传入的名称创建Dog类的实例。它返回一个新的Dog对象。

6.1类方法的其他参数

class MyClass:
    class_variable = 0

    @classmethod
    def increment(cls, amount):
        cls.class_variable += amount  # 增加类变量的值

    @classmethod
    def get_class_variable(cls):
        return cls.class_variable

# 使用类方法
MyClass.increment(5)
print(MyClass.get_class_variable())  # 输出: 5

MyClass.increment(10)
print(MyClass.get_class_variable())  # 输出: 15

说明:

在这个例子中，increment方法接受一个参数amount，用于增加类变量class_variable的值。

注6.2:类方法与实例方法的比较

实例方法：实例方法的第一个参数是self，它指向实例本身，可以访问实例变量和类变量。

类方法：类方法的第一个参数是cls，它指向类本身，只能访问类变量。

class Example:
    class_variable = "I am a class variable"

    def __init__(self, instance_variable):
        self.instance_variable = instance_variable

    @classmethod
    def class_method(cls):
        return cls.class_variable  # 访问类变量

    def instance_method(self):
        return self.instance_variable,self.class_variable  # 访问实例变量和类变量

example = Example("I am an instance variable")
print(example.class_method())  # 输出: I am a class variable
print(example.instance_method())  # 输出: ('I am an instance variable', 'I am a class variable')

7.静态方法(@staticmethod)

定义:静态方法是定义在类中的方法，但它不依赖于类或实例的状态。静态方法不需要访问类变量或实例变量，因此它不需要self或cls作为参数。静态方法通常用于执行一些与类或实例无关的功能。

用法:使用@staticmethod装饰器

class Math:
    @staticmethod
    def add(a, b):
        return a + b

    @staticmethod
    def multiply(a, b):
        return a * b

# 调用静态方法
result_add = Math.add(5, 3)  # 通过类名调用
result_multiply = Math.multiply(4, 2)  # 通过类名调用

print(result_add)      # 输出: 8
print(result_multiply) # 输出: 8

说明:

在这个例子中，Math类定义了两个静态方法：add和multiply，分别用于执行加法和乘法运算。

这些方法不依赖于类的状态，因此可以直接通过类名调用。

注:7.1静态方法与实例方法,类方法的比较

实例方法：实例方法的第一个参数是self，它指向实例本身，可以访问实例变量和类变量。

类方法：类方法的第一个参数是cls，它指向类本身，可以访问类变量。

静态方法：静态方法不需要self或cls，它们不依赖于类或实例的状态。

class Example:
    class_variable = "I am a class variable"

    def __init__(self, instance_variable):
        self.instance_variable = instance_variable

    @classmethod
    def class_method(cls):  #类方法
        return cls.class_variable  # 访问类变量

    def instance_method(self):    #实例方法
        return self.instance_variable  # 访问实例变量

    @staticmethod
    def static_method():    #静态方法
        return "I am a static method"  # 不依赖于类或实例

example = Example("I am an instance variable")
print(example.class_method())  # 输出: I am a class variable
print(example.instance_method())  # 输出: I am an instance variable
print(Example.static_method())  # 输出: I am a static method

8.属性装饰器(@property)

定义:属性装饰器用于将方法转换为属性,允许对属性的访问进行控制,她可以让你在访问属性时执行一些逻辑

用法:使用@property和@<property_name>.setter装饰器

class Circle:
    def __init__(self, radius):
        self._radius = radius  # 保护属性

    @property
    def radius(self):
        """获取圆的半径"""
        return self._radius

    @radius.setter
    def radius(self, value):
        """设置圆的半径，确保半径为正数"""
        if value < 0:
            raise ValueError("Radius cannot be negative")
        self._radius = value

    @property
    def area(self):
        """计算圆的面积"""
        return 3.14159 * (self._radius ** 2)

# 创建实例
circle = Circle(5)

# 访问属性
print(circle.radius)  # 输出: 5
print(circle.area)    # 输出: 78.53975

# 修改属性
circle.radius = 10
print(circle.radius)  # 输出: 10
print(circle.area)    # 输出: 314.159

# circle.radius = -5  # 会引发 ValueError

说明:

在这个例子中，Circle类有一个保护属性_radius，用于存储圆的半径。

radius方法被装饰为属性，允许通过circle.radius访问半径。

radius的设置器方法允许对半径进行赋值，并在赋值时进行验证，确保半径为正数。

area方法被装饰为只读属性，计算并返回圆的面积。

具体实例:

class Bank:
    #使用__加在需要隐藏的属性命名前
    # 即使是使用print(__money)也输出不了
    def __init__(self,ID,password,money):
        self.ID = ID
        self.__passsword = password
        self.__money = money
    @property   #python内置三大装饰器 描述符 将方法变为属性
    def money(self):
        return self.__money

    @money.setter  #存钱
    def money(self,value):
        self.__money = value
        print(f'尊敬的{self.ID}你好，您的余额还剩{self.__money}')

    @money.deleter  #删除
    def money(self):
        del self.__money
        print('已删除')
b = Bank('小徐','123456',1000)
print(b.money)   #1000
b.money =2000    #尊敬的小徐你好，您的余额还剩2000
print(b.money)   #2000
#删除此数据
del b.money  #已删除

9.私有属性与方法

定义:在Python中，私有属性和方法是以双下划线（__）开头的属性和方法。它们的设计目的是为了限制对类内部状态的直接访问，从而实现数据封装和保护。

私有属性：以双下划线开头的实例变量，外部无法直接访问。

私有方法：以双下划线开头的方法，外部无法直接调用。

用法:通过公共方法访问私有属性

class BankAccount:
    def __init__(self, balance):
        self.__balance = balance  # 私有属性

    def deposit(self, amount):
        """存款方法，增加余额"""
        if amount > 0:
            self.__balance += amount
        else:
            print("Deposit amount must be positive")

    def withdraw(self, amount):
        """取款方法，减少余额"""
        if 0 < amount <= self.__balance:
            self.__balance -= amount
        else:
            print("Invalid withdrawal amount")

    def get_balance(self):
        """获取当前余额"""
        return self.__balance  # 通过公共方法访问私有属性

# 创建实例
account = BankAccount(1000)

# 存款
account.deposit(500)
print(account.get_balance())  # 输出: 1500

# 取款
account.withdraw(200)
print(account.get_balance())  # 输出: 1300

# 直接访问私有属性会引发错误
# print(account.__balance)  # 会引发 AttributeError

说明:

在这个例子中，BankAccount类有一个私有属性__balance，用于存储账户余额。

deposit和withdraw方法用于增加和减少余额，确保对余额的操作是安全的。

get_balance方法是一个公共方法，用于获取当前余额，允许外部访问私有属性。

10.继承

定义:继承允许一个类(子类)继承另一个类(父类)的属性和方法,子类可以重用父类的代码,并可以添加或重写功能.

用法:通过在类定义中指定父类.

10.1单继承:

# 定义父类 Animal
class Animal:
    def __init__(self, name, age):
        self.name = name  # 实例变量
        self.age = age    # 实例变量

    def speak(self):
        return "Some sound"

    def info(self):
        return f"{self.name} is {self.age} years old."

# 定义子类 Dog，继承自 Animal
class Dog(Animal):
    def speak(self):  # 重写父类的方法
        return "Woof!"

# 定义子类 Cat，继承自 Animal
class Cat(Animal):
    def speak(self):  # 重写父类的方法
        return "Meow!"

# 创建实例
dog = Dog("Buddy", 3)
cat = Cat("Whiskers", 5)

# 访问父类的属性和方法
print(dog.name)  # 输出: Buddy
print(dog.age)   # 输出: 3
print(dog.info())  # 输出: Buddy is 3 years old.
print(dog.speak())  # 输出: Woof!

print(cat.name)  # 输出: Whiskers
print(cat.age)   # 输出: 5
print(cat.info())  # 输出: Whiskers is 5 years old.
print(cat.speak())  # 输出: Meow!

说明:

在这个例子中，Animal是父类，包含两个实例变量name和age，以及两个方法speak和info。
Dog和Cat是子类，分别继承自Animal类，并重写了speak方法，以返回特定的声音。
通过创建Dog和Cat的实例，可以访问它们的属性和方法，展示了继承的效果。

10.2多继承:

class Flyer:
    def fly(self):
        return "Flying"

class Swimmer:
    def swim(self):
        return "Swimming"

class Duck(Flyer, Swimmer):  # 多重继承
    def quack(self):
        return "Quack!"

# 创建实例
duck = Duck()
print(duck.fly())  # 输出: Flying
print(duck.swim())  # 输出: Swimming
print(duck.quack())  # 输出: Quack!

说明:

在这个例子中，Flyer和Swimmer是两个父类，Duck类同时继承了这两个父类。

Duck类可以访问Flyer和Swimmer类的方法，展示了多重继承的特性。

注:10.1方法解析顺序

在多重继承中，Python使用方法解析顺序（MRO）来确定方法的调用顺序。可以使用__mro__属性查看类的MRO。

print(Duck.__mro__)  # 输出: (<class '__main__.Duck'>, <class '__main__.Flyer'>, <class '__main__.Swimmer'>, <class 'object'>)

MRO的顺序是从子类到父类的顺序

11.多态

定义:多态允许不同类的对象以相同的方式调用相同的方法,它使代码更加灵活可拓展

用法:通过父类引用调用子类的方法

# 定义父类 Animal
class Animal:
    def speak(self):
        raise NotImplementedError("Subclasses must implement this method")

# 定义子类 Dog，继承自 Animal
class Dog(Animal):
    def speak(self):  # 重写父类的方法
        return "Woof!"

# 定义子类 Cat，继承自 Animal
class Cat(Animal):
    def speak(self):  # 重写父类的方法
        return "Meow!"

# 定义子类 Bird，继承自 Animal
class Bird(Animal):
    def speak(self):  # 重写父类的方法
        return "Chirp!"

# 创建一个函数，接受 Animal 类型的参数
def animal_sound(animal):
    print(animal.speak())

# 创建实例
dog = Dog()
cat = Cat()
bird = Bird()

# 调用函数，展示多态
animal_sound(dog)  # 输出: Woof!
animal_sound(cat)  # 输出: Meow!
animal_sound(bird)  # 输出: Chirp!

说明:

在这个例子中，Animal是一个父类，定义了一个speak方法，但没有实现具体的逻辑，而是抛出NotImplementedError，要求子类必须实现这个方法。

Dog、Cat和Bird是子类，它们分别重写了speak方法，返回各自特有的声音。

animal_sound函数接受一个Animal类型的参数，并调用其speak方法。无论传入的是Dog、Cat还是Bird对象，都会调用相应的speak方法，展示了多态的特性。

11.1多态与鸭子类型

Python是一种动态类型语言，支持鸭子类型（Duck Typing）。这意味着只要一个对象实现了所需的方法，就可以被视为该类型，而不需要显式声明类型。

class Duck:
    def quack(self):
        return "Quack!"

class Person:
    def quack(self):
        return "I'm quacking like a duck!"

# 定义一个函数，接受任何具有 quack 方法的对象
def make_it_quack(thing):
    print(thing.quack())

# 创建实例
duck = Duck()
person = Person()

# 调用函数，展示鸭子类型
make_it_quack(duck)    # 输出: Quack!
make_it_quack(person)  # 输出: I'm quacking like a duck!

在这个例子中，Duck和Person类都实现了quack方法。make_it_quack函数接受任何具有quack方法的对象，无论其类型如何。

这展示了鸭子类型的灵活性，允许不同类型的对象以相同的方式进行操作。

12.方法重写

定义:方法重写（Method Overriding）是指在子类中重新定义父类的方法，以提供特定的实现。通过方法重写，子类可以改变或扩展父类的行为。

用法:子类中定义与父类同名的方法

# 定义父类 Animal
class Animal:
    def speak(self):
        return "Some sound"

# 定义子类 Dog，继承自 Animal
class Dog(Animal):
    def speak(self):  # 重写父类的方法
        return "Woof!"

# 定义子类 Cat，继承自 Animal
class Cat(Animal):
    def speak(self):  # 重写父类的方法
        return "Meow!"

# 创建实例
dog = Dog()
cat = Cat()

# 调用方法
print(dog.speak())  # 输出: Woof!
print(cat.speak())  # 输出: Meow!

说明:

在这个例子中，Animal是父类，定义了一个speak方法，返回一个通用的声音。

Dog和Cat是子类，它们分别重写了speak方法，返回特定的声音。

当调用dog.speak()和cat.speak()时，执行的是子类中的实现，而不是父类中的实现。

13.super()函数

定义:super()是一个内置函数，用于返回当前类的父类（超类）对象。它主要用于调用父类的方法，特别是在子类重写父类方法时，可以通过super()来访问父类的实现。

用法:在子类中使用super()调用父类的构造函数或方法

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

    def speak(self):
        return "Some sound"

class Dog(Animal):
    def __init__(self, name, breed):
        super().__init__(name)  # 调用父类的构造函数
        self.breed = breed

    def speak(self):  # 重写父类的方法
        parent_sound = super().speak()  # 调用父类的方法
        return f"{parent_sound} and Woof!"

# 创建实例
dog = Dog("Buddy", "Golden Retriever")

# 调用方法
print(dog.name)  # 输出: Buddy
print(dog.breed)  # 输出: Golden Retriever
print(dog.speak())  # 输出: Some sound and Woof!

说明:

在这个例子中，Animal类有一个构造函数和一个speak方法。

Dog类继承自Animal，在其构造函数中使用super().__init__(name)调用父类的构造函数，以初始化name属性。

Dog类重写了speak方法，并在其中使用super().speak()调用父类的speak方法，结合了父类和子类的行为。

13.1多继承中的super()

在多重继承中，super()能够按照方法解析顺序（MRO）正确地调用父类的方法。

class A:
    def greet(self):
        return "Hello from A"

class B(A):
    def greet(self):
        return super().greet() + " and Hello from B"

class C(A):
    def greet(self):
        return super().greet() + " and Hello from C"

class D(B, C):  # D 继承自 B 和 C
    def greet(self):
        return super().greet() + " and Hello from D"

# 创建实例
d = D()
print(d.greet())  # 输出: Hello from A and Hello from C and Hello from B and Hello from D

说明:

在这个例子中，D类继承自B和C，而B和C又都继承自A。

当调用d.greet()时，super()会按照MRO的顺序依次调用父类的方法，确保每个类的greet方法都被调用。

14.类的文档字符串

定义:文档字符串用于描述类或方法的功能,她们呢是类和方法的第一行字符串,通常用于提供帮助信息.

用法:在类或方法的第一行使用三重引号

class Dog:
    """A class representing a dog."""
    
    def bark(self):
        """Make the dog bark."""
        return "Woof!"

说明:在这个例子中,Dog类和bark方法都有文档字符串,可以使用help(Dog)或help(Dog.bark)查看这些文档字符串,帮助用户理解类和方法的功能.

15.类的属性和方法的访问控制

公有:可以在类外部访问,默认情况下,所有属性和方法都是公有的
保护:以单下划线开头,表示不建议在类的外部访问,通常用于内部使用
私有:以双下划线开头,外部无法直接访问,通常用于保护类的内部状态.

class Example:
    def __init__(self):
        self.public_var = "I am public"
        self._protected_var = "I am protected"
        self.__private_var = "I am private"

example = Example()
print(example.public_var)  # 输出: I am public
print(example._protected_var)  # 输出: I am protected
# print(example.__private_var)  # 会引发 AttributeError

16.其他

'''
Python内置的类属性
1.dict 类的属性 返回字典
2.doc 类的文档  输出第一行内部注释 单' '或三 ''' ''' #不行
3.name 输出类的名字
4.bases 类的所有父类
'''
class a :
    '所有员工的基类'
    b = 0
    '13'

print(a.__doc__)  #所有员工的基类
print(a.__name__)  #a
print(a.__dict__)  #{'__module__': '__main__', '__doc__': '所有员工的基类', 'b': 0, '__dict__': <attribute '__dict__' of 'a' objects>, '__weakref__': <attribute '__weakref__' of 'a' objects>}
print(a.__bases__)   #(<class 'object'>,)

'''
type :检测该数据是什么数据类型
isinstance(obj,int) :检测obj是不是int类型,检测一个类型是不是指定类型
issubclass(子类,父类):是否有继承关系
'''

class A(object):
    pass
class B(A):
    pass
#检测B是不是A的子类
print(issubclass(B,A))  #True

16总结

class Animal:
    """父类：动物"""
    
    def __init__(self, name, age):
        self.name = name  # 实例变量
        self.age = age    # 实例变量

    def speak(self):
        """动物发声，子类需要重写此方法"""
        raise NotImplementedError("Subclasses must implement this method")

    def info(self):
        """获取动物信息"""
        return f"{self.name} is {self.age} years old."


class Dog(Animal):
    """子类：狗"""
    
    def __init__(self, name, age, breed):
        super().__init__(name, age)  # 调用父类构造函数
        self.breed = breed  # 实例变量

    def speak(self):  # 重写父类的方法
        return "Woof!"

    @staticmethod
    def species():
        """静态方法：返回物种"""
        return "Canis familiaris"


class Cat(Animal):
    """子类：猫"""
    
    def speak(self):  # 重写父类的方法
        return "Meow!"


class Bird(Animal):
    """子类：鸟"""
    
    def speak(self):  # 重写父类的方法
        return "Chirp!"


class AnimalShelter:
    """动物收容所类"""
    
    def __init__(self):
        self.animals = []  # 存储动物的列表

    def add_animal(self, animal):
        """添加动物到收容所"""
        self.animals.append(animal)

    def make_sounds(self):
        """让所有动物发声"""
        for animal in self.animals:
            print(f"{animal.info()} says {animal.speak()}")


# 创建动物实例
dog = Dog("Buddy", 3, "Golden Retriever")
cat = Cat("Whiskers", 2)
bird = Bird("Tweety", 1)

# 创建动物收容所实例
shelter = AnimalShelter()

# 添加动物到收容所
shelter.add_animal(dog)
shelter.add_animal(cat)
shelter.add_animal(bird)

# 让所有动物发声
shelter.make_sounds()

# 输出狗的物种
print(f"{dog.name} is a {Dog.species()}.")  # 输出: Buddy is a Canis familiaris.

说明:

1. 类定义：

Animal是父类，包含基本的动物属性和方法。

Dog、Cat和Bird是子类，分别重写了speak方法，提供特定的发声实现。

2. 继承：

Dog类继承自Animal类，并在构造函数中使用super()调用父类的构造函数。

3. 多态：

make_sounds方法展示了多态性，通过调用不同动物的speak方法，输出不同的声音。

4. 静态方法：

Dog类中定义了一个静态方法species，返回狗的物种。

5. 私有属性：

在这个示例中没有使用私有属性，但可以在实际应用中根据需要添加。

6. 动物收容所：

AnimalShelter类用于管理动物，提供添加动物和让动物发声的方法。

16.2

import random

class Animal:
    """父类：动物"""
    
    def __init__(self, name, age):
        self.name = name  # 实例变量
        self.age = age    # 实例变量
        self.__health = 100  # 私有属性：健康值

    def speak(self):
        """动物发声，子类需要重写此方法"""
        raise NotImplementedError("Subclasses must implement this method")

    def info(self):
        """获取动物信息"""
        return f"{self.name} is {self.age} years old and has {self.__health} health."

    @property
    def health(self):
        """健康值的属性装饰器"""
        return self.__health

    def take_damage(self, damage):
        """减少健康值"""
        self.__health -= damage
        if self.__health < 0:
            self.__health = 0

    def heal(self, amount):
        """恢复健康值"""
        self.__health += amount
        if self.__health > 100:
            self.__health = 100


class Dog(Animal):
    """子类：狗"""
    
    def __init__(self, name, age, breed):
        super().__init__(name, age)  # 调用父类构造函数
        self.breed = breed  # 实例变量

    def speak(self):  # 重写父类的方法
        return "Woof!"

    @staticmethod
    def species():
        """静态方法：返回物种"""
        return "Canis familiaris"


class Cat(Animal):
    """子类：猫"""
    
    def speak(self):  # 重写父类的方法
        return "Meow!"


class Bird(Animal):
    """子类：鸟"""
    
    def speak(self):  # 重写父类的方法
        return "Chirp!"


class AdventureGame:
    """动物冒险游戏类"""
    
    def __init__(self):
        self.animals = []  # 存储动物的列表

    def add_animal(self, animal):
        """添加动物到游戏"""
        self.animals.append(animal)

    def start_adventure(self):
        """开始冒险"""
        print("Welcome to the Animal Adventure Game!")
        for animal in self.animals:
            print(f"{animal.info()} says {animal.speak()}")
            self.adventure(animal)

    def adventure(self, animal):
        """进行一次冒险"""
        print(f"{animal.name} is going on an adventure!")
        damage = random.randint(10, 30)  # 随机伤害
        print(f"{animal.name} encountered a challenge and took {damage} damage!")
        animal.take_damage(damage)
        print(animal.info())

        # 选择是否恢复健康
        if random.choice([True, False]):
            heal_amount = random.randint(5, 20)
            animal.heal(heal_amount)
            print(f"{animal.name} healed for {heal_amount} health!")
            print(animal.info())
        print("-" * 30)


# 创建动物实例
dog = Dog("Buddy", 3, "Golden Retriever")
cat = Cat("Whiskers", 2)
bird = Bird("Tweety", 1)

# 创建游戏实例
game = AdventureGame()

# 添加动物到游戏
game.add_animal(dog)
game.add_animal(cat)
game.add_animal(bird)

# 开始冒险
game.start_adventure()

说明:

1. 类定义：

Animal是父类，包含基本的动物属性和方法，包括健康值的私有属性、发声方法、信息获取方法、受伤和恢复健康的方法。

Dog、Cat和Bird是子类，分别重写了speak方法，提供特定的发声实现。

继承：

Dog类继承自Animal类，并在构造函数中使用super()调用父类的构造函数。

3. 多态：

start_adventure方法展示了多态性，通过调用不同动物的speak方法，输出不同的声音。

4. 属性装饰器：

health属性使用了属性装饰器，提供对私有健康值的访问。

私有属性：

__health是一个私有属性，外部无法直接访问，通过公共方法进行访问和修改。

6. 静态方法：

Dog类中定义了一个静态方法species，返回狗的物种。

7. 游戏逻辑：

AdventureGame类用于管理动物的冒险，提供添加动物和开始冒险的方法。在冒险中，动物会随机受到伤害，并有机会恢复健康。

标签：__,定义,self,使用,print,class,def,name
From： https://blog.csdn.net/2303_81133811/article/details/143234296

1.类的定义:

2.构造函数(init)

3.实例变量

4.类变量

5.方法(实例方法)

6.类方法(@classmethod)

6.1类方法的其他参数

注6.2:类方法与实例方法的比较

7.静态方法(@staticmethod)

注:7.1静态方法与实例方法,类方法的比较

8.属性装饰器(@property)

9.私有属性与方法

10.继承

10.1单继承:

10.2多继承:

注:10.1方法解析顺序

11.多态

11.1多态与鸭子类型

12.方法重写

13.super()函数

13.1多继承中的super()

14.类的文档字符串

15.类的属性和方法的访问控制

16.其他

16总结

相关文章

赞助商

阅读排行

9.类的定义与使用

1.类的定义:

2.构造函数(__init__)

3.实例变量

4.类变量

5.方法(实例方法)

6.类方法(@classmethod)

6.1类方法的其他参数

注6.2:类方法与实例方法的比较

7.静态方法(@staticmethod)

注:7.1静态方法与实例方法,类方法的比较

8.属性装饰器(@property)

9.私有属性与方法

10.继承

10.1单继承:

10.2多继承:

注:10.1方法解析顺序

11.多态

11.1多态与鸭子类型

12.方法重写

13.super()函数

13.1多继承中的super()

14.类的文档字符串

15.类的属性和方法的访问控制

16.其他

16总结

相关文章

赞助商

阅读排行

2.构造函数(init)