类和对象
在Godot引擎中，GDScript是一种面向对象的脚本语言，它允许开发者通过定义类和创建对象来构建游戏。面向对象编程的核心概念包括类、对象、继承、封装和多态。本节将详细介绍这些概念，并通过具体的例子来展示如何在Godot引擎中使用GDScript编写类和对象。
类的基本概念
类是对象的蓝图，它定义了对象的属性和方法。在GDScript中，类是通过class关键字来定义的。一个类可以包含变量（属性）、函数（方法）和信号（signals）。
定义类
定义一个类的基本语法如下：
class_name class_name:
# 类属性
var attribute1: type = default_value
var attribute2: type = default_value
# 构造函数
func _init():
# 初始化代码
pass
# 类方法
func method1(param1: type, param2: type) -> return_type:
# 方法代码
pass
# 信号
signal signal_name(param1: type, param2: type)
示例：定义一个简单的角色类
假设我们正在开发一个动作游戏，需要定义一个简单的角色类。这个类包含角色的名称、生命值和攻击力，并且有一个攻击方法。
# 角色类
class_name Character:
# 类属性
var name: String
var health: int
var attack_power: int
# 构造函数
func _init(name: String, health: int, attack_power: int):
self.name = name
self.health = health
self.attack_power = attack_power
# 攻击方法
func attack(target: Character):
target.health -= self.attack_power
print(f"{self.name} attacks {target.name} for {self.attack_power} damage.")
if target.health <= 0:
target.die()
# 死亡方法
func die():
print(f"{self.name} has died.")
创建对象
创建对象是通过调用类的构造函数来实现的。在GDScript中，构造函数的名字是_init。
示例：创建角色对象
# 创建两个角色对象
var hero = Character.new("Hero", 100, 20)
var enemy = Character.new("Enemy", 80, 15)
# 打印角色信息
print(f"Hero's health: {hero.health}")
print(f"Enemy's health: {enemy.health}")
# 英雄攻击敌人
hero.attack(enemy)
# 打印角色信息
print(f"Hero's health: {hero.health}")
print(f"Enemy's health: {enemy.health}")
类的继承
在面向对象编程中，继承是一种重要的机制，它允许子类继承父类的属性和方法，并且可以扩展或重写这些属性和方法。在GDScript中，继承是通过extends关键字来实现的。
示例：定义一个带有继承的类
假设我们想要定义一个更强大的角色类，这个角色类继承自Character类，并且增加了一个特殊技能。
# 继承自Character类的更强大角色类
class_name PowerfulCharacter extends Character:
# 新增属性
var special_skill: String
# 重写构造函数
func _init(name: String, health: int, attack_power: int, special_skill: String):
# 调用父类的构造函数
super._init(name, health, attack_power)
self.special_skill = special_skill
# 新增方法
func use_special_skill(target: Character):
print(f"{self.name} uses {self.special_skill} on {target.name}!")
target.health -= self.attack_power * 2
if target.health <= 0:
target.die()
创建继承对象
创建继承对象的方式与创建普通对象类似，只需要调用子类的构造函数即可。
示例：创建强大角色对象
# 创建一个强大角色对象
var powerful_hero = PowerfulCharacter.new("Powerful Hero", 150, 25, "Super Strike")
# 打印角色信息
print(f"Powerful Hero's health: {powerful_hero.health}")
print(f"Enemy's health: {enemy.health}")
# 强大英雄使用特殊技能攻击敌人
powerful_hero.use_special_skill(enemy)
# 打印角色信息
print(f"Powerful Hero's health: {powerful_hero.health}")
print(f"Enemy's health: {enemy.health}")
封装
封装是面向对象编程的另一个重要概念，它通过将数据和方法封装在类中，隐藏内部实现细节，只暴露必要的接口给外部使用。在GDScript中，可以通过使用setget关键字来实现属性的封装。
示例：封装角色的生命值
# 角色类
class_name Character:
# 私有属性
var _health: int
# 公有属性，通过setget关键字封装
var health: int:
set(value):
if value > 0:
_health = value
else:
_health = 0
die()
get:
return _health
var name: String
var attack_power: int
# 构造函数
func _init(name: String, health: int, attack_power: int):
self.name = name
self.health = health
self.attack_power = attack_power
# 攻击方法
func attack(target: Character):
target.health -= self.attack_power
print(f"{self.name} attacks {target.name} for {self.attack_power} damage.")
# 死亡方法
func die():
print(f"{self.name} has died.")
多态
多态是指子类可以重写父类的方法，从而在调用时表现出不同的行为。在GDScript中，多态可以通过方法重写来实现。
示例：多态
假设我们有一个角色类Character和一个子类RangeCharacter，RangeCharacter重写了attack方法以实现远程攻击。
# 角色类
class_name Character:
var name: String
var health: int
var attack_power: int
# 构造函数
func _init(name: String, health: int, attack_power: int):
self.name = name
self.health = health
self.attack_power = attack_power
# 攻击方法
func attack(target: Character):
target.health -= self.attack_power
print(f"{self.name} attacks {target.name} for {self.attack_power} damage.")
if target.health <= 0:
target.die()
# 死亡方法
func die():
print(f"{self.name} has died.")
# 继承自Character类的远程角色类
class_name RangeCharacter extends Character:
# 重写攻击方法
func attack(target: Character):
target.health -= self.attack_power * 0.75
print(f"{self.name} performs a ranged attack on {target.name} for {self.attack_power * 0.75} damage.")
if target.health <= 0:
target.die()
示例：多态的应用
# 创建一个远程角色对象
var ranger = RangeCharacter.new("Ranger", 120, 20)
# 创建一个普通角色对象
var troll = Character.new("Troll", 100, 15)
# 打印角色信息
print(f"Ranger's health: {ranger.health}")
print(f"Troll's health: {troll.health}")
# 远程角色攻击普通角色
ranger.attack(troll)
# 打印角色信息
print(f"Ranger's health: {ranger.health}")
print(f"Troll's health: {troll.health}")
内部类
在GDScript中，可以定义内部类（嵌套类），即在一个类的内部定义另一个类。内部类可以访问外部类的属性和方法，这在某些情况下非常有用。
示例：内部类
假设我们有一个Character类，其中包含一个内部类Weapon，用于表示角色的武器。
# 角色类
class_name Character:
var name: String
var health: int
var attack_power: int
var weapon: Weapon
# 构造函数
func _init(name: String, health: int, attack_power: int, weapon: Weapon):
self.name = name
self.health = health
self.attack_power = attack_power
self.weapon = weapon
# 攻击方法
func attack(target: Character):
target.health -= self.attack_power * self.weapon.damage_multiplier
print(f"{self.name} attacks {target.name} with {self.weapon.name} for {self.attack_power * self.weapon.damage_multiplier} damage.")
if target.health <= 0:
target.die()
# 死亡方法
func die():
print(f"{self.name} has died.")
# 内部类：武器
class_name Weapon:
var name: String
var damage_multiplier: float
# 构造函数
func _init(name: String, damage_multiplier: float):
self.name = name
self.damage_multiplier = damage_multiplier
示例：使用内部类
# 创建一个武器对象
var sword = Character.Weapon.new("Sword", 1.5)
# 创建一个角色对象
var knight = Character.new("Knight", 150, 20, sword)
# 创建一个普通角色对象
var goblin = Character.new("Goblin", 100, 15, Character.Weapon.new("Club", 1.0))
# 打印角色信息
print(f"Knight's health: {knight.health}")
print(f"Goblin's health: {goblin.health}")
# 骑士攻击哥布林
knight.attack(goblin)
# 打印角色信息
print(f"Knight's health: {knight.health}")
print(f"Goblin's health: {goblin.health}")
动态类型
GDScript是一种动态类型语言，这意味着变量的类型可以在运行时改变。虽然动态类型提供了灵活性，但也需要注意类型安全问题。
示例：动态类型
# 动态类型示例
var dynamic_var = 10
print(f"dynamic_var is {dynamic_var} of type {typeof(dynamic_var)}")
# 改变变量类型
dynamic_var = "Hello, World!"
print(f"dynamic_var is {dynamic_var} of type {typeof(dynamic_var)}")
# 改变变量类型为对象
dynamic_var = Character.new("Dynamic Hero", 100, 20)
print(f"dynamic_var is {dynamic_var.name} of type {typeof(dynamic_var)}")
类的静态属性和方法
在GDScript中，可以定义类的静态属性和方法。静态属性和方法属于类本身，而不是类的实例。静态属性和方法通过@staticmethod和@classmethod装饰器来定义。
示例：静态属性和方法
# 角色类
class_name Character:
# 静态属性
@classmethod
var total_characters: int = 0
var name: String
var health: int
var attack_power: int
# 构造函数
func _init(name: String, health: int, attack_power: int):
self.name = name
self.health = health
self.attack_power = attack_power
# 增加静态属性
Character.total_characters += 1
# 攻击方法
func attack(target: Character):
target.health -= self.attack_power
print(f"{self.name} attacks {target.name} for {self.attack_power} damage.")
if target.health <= 0:
target.die()
# 死亡方法
func die():
print(f"{self.name} has died.")
# 减少静态属性
Character.total_characters -= 1
# 静态方法
@staticmethod
func get_total_characters() -> int:
return Character.total_characters
示例：使用静态属性和方法
# 创建两个角色对象
var hero = Character.new("Hero", 100, 20)
var enemy = Character.new("Enemy", 80, 15)
# 打印当前角色总数
print(f"Total characters: {Character.get_total_characters()}")
# 英雄攻击敌人
hero.attack(enemy)
# 打印当前角色总数
print(f"Total characters: {Character.get_total_characters()}")
类的实例化和生命周期
在GDScript中，类的实例化是通过调用构造函数来完成的。类的生命周期包括实例化、使用和销毁。在Godot引擎中，对象的销毁通常是由引擎自动管理的，但也可以通过手动调用queue_free()方法来销毁对象。
示例：类的实例化和生命周期
# 角色类
class_name Character:
var name: String
var health: int
var attack_power: int
# 构造函数
func _init(name: String, health: int, attack_power: int):
self.name = name
self.health = health
self.attack_power = attack_power
print(f"{self.name} is instantiated with {self.health} health and {self.attack_power} attack power.")
# 攻击方法
func attack(target: Character):
target.health -= self.attack_power
print(f"{self.name} attacks {target.name} for {self.attack_power} damage.")
if target.health <= 0:
target.die()
# 死亡方法
func die():
print(f"{self.name} has died.")
# 手动销毁对象
queue_free()
示例：类的生命周期
# 创建两个角色对象
var hero = Character.new("Hero", 100, 20)
var enemy = Character.new("Enemy", 80, 15)
# 英雄攻击敌人
hero.attack(enemy)
# 打印当前角色信息
print(f"Hero's health: {hero.health}")
print(f"Enemy's health: {enemy.health}")
# 敌人死亡
hero.attack(enemy)
# 打印当前角色信息
print(f"Hero's health: {hero.health}")
# Enemy对象已经被销毁，尝试访问会报错
# print(f"Enemy's health: {enemy.health}")
类的信号
信号是Godot引擎中的一种特殊机制，用于在对象之间传递消息。信号可以被其他对象连接，当信号被触发时，连接的函数会被调用。
示例：定义和使用信号
# 角色类
class_name Character:
# 信号
signal health_changed(current_health: int)
var name: String
var health: int
var attack_power: int
# 构造函数
func _init(name: String, health: int, attack_power: int):
self.name = name
self.health = health
self.attack_power = attack_power
# 攻击方法
func attack(target: Character):
target.health -= self.attack_power
print(f"{self.name} attacks {target.name} for {self.attack_power} damage.")
target.health_changed.emit(target.health)
if target.health <= 0:
target.die()
# 死亡方法
func die():
print(f"{self.name} has died.")
示例：连接和触发信号
# 创建两个角色对象
var hero = Character.new("Hero", 100, 20)
var enemy = Character.new("Enemy", 80, 15)
# 连接信号
enemy.connect("health_changed", self, "_on_enemy_health_changed")
# 英雄攻击敌人
hero.attack(enemy)
# 打印当前角色信息
print(f"Hero's health: {hero.health}")
print(f"Enemy's health: {enemy.health}")
# 敌人死亡
hero.attack(enemy)
# 打印当前角色信息
print(f"Hero's health: {hero.health}")
# Enemy对象已经被销毁，尝试访问会报错
# print(f"Enemy's health: {enemy.health}")
# 信号处理函数
func _on_enemy_health_changed(current_health: int):
print(f"Enemy's health is now {current_health}.")
类的自定义属性
在GDScript中，可以通过自定义属性来扩展类的功能。自定义属性可以用于存储额外的数据，或者实现复杂的逻辑。
示例：自定义属性
假设我们想要为角色类增加一个is_alive属性，用于检查角色是否存活。
# 角色类
class_name Character:
var name: String
var health: int
var attack_power: int
# 自定义属性
var is_alive: bool:
get:
return self.health > 0
# 构造函数
func _init(name: String, health: int, attack_power: int):
self.name = name
self.health = health
self.attack_power = attack_power
# 攻击方法
func attack(target: Character):
target.health -= self.attack_power
print(f"{self.name} attacks {target.name} for {self.attack_power} damage.")
if target.health <= 0:
target.die()
# 死亡方法
func die():
print(f"{self.name} has died.")
示例：使用自定义属性
# 创建两个角色对象
var hero = Character.new("Hero", 100, 20)
var enemy = Character.new("Enemy", 80, 15)
# 检查角色是否存活
print(f"Hero is alive: {hero.is_alive}")
print(f"Enemy is alive: {enemy.is_alive}")
# 英雄攻击敌人
hero.attack(enemy)
# 检查角色是否存活
print(f"Hero is alive: {hero.is_alive}")
print(f"Enemy is alive: {enemy.is_alive}")
# 敌人死亡
hero.attack(enemy)
# 检查角色是否存活
print(f"Hero is alive: {hero.is_alive}")
print(f"Enemy is alive: {enemy.is_alive}")
类的单例模式
在某些情况下，我们希望一个类只有一个实例，并且提供一个全局访问点。这种模式称为单例模式。单例模式在Godot引擎中非常有用，特别是在需要全局状态管理或资源管理的情况下。
示例：定义和使用单例模式
假设我们有一个GameManager类，用于管理游戏的全局状态。我们希望在整个游戏中只有一个GameManager实例，并且可以通过全局访问点来获取这个实例。
定义单例类
# 游戏管理类
class_name GameManager:
# 静态变量，用于存储单例实例
@classmethod
var instance: GameManager = null
# 静态方法，用于获取单例实例
@staticmethod
func get_instance() -> GameManager:
if instance == null:
instance = GameManager.new()
return instance
# 私有构造函数，防止外部实例化
func _init():
print("GameManager is instantiated.")
# 游戏开始方法
func start_game():
print("Game started.")
# 游戏结束方法
func end_game():
print("Game ended.")
使用单例类
在其他脚本中，我们可以通过GameManager.get_instance()方法来获取GameManager的单例实例。
# 在其他脚本中使用GameManager单例
var game_manager = GameManager.get_instance()
# 调用游戏管理方法
game_manager.start_game()
# 进行一些游戏逻辑
# ...
# 调用游戏结束方法
game_manager.end_game()
类的注释和文档
在编写复杂的类和方法时，添加注释和文档是非常重要的。注释可以帮助其他开发者理解代码的意图和逻辑，而文档可以提供更详细的使用说明。
示例：类的注释和文档
# 角色类
class_name Character:
"""
Character类表示游戏中的一个角色。
它包含角色的名称、生命值和攻击力，并提供攻击和死亡方法。
"""
var name: String
var health: int
var attack_power: int
# 构造函数
func _init(name: String, health: int, attack_power: int):
"""
初始化一个新的角色实例。
参数:
- name (String): 角色的名称。
- health (int): 角色的生命值。
- attack_power (int): 角色的攻击力。
"""
self.name = name
self.health = health
self.attack_power = attack_power
# 攻击方法
func attack(target: Character):
"""
对目标角色进行攻击。
参数:
- target (Character): 被攻击的目标角色。
"""
target.health -= self.attack_power
print(f"{self.name} attacks {target.name} for {self.attack_power} damage.")
if target.health <= 0:
target.die()
# 死亡方法
func die():
"""
角色死亡时调用的方法。
"""
print(f"{self.name} has died.")
类的私有属性和方法
在面向对象编程中，私有属性和方法是不希望被外部直接访问的。在GDScript中，可以通过在属性或方法名称前加下划线_来表示私有。
示例：私有属性和方法
# 角色类
class_name Character:
# 私有属性
var _health: int
var _attack_power: int
# 公有属性，通过setget关键字封装
var health: int:
set(value):
if value > 0:
_health = value
else:
_health = 0
die()
get:
return _health
var attack_power: int:
set(value):
if value > 0:
_attack_power = value
else:
_attack_power = 0
get:
return _attack_power
var name: String
# 构造函数
func _init(name: String, health: int, attack_power: int):
self.name = name
self.health = health
self.attack_power = attack_power
# 攻击方法
func attack(target: Character):
target.health -= self.attack_power
print(f"{self.name} attacks {target.name} for {self.attack_power} damage.")
# 死亡方法
func die():
print(f"{self.name} has died.")
# 私有方法
func _private_method():
print(f"{self.name} is performing a private action.")
使用私有属性和方法
私有属性和方法不能在类的外部直接访问，只能通过类的公有方法来间接访问。
# 创建一个角色对象
var hero = Character.new("Hero", 100, 20)
# 尝试直接访问私有属性（会报错）
# print(hero._health)
# 通过公有属性访问
print(f"Hero's health: {hero.health}")
# 调用公有方法
hero.attack(hero)
# 尝试直接调用私有方法（会报错）
# hero._private_method()
类的类方法和静态方法
在GDScript中，类方法和静态方法都可以在不创建类实例的情况下调用。类方法可以访问类的属性和方法，而静态方法则不能。
示例：类方法和静态方法
# 角色类
class_name Character:
# 静态属性
@classmethod
var total_characters: int = 0
var name: String
var health: int
var attack_power: int
# 构造函数
func _init(name: String, health: int, attack_power: int):
self.name = name
self.health = health
self.attack_power = attack_power
# 增加静态属性
Character.total_characters += 1
# 攻击方法
func attack(target: Character):
target.health -= self.attack_power
print(f"{self.name} attacks {target.name} for {self.attack_power} damage.")
if target.health <= 0:
target.die()
# 死亡方法
func die():
print(f"{self.name} has died.")
# 减少静态属性
Character.total_characters -= 1
# 类方法
@classmethod
func reset_total_characters():
print("Resetting total characters.")
Character.total_characters = 0
# 静态方法
@staticmethod
func get_total_characters() -> int:
return Character.total_characters
使用类方法和静态方法
# 创建两个角色对象
var hero = Character.new("Hero", 100, 20)
var enemy = Character.new("Enemy", 80, 15)
# 打印当前角色总数
print(f"Total characters: {Character.get_total_characters()}")
# 重置角色总数
Character.reset_total_characters()
# 打印当前角色总数
print(f"Total characters: {Character.get_total_characters()}")
类的类型检查和类型转换
在动态类型语言中，类型检查和类型转换是非常重要的。虽然GDScript是动态类型语言，但也可以通过类型注解和类型检查来提高代码的健壮性和可读性。
示例：类型检查和类型转换
# 角色类
class_name Character:
var name: String
var health: int
var attack_power: int
# 构造函数
func _init(name: String, health: int, attack_power: int):
self.name = name
self.health = health
self.attack_power = attack_power
# 攻击方法
func attack(target: Character):
target.health -= self.attack_power
print(f"{self.name} attacks {target.name} for {self.attack_power} damage.")
# 死亡方法
func die():
print(f"{self.name} has died.")
# 创建一个角色对象
var hero = Character.new("Hero", 100, 20)
# 类型检查
if hero is Character:
print("hero is a Character instance.")
else:
print("hero is not a Character instance.")
# 类型转换
var node = Node.new()
var character: Character = node as Character
# 检查类型转换是否成功
if character:
print("node is successfully converted to Character.")
else:
print("node cannot be converted to Character.")
类的继承和多态的高级用法
在复杂的项目中，继承和多态的高级用法可以大大提高代码的可维护性和灵活性。例如，可以通过接口（抽象类）来定义一组方法，子类必须实现这些方法。
示例：抽象类和接口
# 抽象类：角色
class_name Character:
var name: String
var health: int
var attack_power: int
# 构造函数
func _init(name: String, health: int, attack_power: int):
self.name = name
self.health = health
self.attack_power = attack_power
# 抽象方法
func _attack(target: Character) -> void:
assert(false, "This method should be overridden by subclasses.")
# 抽象方法
func _die() -> void:
assert(false, "This method should be overridden by subclasses.")
# 继承自Character类的战士类
class_name Warrior extends Character:
# 重写攻击方法
func _attack(target: Character):
target.health -= self.attack_power
print(f"{self.name} attacks {target.name} for {self.attack_power} damage.")
if target.health <= 0:
target.die()
# 重写死亡方法
func _die():
print(f"{self.name} has died.")
# 继承自Character类的法师类
class_name Mage extends Character:
# 重写攻击方法
func _attack(target: Character):
target.health -= self.attack_power * 1.5
print(f"{self.name} casts a spell on {target.name} for {self.attack_power * 1.5} damage.")
if target.health <= 0:
target.die()
# 重写死亡方法
func _die():
print(f"{self.name} has been vanquished.")
使用抽象类和接口
# 创建一个战士对象
var warrior = Warrior.new("Warrior", 150, 20)
# 创建一个法师对象
var mage = Mage.new("Mage", 120, 15)
# 创建一个普通角色对象
var goblin = Character.new("Goblin", 100, 15)
# 战士攻击哥布林
warrior._attack(goblin)
# 法师攻击哥布林
mage._attack(goblin)
# 打印当前角色信息
print(f"Warrior's health: {warrior.health}")
print(f" Mage's health: {mage.health}")
print(f"Goblin's health: {goblin.health}")
类的组合
组合是一种设计模式，用于将多个类对象组合在一起，形成更大的对象。在Godot引擎中，组合可以用于创建复杂的节点结构。
示例：组合类
假设我们有一个Character类和一个Inventory类，Character类包含一个Inventory对象。
# 背包类
class_name Inventory:
var items: Array
# 构造函数
func _init():
self.items = []
# 添加物品
func add_item(item: String):
self.items.append(item)
print(f"Added item: {item}")
# 移除物品
func remove_item(item: String):
if item in self.items:
self.items.erase(item)
print(f"Removed item: {item}")
else:
print(f"Item {item} not found in inventory.")
# 角色类
class_name Character:
var name: String
var health: int
var attack_power: int
var inventory: Inventory
# 构造函数
func _init(name: String, health: int, attack_power: int):
self.name = name
self.health = health
self.attack_power = attack_power
self.inventory = Inventory.new()
# 攻击方法
func attack(target: Character):
target.health -= self.attack_power
print(f"{self.name} attacks {target.name} for {self.attack_power} damage.")
if target.health <= 0:
target.die()
# 死亡方法
func die():
print(f"{self.name} has died.")
使用组合类
# 创建一个角色对象
var hero = Character.new("Hero", 100, 20)
# 添加物品
hero.inventory.add_item("Sword")
hero.inventory.add_item("Potion")
# 移除物品
hero.inventory.remove_item("Potion")
# 打印角色信息
print(f"Hero's health: {hero.health}")
print(f"Hero's inventory: {hero.inventory.items}")
# 创建一个普通角色对象
var enemy = Character.new("Enemy", 80, 15)
# 英雄攻击敌人
hero.attack(enemy)
# 打印角色信息
print(f"Hero's health: {hero.health}")
print(f"Enemy's health: {enemy.health}")
总结
通过上述示例，我们展示了如何在Godot引擎中使用GDScript编写类和对象，包括类的基本定义、创建对象、继承、封装、多态、内部类、静态属性和方法、类型检查和转换、抽象类和接口、以及组合类。这些概念和机制是面向对象编程的基础，掌握它们将有助于你更好地组织和管理代码，提高代码的复用性和可维护性。
