Swift 中的 Java 式枚举

Question

我已经使用 Java 一段时间了，目前正在学习 Swift。在 Java 中，我在创建小游戏作为学习语言的一种方式时使用了相当多的枚举。然而，在这个游戏中开始构建“种族”和“武器”时，我遇到了一个问题。Swift 不像 Java 那样处理枚举。所以我的问题是如何在 Swift 中编写以下 Java 代码，以便以类似的方式使用它。

public enum EnumWeapon {
    WOODEN_SWORD("Wooden Sword", 4),
    STONE_SWORD("Stone Sword", 6), 
    STEEL_SWORD("Steel Sword", 8); 

    private String name;
    private int damage;

    private EnumWeapon(String name, int damage) {
        this.name = name;
        this.damage = damage;
    }

    public String getName() {
        return name;
    }

    public int getDamage() {
        return damage;
    }
}

Answer 1

最明显的方法是：

public enum EnumWeapon {
    case WOODEN_SWORD
    case STONE_SWORD
    case STEEL_SWORD

    func getName() -> String {
        switch self {
        case WOODEN_SWORD:  return "Wooden Sword"
        case STONE_SWORD:   return "Stone Sword"
        case STEEL_SWORD:   return "Steel Sword"
        }
    }

    func getDamage() -> Int {
        switch self {
        case WOODEN_SWORD:  return 4
        case STONE_SWORD:   return 6
        case STEEL_SWORD:   return 8
        }
    }
}

如果您有一个值与每个枚举案例关联，您可以使用原始值语法，或者仅使用它来简化上面的枚举案例：

public enum Weapon : Int {
    case WOODEN_SWORD = 4
    case STONE_SWORD = 6
    case STEEL_SWORD = 8

    func getDamage() -> Int {
        return rawValue
    }

    func getName() -> String {
        switch self {
        case .WOODEN_SWORD: return "Wooden Sword"
        case .STONE_SWORD:  return "Stone Sword"
        case .STEEL_SWORD:  return "Steel Sword"
        }
    }
}

显然，如果不需要名称，则可以省略该getName函数。同样，您可以省略该getDamage功能，只需使用weapon.rawValue

一种更简单但更类似于实际 Java 实现的方法是使用结构而不是枚举，如下所示：

public struct Weapon {
    public let name : String
    public let damage : Int

    private init(name:String, damage:Int) {
        self.name = name
        self.damage = damage
    }

    public static let WOODEN_SWORD = Weapon(name: "Wooden Sword", damage: 4)
    public static let STONE_SWORD = Weapon(name: "Stone Sword", damage: 6)
    public static let STEEL_SWORD = Weapon(name: "Steel Sword", damage: 8)
}

并且，重新定义运算符 ==，您可以获得相等比较：

func == (lhs:Weapon, rhs:Weapon) -> Bool {
    return lhs.name == rhs.name && lhs.damage == rhs.damage
}

并且，通过重新定义 operator ~= 您可以按预期切换工作：

func ~= (lhs:Weapon, rhs:Weapon) -> Bool {
    return lhs == rhs
}

func test(sword:Weapon) {
    switch sword {
    case Weapon.STONE_SWORD:    print("stone")
    default:                    print("something else")
    }
}

test(Weapon.STONE_SWORD)

很多选项，主要取决于您真正想要做什么以及需要在枚举中包装多少数据。