0

我正在尝试用java编写这个程序。

我可以从构造函数中读取字符串并使用分隔符分隔字符串。但是，每次，我都尝试promote()为这些值调用方法，但值保持不变。布尔方法promote()显示true，但级别并没有增加。

例如：如果来自构造函数的字符串是 : "Harry#wizard#broom"，那么：

name <- "Harry"
level <- "wizard"
supplies <- "broom"

name，level并且broom都是私有数据实例（我不知道我应该使用数据实例还是局部变量）。

但是，每当我调用harry.promote()它返回true但级别保持不变时，它不会得到提升。in 的初始值level似乎覆盖了它。

我写了以下代码：

import java.util.Scanner;
import java.io.*;

public class Magician
{
    private String name;
    private String level;
    private String supplies;
    private double health;
    private int galleons;

    public Magician(String phrase) //phrase will be sth like this: Harry#wizard#broom#staff
    {

        health = 4000;
        galleons = 200;
        Scanner firstScan = new Scanner(details);
        firstScan.useDelimiter("#");
        name = firstScan.next();
        level = firstScan.next();
        if (firstScan.hasNext())
        {
            supplies = firstScan.next(); 
            while (firstScan.hasNext())
            {        
                supplies = supplies + " " + firstScan.next();
            }
        }
        else 
        {
            supplies ="";
        } 

    }
    public String getName()
    {
        return name;
    }
    public String getLevel()
    {
        return level;
    }
    public int getGalleons()
    {
        return galleons;
    }
    public double getHealth()
    {
        return health;
    }
    public String getSupplies()
    {
        return supplies;
    }
    //Mutators 
    public void setName(String nameUpdate)
    {
        name = nameUpdate;
    }
    public void setLevel(String levelUpdate)
    {
        level =levelUpdate;
    }
    public void setGalleons(int galleonsUpdate)
    {
        galleons = galleonsUpdate;
    }
    public void setHealth(double healthUpdate)
    {
        health = healthUpdate;
    }
    public void setSupplies(String suppliesUpdate)
    {
        supplies = suppliesUpdate;
    }
    // boolean promote, promotes a level up
    public boolean promote()
    {
        if (level == "apprentice")
        {
            level = "wizard";
            galleons +=100;
            return true;
        }
        else if (level == "wizard")
        {
            level = "mage";
            galleons +=100;
            return true;
        }
        else if (level == "mage")
        {
            level = "sorcerer";
            galleons +=100;
            return true;
        }
        else if (level == "sorcerer")
        {
            level = "shaman";
            galleons +=100;
            return true;
        }
        else if (level == "shaman")
        {
            return false;
        }
        return true;
    }
    public boolean downgradeLevel()
    {
        if (level == "shaman")
        {
            level = "sorcerer";
            return true;
        }
        else if (level == "sorcerer")
        {
            level = "mage";
            return true;
        }
        else if (level == "mage")
        {
            level = "wizard";
            return true;
        }
        else if (level == "wizard")
        {
            level = "apprentice";
            return true;
        }
        else if (level == "apprentice")
        {
            return false;
        }
        if(galleons>= 100)
        {
            galleons -=100;
        }
        else
        {
            galleons =0;
        }
        return true;
    }
4

3 回答 3

2

我会替换：

    else if (level == "shaman")
    {
        return false;
    }
    return true;

经过：

    else if (level.equals("shaman"))
    {
        return false;
    }

    System.err.println("Invalid/corrupted level name! ['" + level + "']");
    return false;

确实，如果我可以改写您的算法：

if level is upgradable then
    promote it
    return true

if level is top level
    don't do anything
    return false

// we shouldn't be in this place!
// A level is either upgradable or it is the top level...
// if we are, there is some mistake in here
warn user
return false

我也会为downgrade().

true无论您是否添加错误消息，如果您实际上没有执行任何升级/降级操作，则不应返回进行级别升级/降级。

检查意外行为并在适当时引发异常（或至少写入错误输出）通常是一种好习惯。在这种情况下，它可能会在运行时提醒您您从未输入过任何测试，并且您可能会发现问题与字符串的相等性检查有关。

正如@Rafa El和@JB Nizet在评论中所说，您不应该使用==Java 中的字符串进行比较。作为参考，我添加了评论中提供的链接@JB Nizet：如何比较 Java 中的字符串？

注意：为什么不使用 anenum来存储可能的级别？这样你就知道传递给你的关卡对象的字符串不会有任何错误。

public enum Level {
    APPRENTICE,
    WIZARD,
    MAGE,
    SORCERER,
    SHAMAN,
}

接着：

Level level = Level.APPRENTICE;

switch (level) {
    case APPRENTICE:
        level = Level.WIZARD;
        galleons += 100;
        return true;
    case ...:
        ...
}

此外，由于升级/降级只是enum.编辑所有测试用例。

由于这一点有点偏离主题，我将保持简短。如果您遇到问题，请随时要求精度。基本上，您可以使用：

  • enum.toString()（“返回此枚举常量的名称，包含在声明中”），
  • 迭代enum.values()以迭代一个enum值，
  • enum.ordinal()（“返回此枚举常量的序数（它在其枚举声明中的位置，其中初始常量的序数为零）。”）

除了enum文档之外，还有很多示例可以帮助您入门。

于 2014-03-17T08:04:37.887 回答
0

尝试这个：-

// boolean promote, promotes a level up
    public boolean promote()
    {
        if (level.equals("apprentice"))
        {
            level = "wizard";
            galleons +=100;
            return true;
        }
        else if (level.equals("wizard"))
        {
            level = "mage";
            galleons +=100;
            return true;
        }
        else if (level.equals("mage"))
        {
            level = "sorcerer";
            galleons +=100;
            return true;
        }
        else if (level.equals("sorcerer"))
        {
            level = "shaman";
            galleons +=100;
            return true;
        }
        else if (level.equals("shaman"))
        {
            return false;
        }
        return true;
    }

如果您需要从中访问变量，main()则需要将变量声明为静态。

public static void main(String str[]){
        Magician magg=new Magician("Harry#wizard#broom#staff");

        System.out.println("Level before promote is ::"+level);
        magg.promote();
        System.out.println("Level after promote is::"+level);
    }

输出 ：-

Level before promote is ::wizard
Level after promote is::mage

它现在工作。

希望它会帮助你。

于 2014-03-17T11:05:18.730 回答
0

为了改进 JDeveloper 的答案，您可以包含一个包含所有可能的促销值的列表：

private String[] ranks = new String[] {
                    "Apprentice",
                    "Wizard",
                    "Mage",
                    "Sorceror",
                    "Shaman"};

public boolean promote(String existingRank)  {
    // for each rank that exists
    for(int n = 0; n < ranks.size(); n++) {
        // if we find our rank, the next one should be it's promotion
        if(existingRank.equals(ranks[n])) {
            level = ranks[n + 1];
            galleons += 100;
            return true;
        }
    }

    // if we fail to find a promotion, it's failed
    return false;
}

public boolean demote(String existingRank) {
    for(int n = 0; n < ranks.size(); n++) {
        if(existingRank.equals(ranks[n])) {
            level = ranks[n - 1];
            galleons += 100;
            return true;
        }
    }

    return false;
}

您甚至可以将其折叠成一个方法（boolean demote然后控制该level =行）。

OutOfBounds还可以考虑检查数组的长度，这样在提升萨满或降级学徒时不会出现异常:)

于 2014-03-17T11:21:16.777 回答