时间戳

首页 > 解决方案 > 使用范围 JAVA 添加所有奇数的总和

java - 使用范围 JAVA 添加所有奇数的总和

问题描述

我有一个问题，我有正确的（第 1 部分）和不正确的代码（第 2 部分）。我无法弄清楚为什么不正确的代码不正确。

这

static int sum = 0

part 是 PART 2 中代码的错误部分。如果该行代码移动到 PART 1 的相同位置。代码有效。

如果范围是 10 到 20。第 2 部分输出错误的总和 111。总和应该是 75。有 3 种可能的组合可以得到 111。

18 + 18 + correct sum
17 +19 + correct sum
16 + 20 + correct sum

我猜第 2 部分通过 18 + 18？但如何？！

第 1 部分 正确代码

ublic class SumOddRange {

public static boolean isOdd(int number){
    if (number <= 0) {
        return false;
    }
    
    return number % 2 != 0;
    
}

public static int sumOdd(int start, int end){
    if ( (end < start) || (start < 0) || (end < 0) ){
        return -1;
    }
    int sum = 0;
    
    for (int i = start; i<=end; i++){
        if (isOdd(i)){
            sum +=i;
        }
    }
    return sum;
    
}

第 2 部分 错误代码

public class SumOddRange {



public static boolean isOdd(int number) {
    if((number > 0) && (number % 2 != 0)) {

        return true;
    }
    else {

        return false;
    }
}

static  int startOne = 0;
static int sum = 0;
public static int sumOdd(int start, int end) {
    if ((end >= start) && (end > 0) && (start > 0)) {

        for (startOne = start; startOne <= end; startOne++) {
            if (isOdd(startOne)) {
                sum += startOne;


            }
        }

        return sum;
    } else

        return -1;
}

标签： javasum

解决方案

问题是您正在使用static变量。

是什么static意思？

在此处输入图像描述

创建类后，您可以创建该类的实例（也称为对象）。当您使用类似的命令时，会发生这种情况

SumOddRange a = new SumOddRange();

SumOddRange b = new SumOddRange();

您可能知道，类中有方法和变量。这些方法和类可以分为

  • 类方法和变量
  • 对象方法和变量（对象变量最常被称为属性）

这意味着某些方法和变量确实属于该类，因此该类的所有实例共享该变量或方法。这就是static用途。因此，如果上图中的类有一个名为 的静态属性staticAttributeName，a.staticAttributeName并且b.staticAttributeName必须相同。

如果变量不是静态的，则该变量不会被实例共享。所有实例都有自己的这个变量的实例。因此，尽管它们的名称相同，但变量中保存的值不必相同。因此，如果上图中的类具有名为 的非静态属性attributeName，a.attributeName则b.attributeName不必相同。

一个例子：

public class Add {
    public static int sum = 0;

    public static void addOne() {
        sum = sum + 1;
    }
}

public class Test {
    public static void main(String[] args) {
        Add a = new Add();
        Add b = new Add();

        a.addOne();
        b.addOne();
        System.out.println("a " + a.sum);
        System.out.println("b " + b.sum);   
    }
}

如您所见，变量sum是静态的。这意味着a.sum和b.sum是相同的。在 main-method 中，我们调用了该方法addOne两次，所以两个输出是“a 2”和“b 2”。

public class Add {
    public int sum = 0;

    public void addOne() {
        sum = sum + 1;
    }
}

public class Test {
    public static void main(String[] args) {
        Add a = new Add();
        Add b = new Add();

        a.addOne();
        b.addOne();
        b.addOne();
        System.out.println("a " + a.sum);
        System.out.println("b " + b.sum);   
    }
}

sum我们现在在类中有一个非静态变量Add。

  • a：我们调用了addOne一次方法，所以第一个输出是“a 1”。
  • b：该方法addOne被调用了两次，所以输出为“b 2”。

解决问题

public class Test {
    public static void main(String[] args) {
        SumOddRange s = new SumOddRange();    //Using class given in PART2 of question
        SumOddRange t = new SumOddRange();
        System.out.println(s.sumOdd(10,20));
        System.out.println(s.sumOdd(10,20));
    }
}

这个类产生输出75和150。是这样的，因为s和t使用相同的变量sum，所以第一次求和是正确的，但第二次计算返回75+sumOdd(10,20) = 75+75 = 150结果。

正如我们现在所知，主要问题是变量是static. 这提出了只使用非静态变量的想法，这是最好的想法：

public class SumOddRange {

    public boolean isOdd(int number) {
        if((number > 0) && (number % 2 != 0)) {
            return true;
        }
        else {
            return false;
        }
    }

    int startOne = 0;
    int sum = 0;
    public int sumOdd(int start, int end) {
        sum = 0;
        if ((end >= start) && (end > 0) && (start > 0)) {
            for (startOne = start; startOne <= end; startOne++) {
                if (isOdd(startOne)) {
                    sum += startOne;
                }
            }
            return sum;
        } else {
            return -1;
        }        
    }
}

sum另一种选择是在实际计算总和之前重置变量。这种方法的缺点是您将无法再访问早期的结果：

static  int startOne = 0;
static int sum = 0;
public static int sumOdd(int start, int end) {
    sum = 0;
    if ((end >= start) && (end > 0) && (start > 0)) {
        for (startOne = start; startOne <= end; startOne++) {
            if (isOdd(startOne)) {
                sum += startOne;
            }
        }
        return sum;
    } else {
        return -1;
    }        
}

推荐阅读