Java 是否有办法使此用户验证代码更高效和/或更易于阅读？

我正在尝试验证用户输入，这样程序将返回到第一个问题，即如果不是整数且整数不在9-12（包括9-12）范围内，则询问用户分数。有没有“更好”的方法来编写此代码

do
    {
        if (userGrade < 9 || userGrade > 12)
        {
            System.out.println("That is not a valid grade!");
        }

            System.out.printf("Grade (9-12): ");

        while(!enterInfo.hasNextInt())
        {
            System.out.println("That is not a number! Enter in a valid number.");
            enterInfo.next();
        }
        userGrade = enterInfo.nextInt();
    } while (userGrade < 9 || userGrade > 12);

do
{
如果（用户等级<9 | |用户等级>12）
{
System.out.println（“这不是一个有效的分数！”）；
}
系统输出打印F（“等级（9-12）：”；
而（！enterInfo.hasNextInt（））
{
System.out.println（“这不是一个数字！输入一个有效的数字。”）；
enterInfo.next（）；
}
userGrade=enterInfo.nextInt（）；
}而（用户等级<9 | |用户等级>12）；

基本上，我会阅读System.in，当有东西存在时，首先我会尝试转换为整数，然后检查该整数是否在正确的范围内：

package trial;

import java.util.Scanner;

public class TestScan {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        try {
            System.out.println("Please introduce a number:");
            Scanner sc = new Scanner(System.in);
            while(sc.hasNext()){
                String input=sc.next();
                Integer inputInt;
                try{
                    inputInt=Integer.parseInt(input);
                }catch(Exception e){
                    System.out.println("You must introduce a number");
                    continue;
                }
                if(inputInt<9 || inputInt>12){
                    System.out.println("Number must be between 9 and 12 (inclusive)");
                    continue;
                }
                System.out.println("Correct!");
            }
            sc.close();
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

}

包装试验；
导入java.util.Scanner；
公共类测试扫描{
公共静态void main（字符串[]args）{
//TODO自动生成的方法存根
试一试{
System.out.println（“请介绍一个数字：”）；
扫描仪sc=新的扫描仪（System.in）；
while（sc.hasNext（））{
字符串输入=sc.next（）；
整数输入；
试一试{
inputInt=Integer.parseInt（输入）；
}捕获（例外e）{
System.out.println（“您必须引入一个数字”）；
继续；
}
如果（输入12）{
System.out.println（“数字必须介于9和12之间（包括9和12）”）；
继续；
}
System.out.println（“正确！”）；
}
sc.close（）；
}捕获（例外e）{
e、 printStackTrace（）；
}
}
}

值得注意的是，由于从System.in读取，此程序可以从IDE执行，因此您必须在IDE之外执行：

1.-转到TestScan文件夹并编译它：javac TestScan.java

2.-在类修补程序中指定该类以执行它。如果你在C：你可以用

C:>java-classpath C:\workspace\StackOverflow\src-trial.TestScan

if（userGrade<9 | | userGrade>12）
 if (userGrade < 9 || userGrade > 12)
    {
        System.out.println("That is not a valid grade!");
    } else {
     do {
        System.out.printf("Grade (9-12):        
        ");

    while(!enterInfo.hasNextInt())
    {
        System.out.println("That is not a number! Enter in a valid number.");
        enterInfo.next();
    }
    userGrade = enterInfo.nextInt();
} while (userGrade < 9 || userGrade > 12)}

{
System.out.println（“这不是一个有效的分数！”）；
}否则{
做{
系统输出打印F（“9-12级）：
");
而（！enterInfo.hasNextInt（））
{
System.out.println（“这不是一个数字！输入一个有效的数字。”）；
enterInfo.next（）；
}
userGrade=enterInfo.nextInt（）；
}而（用户等级<9 | |用户等级>12）}

要使代码更清晰，可以使用基于类和 方法（顺便说一句，封装是OOP的主要原因）

所以你尽可能把所有东西分成更小的部分，比如方法或类，每个方法都有一个简单的目的。这样，整个程序更易于阅读、理解和维护

例如，请注意scanner对象是如何在readInput方法的本地上下文中使用的

import java.util.InputMismatchException;
import java.util.Scanner;

public class KillerLoop {

private boolean notReady;
private int grade;

public static void main(String[] args) {

    new KillerLoop();

}

/**
 * the default constructor calls the doStuff method
 * which contains the main loop of the program
 */
public KillerLoop() {
    this.notReady = true;
    doStuff();
}

/**
 * the programs main loop
 */
private void doStuff() {
    while (this.notReady) {
        int input = this.readInput();
        this.verifyInput(input);
    }
    System.out.println("Grade " + this.grade + " is a correct grade!");
}

/**
 * verifies a users input
 * if the input is correct, notReady will be set
 * to false so that the programs main loop is left
 * (you could also use an if construct with break for this purpose)
 * @param userGrade the users input
 */
private void verifyInput(int userGrade) {
    if (userGrade < 9 || userGrade > 12) {
        System.out.println("That is not a valid grade!\n" + "Grade (9-12): ");
    } else {
        this.grade = userGrade;
        this.notReady = false;
    }

}

/**
 * this method reads input from the command line
 * and returns an integer if successful
 * @return the users input as integer
 */
private int readInput() {
    Scanner scanner = new Scanner(System.in);
    System.out.println("enter a grade");

    int userGrade = 0;

    try {
        userGrade = scanner.nextInt();
    } catch (InputMismatchException e) {
        System.out.println("That is not a number! Enter in a valid number.");
        this.readInput(); //this recursion might not always be a good idea ;)
    }
    return userGrade;
}
}

import java.util.InputMismatchException；
导入java.util.Scanner；
公共类KillerLoop{
私有布尔未就绪；
私人内部职系；
公共静态void main（字符串[]args）{
新KillerLoop（）；
}
/**
*默认构造函数调用doStuff方法
*它包含程序的主循环
*/
公共杀手环（）{
this.notReady=true；
doStuff（）；
}
/**
*程序主循环
*/
私人无效文件（）{
而（这个，还没准备好）{
int input=this.readInput（）；
这个。验证输入（输入）；
}
System.out.println（“Grade”+this.Grade+“是正确的分数！”）；
}
/**
*验证用户的输入
*如果输入正确，将设置notReady
*设置为false，使程序主循环处于左侧
*（为此，还可以使用带break的if构造）
*@param userGrade用户输入
*/
私有无效验证输入（int userGrade）{
如果（用户等级<9 | |用户等级>12）{
System.out.println（“这不是一个有效的等级！\n”+“等级（9-12）：”；
}否则{
this.grade=userGrade；
this.notReady=false；
}
}
/**
*此方法从命令行读取输入
*如果成功，则返回一个整数
*@返回用户输入的整数
*/
私有int readInput（）{
扫描仪=新的扫描仪（System.in）；
System.out.println（“输入等级”）；
int userGrade=0；
试一试{
userGrade=scanner.nextInt（）；
}捕获（输入不匹配异常e）{
System.out.println（“这不是一个数字！输入一个有效的数字。”）；
this.readInput（）；//这种递归可能并不总是一个好主意；）
}
返回用户等级；
}
}

while条件在do块内重复。它看起来正常，除非在读取了需要调用

enterInfo.nextLine（）

以使用缓冲区中的换行符的任何内容之后。您还可以使用

while（true）

循环和

中断当答案有效时退出。不需要更高效。这里的速率限制步骤是用户的输入速度，而不是此代码。