java - 为什么我的类不调用其他方法？

Question

所以我正在尝试制作一个简单的游戏，例如《财富之轮》/《刽子手》。用户输入 1 输入字母，输入 2 求解，输入 3 退出。当我输入字母时，出现错误:

Enter your choice: 
(1) to guess a letter
(2) to solve the puzzle
(3) to quit
1
Please enter your letter
b
Exception in thread "main" java.lang.StringIndexOutOfBoundsException: String index out of range: 8
    at java.lang.AbstractStringBuilder.charAt(Unknown Source)
    at java.lang.StringBuilder.charAt(Unknown Source)
    at Puzzle.<init>(Puzzle.java:68)
    at PuzzleTester.main(PuzzleTester.java:50)

当我输入解决方案时，我得到了同样的错误。退出选项效果很好。那么这些错误是怎么回事呢？

拼图.java:

/**
 * A puzzle is used to represent a word puzzle.  A puzzle contains a solution
 * and the current state of the puzzle.  The current state of the puzzle is 
 * represented with a hyphen for each letter in the puzzle that has not yet been
 * guessed.  For example if a puzzle is created like this:
 * 
 * Puzzle puzzle = new Puzzle("BIG JAVA");
 * 
 * a call to puzzle.getPuzzle() should return: --- ----
 * 
 * Notice that all letters in the solution were replaced with hyphens but the
 * space character remained in place.
 * 
 * A call to puzzle.guessLetter('b') should return 1 and a subsequent 
 * call to puzzle.getPuzzle() should return: B-- ----
 * 
 * Calling puzzle.guessLetter('b') a second time should return 0 since the
 * letter B has already been guessed and should leave the puzzle unchanged.
 * 
 * <p/>
 * Bugs: (List any known issues or unimplemented features here)
 * 
 * @author (Insert your first and last name)
 * 
 */
public class Puzzle
{
    /** The solution is the complete word or phrase that is to be guessed */
    private String solution="BIG JAVA";


    /**
     * The puzzle is the word or phrase that is to be guessed with hyphens for
     * all unguessed letters. Initially the puzzle should include all hyphens
     * for all letters in the solution. As the user guesses a letter the hyphens
     * for that letter are replaced with the letter.
     */
    private StringBuilder puzzle;


    /**
     * Constructs a new Puzzle object with the given puzzle solution. Puzzles
     * can contain any character and should be case insensitive. This
     * constructor should set the current state of the puzzle so the all letters
     * in the puzzle are set to a hyphen. All non letter values should be left
     * unchanged in the puzzle.  The puzzle should be set to the solution passed
     * in.
     * 
     * @param solution the solution to the puzzle
     */
    public Puzzle(String Solution)
    {
        puzzle=new StringBuilder(this.solution);
        int length= this.solution.length();
        for(int count=0; count<=length; count++)
        {
            if (Character.isLetter(puzzle.charAt(count)))
            {
                puzzle.setCharAt(count, '-');
            }
        }



    }


    /** 
     * The guessLetter method is used to determine how many times the letter
     * that is passed in occurs in the puzzle. If the letter has already been
     * guessed previously, this method should return zero. This method should be
     * case insensitive. In other words 'H' is the same as 'h'.  After a call to
     * to this method the puzzle should be updated to remove the hyphen from
     * the location in the puzzle for each occurrence of the letter.
     * 
     * @param letter
     *            the letter that the user is guessing
     * @return the number of times the letter occurs in the solution only if the
     *         letter has not already been guessed. If the letter has been
     *         previously guessed this method should return 0.
     */
    public int guessLetter(char letter)
    {
        int count = 0;
        int k=this.solution.length();
        solution.equalsIgnoreCase(solution);
        for(int seq=0; seq<=k; seq++)
        {
            if(solution.charAt(seq)==letter)
            {
                count++;                
                puzzle.setCharAt(seq, letter);

            }
        }

        return count;
    }

    /**
     * 
     * The getPuzzle method should return the current state of the puzzle. The
     * puzzle should include a hyphen for any letters that have not been guessed.
     * 
     * @return the current state of the puzzle
     */
    public String getPuzzle()
    {
        String str=new String(puzzle);


        return str;
    }

    /**
     * The solvePuzzle method is used to verify that a solution passed in
     * matches the solution to this puzzle. The check for matching solutions
     * should be case insensitive.
     * 
     * @param solution
     * @return true if the solution passed in matches the solution for the
     *         puzzle
     */
    public boolean solvePuzzle(String solution)
    {
        if(this.solution==solution)
        {
            return true;
        }
        else
        {
            return false;

        }

    }

}

Puzzletester.java:

import java.util.Scanner;
public class PuzzleTester
{

    /**
     * (Insert a brief description that describes the purpose of this method) 
     *
     * @param args
     */
    public static void main(String[] args)
    {
        String str="";

        Scanner input= new Scanner(System.in);


        System.out.println("Enter your choice: ");
        System.out.println("(1) to guess a letter");
        System.out.println("(2) to solve the puzzle");
        System.out.println("(3) to quit");
        int choice=input.nextInt();

        while(choice!=3)
        {           
            if(choice==1)
            {
                System.out.println("Please enter your letter");
                str=input.next();

                char letter=str.charAt(0);
                Puzzle game=new Puzzle(str);
                game.guessLetter(letter);
            }

            if(choice==2)
            {
                System.out.println("Please solve the puzzle");
                input.nextLine();
                String solution=input.next();
                Puzzle game=new Puzzle(solution);
                game.solvePuzzle(solution);
            }


        }

        if(choice==3)
            {
                System.out.println("Good Bye");
            }


    }

}

Answer 1

Puzzle 中的 for 循环类构造函数是罪魁祸首:

for(int count=0; count<=length; count++)

您的条件应该是<而不是<= 。由于您的索引从 0 开始，因此您可以访问的字符串的最后一个索引是 string.length() - 1 。因此你不应该迭代直到 length ，但仅限于值 1 less than length 。

所以，将其更改为:

for(int count=0; count < length; count++)

<小时/>

guessLetter的情况也是如此方法:

for(int seq=0; seq<=k; seq++)  // Change here too

此外，在您的 guessLetter 中仅方法，我不明白您在 for statement 之前试图用此语句做什么:

solution.equalsIgnoreCase(solution);

您没有将该值分配给任何变量，也没有在任何地方使用它。就目前情况而言，上述比较毫无意义。