我正在创建一个最终幻想角色的小游戏，其中我输入了我想要“战斗”的人的名字我将每个角色（只有5个）作为一个名为Stats的超类的子类。定义了变量（非静态）和getter / setter。
代码全部按照我的意愿运作，但我不喜欢它在一个庞大的类中。
主要方法在这里;
package com.George.revision;
import java.util.Random;
import com.George.characters.Cloud;
import com.George.characters.Squall;
import com.George.characters.Stats;
import com.George.characters.TheEnemy;
import com.George.characters.ThePlayer;
import com.George.characters.Tidus;
import com.George.characters.Yuna;
import com.George.characters.Zidane;
import com.George.input.GetInput;
import com.George.input.ListNames;
public class Main {
public static void main(String[] args) {
ListNames.listNames();
Stats clo = new Cloud();
Stats squ = new Squall();
Stats zid = new Zidane();
Stats tid = new Tidus();
Stats yun = new Yuna();
String versus = GetInput.getInput("\nWhich of these Characters would you like to go up against?");
Stats ene1 = new TheEnemy();
switch (versus) {
case "Cloud":
ene1.setName(Names.CLOUD);
ene1.setHairColor(Stats.BLONDE);
ene1.setWep(Weapons.BUSTER_SWORD);
ene1.setSkill(clo.skill);
ene1.setAp(clo.ap);
ene1.setStr(clo.str);
ene1.setMag(clo.mag);
break;
case "Squall":
ene1.setName(Names.SQUALL);
ene1.setHairColor(Stats.BLACK);
ene1.setWep(Weapons.LIONHEART);
ene1.setSkill(squ.skill);
ene1.setAp(squ.ap);
ene1.setStr(squ.str);
ene1.setMag(squ.mag);
break;
case "Zidane":
ene1.setName(Names.ZIDANE);
ene1.setHairColor(Stats.LIGHTBROWN);
ene1.setWep(Weapons.THIEF_DAGGER);
ene1.setSkill(zid.skill);
ene1.setAp(zid.ap);
ene1.setStr(zid.str);
ene1.setMag(zid.mag);
break;
case "Tidus":
ene1.setName(Names.TIDUS);
ene1.setHairColor(Stats.BLONDE);
ene1.setWep(Weapons.CALADBOLG);
ene1.setSkill(tid.skill);
ene1.setAp(tid.ap);
ene1.setStr(tid.str);
ene1.setMag(tid.mag);
break;
case "Yuna":
ene1.setName(Names.YUNA);
ene1.setHairColor(Stats.DARKBROWN);
ene1.setWep(Weapons.NIRVANA);
ene1.setSkill(yun.skill);
ene1.setAp(yun.ap);
ene1.setStr(yun.str);
ene1.setMag(yun.mag);
break;
default:
System.out.println("You did not enter a valid character name");
break;
}
System.out.println("You have chosen to face " + ene1.name);
System.out.println("Enemy Skill = " + ene1.skill + " Enemy Weapon = " + ene1.wep);
System.out.println("Enemy Skill = " + ene1.skill + " Enemy Weapon = " + ene1.wep);
int eneTotal = ene1.skill + ene1.ap + ene1.str + ene1.mag;
Stats player = new ThePlayer();
String plN = GetInput.getInput("What is your name?");
player.playerName = plN;
System.out.println("So Your name is " + player.playerName);
String plWep = GetInput.getInput("What is your Weapon's name?");
player.playerWep = plWep;
System.out.println("So your Weapon is " + player.playerWep);
Random generator = new Random();
int plSkill = generator.nextInt(10);
player.skill = plSkill;
System.out.println("Your skill level is " + player.skill);
Random gn = new Random();
int plAp = gn.nextInt(10 - 5) + 5;
System.out.println("So your Attack Power is " + plAp);
player.ap = plAp;
Random gns = new Random();
int plStr = gns.nextInt(10);
System.out.println("So your Strength is " + plStr);
plStr = player.str;
Random gnm = new Random();
int plMag = gnm.nextInt(10 - 5) + 5;
player.mag = plMag;
System.out.println("So your Magic is " + player.mag);
int plHax = 15;
double doubleResult = plHax;
double ene1Hax = 3.99;
int intResult = (int)ene1Hax;
double doubleValue = 6.99;
Double doubleObj = new Double(doubleValue);
int intR = doubleObj.intValue();
System.out.println(intR);
int plyrTotal = player.skill + player.ap + player.str + player.mag;
if (plyrTotal > eneTotal) {
System.out.println("Congratulations you beat " + ene1.name + " Please Play Again!" );
} else if (plyrTotal == eneTotal) {
System.out.println("You drew with " + ene1.name + " Play again and Win!");
}
else
{
System.out.println("You were not succesful this time " + ene1.name + " Defeated you by " + (eneTotal - plyrTotal) + " Please Try Again");
}
}
}
在此之后，我有更多的代码为玩家“统计数据”和角色生成随机数，然后匹配他们的统计数据的总值来确定我想要放入的“胜利者”单独的课程。我的问题是，
如何在一个单独的类中使用在Main类的switch语句中输入的值获取ene1。
为了清晰起见，已更新为完整的主要方法
答案 0 :(得分：1)
您遇到的一个问题是您将Enemy指定为Stats的子类，但与您的角色无关。因此，虽然敌人具有与角色相同的属性，但它与角色没有任何关系。而不是复制所有这些值，如名称和颜色，而是让Enemy拥有一个Stats值的自己的实体，它与stats共享一个接口。然后敌人可以使用该接口调用Stats类中的各种方法。
public class Static implements Actions{
// ...
}
public class Enemy implements Actions{
private Static characterType;
}
另外，为了将来参考，您能否设计一下您的问题更通用？它不仅可以帮助那些不理解参考文献的人，也可以让有类似问题的人更容易找到这个。
答案 1 :(得分：0)
您可以将其传递给该类的方法（或构造函数），就像传递任何其他变量或文本一样。即。
clo.setOpponent(ene1);
然后让setOpponent的实现像这样
class Stats
{
private Stats opponent;
//ALL OF YOUR OTHER CODE AND METHODS GO HERE
public void setOpponent(Stats enemy)
{
opponent = enemy;
}
}
这没有考虑到您的应用程序的OO设计不佳，它只回答您的问题。更好的设计带来更多的练习和一些学习（查找IS-A和HAS-A关系以帮助进行基本的OO设计）
答案 2 :(得分：0)
在您的特定示例中，我建议为敌人设置Enumerations，而不是使用类层次结构，因为您为所有敌方实体获得了相同的字段，而您在此处没有使用任何外部存储（例如DB，文件或无论）。
当您有多个具有相似性和区别性的实体时，类层次结构更适合于这种情况。例如，你可以为常规敌人设置一个类，为一些具有一些超级技能的“强制”敌人设置一个类，因此第二个类将继承第一个类并且将有一个额外的字段。这允许您减少代码重复并提供足够的灵活性。此外，当您希望将此实体保存在某些存储中时，类层次结构可为您提供更多好处，例如DB。
但在你的情况下，使用单个Enum来拥有一些敌人更为合乎逻辑，这些敌人对应用程序进行了“硬编码”。我建议下一个解决方案：
public enum Enemy {
CLOUD("Cloud", "Red", "Sword", 10),
SQUALL("Cloud", "Black", "Minigun", 999)
// and so on
;
public String name;
public String hairColor;
public String wep;
public int skill;
Enemy(String name, String hairColor, String wep, int skill /* and so on */) {
this.name = name;
this.hairColor = hairColor;
this.wep = wep;
this.skill = skill;
}
public static Enemy getByName(String name) {
for (Enemy enemy : Enemy.values()) {
if (enemy.name.equalsIgnoreCase(name)) {
return enemy;
}
}
throw new IllegalArgumentException("Enemy with the name `" + name + "` doesn't exist.");
}
}
然后可以通过其键名初始化主类中的敌人：
String versus = GetInput.getInput("\nWhich of these Characters would you like to go up against?");
try {
Enemy enemy = Enemy.getByName(versus);
} catch (IllegalArgumentException e) { // processing incorrect input
System.out.println(e.getMessage());
}
然后你可以将这个常量传递给任何其他类来处理它并计算你想要的任何东西：
public class FightCalculator {
public int calculateScore(Enemy enemy) {
// Some calculations here...
}
}
答案 3 :(得分：0)
创建单独的Hero和Enemy类可能会有所帮助。或者如果你的角色不是“好”或“坏”的人，也许只是一个Character类。对于以下讨论，我将只使用Character，但您可以将其替换为Hero或Enemy，并且它仍然有意义。
首先，Character和Stats之间的关系是什么。我认为Characater 有一个 Stats。这意味着Character应该具有Stats类型的成员变量：
class Character {
private Stats stats = new Stats();
}
现在，您可以为Stats添加一个新的Character对象的构造函数。这意味着Character需要为Stats中存储的每个值采用几个参数。这种方法的一个优点是你编写代码只需设置一个Stats对象，然后每个case语句只有一行：
ene1 = new Character(/* all the stats values go here */);
这里的故事的寓意是，当你发现自己重复代码时，你应该考虑编写一个封装重复的方法。