实现布尔值而不是not（！）的Java程序

我不理解下面这个问题的额外信用问题。 我已经实现了try-catch语句，看起来效果不错，但是我们的讲师现在希望我们在循环条件中使用

布尔值
变量，而不是数据=0我猜：

while(data!=0.0)

但这怎么行呢？我是否要完全摆脱它，只使用我已经创建的
boolean
？附言：我意识到这可能非常简单，我只是没看到而已

import java.util.*;

public class SumInput {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);

        double data = 1.0;
        double sum = 0.0;
        boolean valid = false;
        while (!valid) {
            try {
                while (data != 0.0) {
                    System.out.print("So far, sum = " + sum
                       + "\nEnter a number or 0 to exit: ");
                    data = input.nextDouble();
                    sum = sum + data;
                    valid = true;
                }
            } catch (InputMismatchException e) {
                System.out.println("Error--please enter a double number");
                input.next();
            } catch (NoSuchElementException e) {
                System.out.println("\nGoodbye!");
                System.exit(0);
            }
        }
        System.out.println("Ending sum: " + sum);
    }
}

我想他想要

public class SumInput {
    public static void main(String... ignored) {
        Scanner input = new Scanner(System.in);
        double sum = 0.0;
        while (true) {
            System.out.println("So far, sum = " + sum);
            System.out.print("Enter 'exit' to exit: ");
            if (!input.hasNextDouble())
                break;
            sum += input.nextDouble();
        }
        System.out.println("Ending sum: " + sum);
    }
}

像

So far, sum = 0.0
Enter 'exit' to exit: 122
So far, sum = 122.0
Enter 'exit' to exit: 232.2
So far, sum = 354.2
Enter 'exit' to exit: 322
So far, sum = 676.2
Enter 'exit' to exit: exit
Ending sum: 676.2

这更清晰、更安全，因为您可能希望对0.0不是最后一个值的值求和

使用此循环，您将能够删除当前的大部分代码。
我想他希望

public class SumInput {
    public static void main(String... ignored) {
        Scanner input = new Scanner(System.in);
        double sum = 0.0;
        while (true) {
            System.out.println("So far, sum = " + sum);
            System.out.print("Enter 'exit' to exit: ");
            if (!input.hasNextDouble())
                break;
            sum += input.nextDouble();
        }
        System.out.println("Ending sum: " + sum);
    }
}

boolean valid = true;
while (valid) {
    if((data =input.nextDouble()) != 0.0)
        valid = true;
    else
       valid = false;

// perform your calculation.
}

像

So far, sum = 0.0
Enter 'exit' to exit: 122
So far, sum = 122.0
Enter 'exit' to exit: 232.2
So far, sum = 354.2
Enter 'exit' to exit: 322
So far, sum = 676.2
Enter 'exit' to exit: exit
Ending sum: 676.2

这更清晰、更安全，因为您可能希望对0.0不是最后一个值的值求和

使用此循环，您将能够删除当前的大部分代码。
我已更新了您的程序，以使用布尔值，而不是讲师期望的（data！=0.0）。请在下面查找程序：

boolean valid = true;
while (valid) {
    if((data =input.nextDouble()) != 0.0)
        valid = true;
    else
       valid = false;

// perform your calculation.
}

import java.util.*;

public class SumInput {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);

        double data = 1.0;
        double sum = 0.0;
        boolean valid = false;
        while (!valid) {
            try {
                while (true) {
                    System.out.print("So far, sum = " + sum
                            + "\nEnter a number or 0 to exit: ");
                    data = input.nextDouble();
                    sum = sum + data;
                    valid = true;
                    if (data == 0.0) {
                        break;
                    }
                }
            } catch (InputMismatchException e) {
                System.out.println("Error--please enter a double number");
                input.next();
            } catch (NoSuchElementException e) {
                System.out.println("\nGoodbye!");
                System.exit(0);
            }
        }
        System.out.println("Ending sum: " + sum);
    }
}

希望它能解决你的问题
 我已更新您的程序，以使用布尔值，而不是您的讲师期望的（data！=0.0）。请在下面查找程序：

import java.util.*;

public class SumInput {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);

        double data = 1.0;
        double sum = 0.0;
        boolean valid = false;
        while (!valid) {
            try {
                while (true) {
                    System.out.print("So far, sum = " + sum
                            + "\nEnter a number or 0 to exit: ");
                    data = input.nextDouble();
                    sum = sum + data;
                    valid = true;
                    if (data == 0.0) {
                        break;
                    }
                }
            } catch (InputMismatchException e) {
                System.out.println("Error--please enter a double number");
                input.next();
            } catch (NoSuchElementException e) {
                System.out.println("\nGoodbye!");
                System.exit(0);
            }
        }
        System.out.println("Ending sum: " + sum);
    }
}

希望它能解决你的问题
 切勿使用双入作为逻辑（停止）条件，尤其是使用
==
或
时=

代码中的一个问题是
data==0.0
将此表示形式转换为双精度表示非常困难，尤其是在执行某些计算时。这是由于

当您使用
0
时，作为停止条件，我将从用户输出中删除该条件，并只留下
Enter
键作为退出循环的唯一方法
 切勿使用双入作为逻辑（停止）条件，尤其是使用
==
或
时=

代码中的一个问题是
data==0.0
将此表示形式转换为双精度表示非常困难，尤其是在执行某些计算时。这是由于

当您使用
0
时，作为停止条件，我将从用户输出中删除该条件，并只留下
Enter
键作为退出循环的唯一方法
 谢谢！！在实现带有中断的if语句时完全被屏蔽。太好了，再次谢谢。谢谢！！在实现带有中断的if语句时完全被屏蔽。很好，再次感谢。0用作用户传递的停止。0用作用户传递的停止。如果检测到相等将意味着后续循环传递将执行与先前循环传递相同的计算，并且如果“错误”，则使用
double
作为早期退出条件通常没有任何错误检测到的不平等不会产生任何负面影响，除了要求计算机做一些可以避免的额外工作之外。如果你是对的，那么这个例子就不会成为问题。在我看来，该示例似乎使用了
double
equality作为唯一的退出条件，而不是早期退出条件。一个更好的场景是
double compute（double init，double param，int reps）{do{double prev=init；init=f（init，param）；if（next==init）break；}while（-reps>0）；return init；}
。如果
f（）
没有副作用，并且不关心+0.0和-0.0之间的区别，那么如果其输出和输入匹配一次，重复调用只会产生相同的结果，也可以跳过。根据
f（）
的性质，当
init
中的更改低于某个阈值时，可能值得退出，但这种方法会增加开发成本（计算出阈值）和每次迭代的运行时成本。如果f（）能够在99.9%的情况下快速稳定下来，那么提前退出是合适的，并且迭代次数不会过多，在快速收敛到接近完美的结果但没有完全达到完美的情况下，容忍一些额外的循环迭代可能是最好的做法。我应该补充一点，在某些类型的模拟中，基于容差提前退出可能会改变模拟的行为。有人可能会认为基于相等的早期退出和基于容差之间的区别就像无损音频压缩和有损压缩之间的区别一样。即使在不能容忍记录数据发生任何变化的情况下，也可以尝试使用无损压缩，这通常会有所帮助。它通常不会像有损压缩那样减少事情，但即使在没有有损压缩的情况下也是安全的。如果检测到相等意味着后续循环过程将执行与早期循环过程相同的计算，则使用
double
作为早期退出条件通常没有任何错误，如果“错误地”检测到不平等性，除了要求计算机做一些可以避免的额外工作之外，不会产生任何负面影响。如果你是对的，那么这个例子就不会是问题。在我看来，该示例似乎使用了
double
equality作为唯一的退出条件，而不是早期退出条件。一个更好的场景是
double compute（double init，double param，int reps）{do{double prev=init；init=f（init，param）；if（next==init）break；}while（-reps>0）；return init；}
。如果
f（）
没有副作用，并且不关心+0.0和-0.0之间的区别，那么如果其输出和输入匹配一次，重复调用只会产生相同的结果，也可以跳过。根据
f（）
的性质，当
init
中的更改低于某个阈值时，退出可能是值得的，但这种方法会增加开发成本（计算阈值）和每次迭代的成本