Java 没有抽象类的抽象方法

我对Java有点陌生，我正在尝试编写一个RPG

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

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

编辑：当我们在做这件事时，如果我想要一个带有标准变量的对象出现一次，有没有什么解决方法可以只为这个对象创建一个类，然后实例化它？

这个怎么样：

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


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

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

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

我只需要一个类，它包含所有方法，但只有选定的方法可供使用。拥有Enum的技能也不是一个坏主意

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类来处理所有事情，并在那里执行所有检查。

我还将使用枚举，您可以在其中填充大量登录信息。地图让每个玩家拥有他们所需要的任何技能和数据。可以像或那样嵌套枚举

import java.util.Map；
导入java.util.Random；
导入java.util.TreeMap；
公共类So36107587{
枚举统计{
食物、健康、魔法；
}
枚举技能{
治愈、伤害、狩猎；
静态无效应用（技能，双倍数量，玩家）{
double a=数量*随机数.nextDouble（），x；
转换（技能）{
病例愈合：
x=玩家.stats.get（Stat.health）；
玩家.stats.put（Stat.health，a+x）；
打破
案件伤害：
x=玩家.stats.get（Stat.health）；
玩家。统计。放置（统计健康，a-x）；
打破
个案搜寻：
x=玩家.stats.get（Stat.food）；
玩家.stats.put（Stat.food，a+x）；
打破
}
}
静态最终随机=新随机（）；
}
静态类播放器{
玩家（）{
init（）；
}
void init（）{
for（Stat:Stat.values（））
统计数据。放置（统计数据，1.）；
for（Skill:Skill.values（））
技能。把（技能，1。）；
}
无效应用（技能，玩家）{
技能。应用（技能，技能。获得（技能），玩家）；
}
@重写公共字符串toString（）{
返回“+”技能“+”统计信息；
}
最终地图统计=新树形图（）；
最终地图技能=新树形图（）；
}
公共静态void main（字符串[]args）{
玩家=新玩家（）；
System.out.println（播放器）；
玩家。应用（技能。治疗，玩家）；
System.out.println（播放器）；
玩家。应用（技能。狩猎，玩家）；
System.out.println（播放器）；
}
}

抽象方法必须在子类中实现。如果没有子类，您将如何实现它们？您需要一个抽象的技能类。每个技能或技能类型或任何可以扩展技能类的东西都有一个具体的applyEffect（）方法。比如说，创建一个DamageSkill1子类，然后在DamageSkill1对象中实例化它似乎是多余的，因为后者将只出现在一个实例中。这有点违背了课程的目的。你必须这样做。这并不是多余的。这样做很好。Minecraft也是这样做的。如果你不喜欢创建命名类，你可以尝试匿名类。不过，它们在堆栈跟踪中看起来更糟糕。这是一个匿名类，对吗？这似乎是最尖锐的方式，但我认为他们只是本地人。这将是一个很大的障碍，因为我需要在类和包之间传递它们。但是你可能想在问题中澄清你的需求。一个有趣的方法。可能比我的好。我担心的是，如果技能至少达到，比如说，100（分散在多个玩家专业中），那么一个玩家等级将变得庞大而笨拙，就像所有的canUseSkill布尔人一样。再一次，我可以像你说的那样，把这些都扔到另一门课上。我认为你的方法是最符合逻辑的，谢谢，如果太复杂的话，你也可以使用接口。

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);
    }
}