Question

我是Java的新手，我正在尝试编写各种RPG。

现在，在游戏中玩家角色会有技能。这些可以是非常多样化的，从伤害敌人到治疗玩家以及许多其他事情。创建一个带有抽象applyEffect（）方法的Skill类是有意义的，可以在每个特定技能上定义。

但是，我不能拥有一个包含抽象方法的非抽象类，并且每个技能都应该是Skill类的一个对象，所以它不能是抽象的。显而易见的解决方案是使Skill类抽象化并为每个技能创建一个子类，然后将其实例化为要使用的对象。这种方法似乎有点多余。在这种情况下，还有什么我可以想象的吗？

编辑：虽然我们正在研究它，但如果我想要一个标准变量出现一次的对象，是否有任何解决办法来为一个对象创建一个类然后实例化它？

Answer 1

这个怎么样：

public abstract class Skill {
    public abstract void applyEffect();
}


... somewhere else ... 
Skill dig = new Skill() {
    @Override
    public void applyEffect() {
        doSomeDigging();
    }
};

这个仍然在后台创建一个子类，但你可能会更喜欢它。

Answer 2

我不会把技能（比如'治愈'和'隐藏'）写成课程。我将类视为对象（玩家），将方法视为能力（技能）。像“治疗”或“隐藏”这样的技能显然比方法更好。

我只需要一个具有所有方法的类，但只有所选方法可供使用。拥有枚举技能也不错。

enum Skill {
    HEAL, HIDE, ATTACK, THROW
}

class Player {
    boolean canHeal = false;
    boolean canHide = false;
    boolean canAttack = false;
    boolean canThrow = false;

    Player(Skill[] skills) {
        for(skill : skills) {
            switch(skill) {
                case Skills.HEAL: canHeal = true;
                break;

                case Skills.HIDE: canHide = true;
                break;

                case Skills.ATTACK: canAttack = true;
                break;

                case Skills.THROW: canThrow = true;
                break;

                default: //error
            }
        }
    }

    void heal() {
        [...]
    }
    void hide() {
        [...]
    }
    void attack() {
        [...]
    }
    void throw() {
        [...]
    }
    boolean canHeal() {
        return canHeal;
    }
    boolean canHide() {
        return canHide;
    }
    boolean canAttack() {
        return canAttack;
    }
    boolean canThrow() {
        return canThrow;
    }
}

现在玩家可以被限制为仅使用应该可用的方法。我要做的就是编写一个GameHandler类来处理所有事情并在那里进行所有检查。

Answer 3

我也会使用枚举，你可以在其中填充一堆登录信息。地图让每个玩家拥有他们需要的任何技能和统计数据。您可以嵌套this或that等枚举。

import java.util.Map;
import java.util.Random;
import java.util.TreeMap;
public class So36107587 {
    enum Stat {
        food,health,magic;
    }
    enum Skill {
        heal,hurt,hunt;
        static void apply(Skill skill,double amount,Player player) {
            double a=amount*random.nextDouble(),x;
            switch(skill) {
                case heal:
                    x=player.stats.get(Stat.health);
                    player.stats.put(Stat.health,a+x);
                    break;
                case hurt:
                    x=player.stats.get(Stat.health);
                    player.stats.put(Stat.health,a-x);
                    break;
                case hunt:
                    x=player.stats.get(Stat.food);
                    player.stats.put(Stat.food,a+x);
                    break;
            }
        }
        static final Random random=new Random();
    }
    static class Player {
        Player() {
            init();
        }
        void init() {
            for(Stat stat:Stat.values())
                stats.put(stat,1.);
            for(Skill skill:Skill.values())
                skills.put(skill,1.);
        }
        void apply(Skill skill,Player player) {
            Skill.apply(skill,skills.get(skill),player);
        }
        @Override public String toString() {
            return ""+skills+" "+stats;
        }
        final Map<Stat,Double> stats=new TreeMap<>();
        final Map<Skill,Double> skills=new TreeMap<>();
    }
    public static void main(String[] args) {
        Player player=new Player();
        System.out.println(player);
        player.apply(Skill.heal,player);
        System.out.println(player);
        player.apply(Skill.hunt,player);
        System.out.println(player);
    }
}

没有抽象类的抽象方法

3 个答案: