首先，一个简单的例子 - 我的方法看起来像这样（使用问题中的其他所有内容）： 
 
public class Class1D {

    private int degree;
    private int [] coefficient;
    // private double evaluation=0; (Remove this!)

    public Class1D(int degree){
        this.degree =degree;
    }

    public Class1D(int degree, int[] a){

        this.degree =degree;
        this.coefficient = a.clone();
    }

    public int []getCoefficient() {
        return coefficient;  
    }

    public double Evaluathepolynomial(double value){

        // This will be the output:
        double total=0;

        // For each degree..
        for (int i =0; i<this.degree; i++)
        {

            // The current one is..
            double evaluation = Math.pow(value,i) *this.coefficient[i];

            // Add it into the total:
            // (same as total+=evaluation)
            total = total + evaluation;

        }

        // We're done! Return that total:
        return total;

    }
}
 
 这是怎么回事？ 
 
 首先要记住的是变量一次只能保持一件事。 所以，如果你做这样的事情： 
 
double a;
a=1;
a=2;
a=14;

// a is now 14.
 
 A将是14 。 那些其他的路线基本上被忽略了，因为a只会持有你最后决定的任何东西。 
 
 好吧，让我们看看你的原始循环： 
 
 for (int i =0; i<this.degree; i++)
 {
     this.evaluation= Math.pow(value,i) *this.coefficient[i];
     this.evaluation+= evaluation;

 }

 return evaluation;
 
 首先，请记住，它所做的一切都是在循环内重复这些行 - 不管你指定多少次。 因此，为了便于可视化，我们假设“度数”为3并解开循环 - 这意味着复制这些行并删除循环： 
 
 // i=0
 this.evaluation= Math.pow(value,0) *this.coefficient[0];
 this.evaluation+= evaluation;

 // i=1
 this.evaluation= Math.pow(value,1) *this.coefficient[1];
 this.evaluation+= evaluation;

 // i=2
 this.evaluation= Math.pow(value,2) *this.coefficient[2];
 this.evaluation+= evaluation;
 
 其次，值得一提的是， this.evaluation evaluation和evaluation是指同一个变量 。 
 
 希望它开始变得更清楚一些 - 循环的每次迭代都完全覆盖了前一次的结果。 让我们进一步简化它： 
 
// i=0
evaluation=2; // It's 2
evaluation+=evaluation; // 2+2; it's now 4

// i=1
evaluation=10; // It's 10. It's now like that 4 never even happened!
evaluation+=evaluation; // 10+10; it's now 20
 
 这意味着在您的原始代码中， 只有最后一个系数至关重要 。 4度，最后系数为2，那32发生如下： 
 
 this.evaluation= Math.pow(2,3) *2; // 16
 this.evaluation+= evaluation; // evaluation = 16+16 = 32
 
 简单的路线是引入第二个变量，所以解决方案更像这样： 
 
 a=0; // a is now 0

 b=14;
 a+=b; // a is now 14

 b=20;
 a+=b; // a is now 34
 
 或者使用一个变量的其他替代方法是直接将其添加到： 
 
 a+=14; // a is now 14

 a+=20; // a is now 34
 
 这看起来像这样： 
 
total += Math.pow(value,i) *this.coefficient[i];
 
 调试 
 
 希望以上内容帮助我们明确了发生了什么，以及为什么上面的方法和您的答案都有效。 但重要的是，一次一个脚本遍历代码并清楚地说明应该做什么是成功调试的重要组成部分。 许多人发现真的很方便，因为你很快就会发现这种方式出了什么问题。 在println调用中添加断点或添加断点来仔细检查它实际上是否在执行您所描述的内容，这一点至关重要。 

Firstly, a quick example - my approach would look something like this (using everything else in the question):
 
public class Class1D {

    private int degree;
    private int [] coefficient;
    // private double evaluation=0; (Remove this!)

    public Class1D(int degree){
        this.degree =degree;
    }

    public Class1D(int degree, int[] a){

        this.degree =degree;
        this.coefficient = a.clone();
    }

    public int []getCoefficient() {
        return coefficient;  
    }

    public double Evaluathepolynomial(double value){

        // This will be the output:
        double total=0;

        // For each degree..
        for (int i =0; i<this.degree; i++)
        {

            // The current one is..
            double evaluation = Math.pow(value,i) *this.coefficient[i];

            // Add it into the total:
            // (same as total+=evaluation)
            total = total + evaluation;

        }

        // We're done! Return that total:
        return total;

    }
}
 
What's going on?
 
The first thing to keep in mind is that a variable can only hold on to one thing at a time. So, if you do something like this:
 
double a;
a=1;
a=2;
a=14;

// a is now 14.
 
A will be 14. Those other lines are essentially being ignored, because a will only hold whatever it was you set to it last.
 
Alright so let's take a look at your original loop:
 
 for (int i =0; i<this.degree; i++)
 {
     this.evaluation= Math.pow(value,i) *this.coefficient[i];
     this.evaluation+= evaluation;

 }

 return evaluation;
 
Firstly, keep in mind that all it's doing is repeating those lines inside the loop over and over - however many times you specify. So, for easy visualising, let's say "degree" is 3 and unravel the loop - that just means duplicate the lines and remove the loop:
 
 // i=0
 this.evaluation= Math.pow(value,0) *this.coefficient[0];
 this.evaluation+= evaluation;

 // i=1
 this.evaluation= Math.pow(value,1) *this.coefficient[1];
 this.evaluation+= evaluation;

 // i=2
 this.evaluation= Math.pow(value,2) *this.coefficient[2];
 this.evaluation+= evaluation;
 
Secondly, it's also worth mentioning that this.evaluation and evaluation are referring to the same variable.
 
Hopefully it's starting to be a little clearer as to what's going on - each iteration of the loop is completely overwriting the results of the previous one. Let's simplify it further:
 
// i=0
evaluation=2; // It's 2
evaluation+=evaluation; // 2+2; it's now 4

// i=1
evaluation=10; // It's 10. It's now like that 4 never even happened!
evaluation+=evaluation; // 10+10; it's now 20
 
This meant that in your original code, only the last coefficient ever mattered. With a degree of 4 and that last coefficient being 2, that 32 occured like this:
 
 this.evaluation= Math.pow(2,3) *2; // 16
 this.evaluation+= evaluation; // evaluation = 16+16 = 32
 
The simple route is to introduce a second variable, so the solution is more like this:
 
 a=0; // a is now 0

 b=14;
 a+=b; // a is now 14

 b=20;
 a+=b; // a is now 34
 
Or the other alternative using one variable is to directly add it in:
 
 a+=14; // a is now 14

 a+=20; // a is now 34
 
That would look like this:
 
total += Math.pow(value,i) *this.coefficient[i];
 
Debugging
 
Hopefully the above helped make it clear what was going on, and why both the approach above and your answer are working. Importantly though, stepping through your code a line at a time and clearly stating what it's supposed to be doing is a big component of successful debugging. Many people find it really convenient to literally speak it out (I know I do!) because you'll very quickly spot what's going wrong that way. Dropping in println calls or adding breakpoints to double check it's actually doing what you describe is vital too.