1. 首页
  2. 问题列表
  3. 如何打印出这个类的toString？
提问者：小点点

如何打印出这个类的toString？


我写了一个多项式类和一个测试类。当提供度、系数和x的值时，多项式类可以评估并返回多项式的和。基本上我需要编辑我的toString方法，以便它实际打印出多项式

          import java.util.Arrays;
import java.util.Scanner;
public class Polynomial {

private int degree;
private int [] coefficient;
private double evaluation; 
private double sum;
private double value;
Scanner key = new Scanner(System.in);



public Polynomial(int degree)
{
    this.degree = degree;
    coefficient = new int [degree+1];

}


public void setCoefficient(int coefficient) 
{
    this.coefficient[this.degree] = coefficient;
}


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



public double Evaluate(double value)
{
    this.value =value;
    for (int i=0; i<=degree; i++)
    {
        System.out.println("Enter coefficent for position " + i);
        this.coefficient[i] = key.nextInt();
        evaluation = Math.pow(value, i)*this.coefficient[0] ;
        this.sum += evaluation;

    }
        return sum;

}   






/** Standard toString method */
//needed something better than this below...needed an actual polynomial printed out 
public String toString()
{
     return "The degree of the polynomial is " + degree + " and the value for which it has been evaluated is" + value;

}
}

共3个答案

匿名用户

这应该是沿着你应该继续的路线。为了简单起见，我在你的多项式类中包含了main函数，所以如果你想把它保留在你的测试类中，你必须修改它。请注意，度已经被制成一个整数数组，大小为度1（在构造函数中分配）：

import java.util.Scanner;
public class Polynomial {

private int degree;
private int [] coefficient;
private double evaluation; 
private double sum;
Scanner key = new Scanner(System.in);
public Polynomial(int degree)
{
    this.degree = degree;
    coefficient = new int [degree+1];

}

public void setCoefficient(int coefficient, int degree) 
{
    this.coefficient[degree] = coefficient;
}

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

public void Evaluate(double value)
{
    for (int i=0; i<=degree; i++)
    {
        System.out.println("Enter coefficent for position " + i);
        this.coefficient[i] = key.nextInt();
        evaluation = Math.pow(value, i)*this.coefficient[0] ;
        this.sum += evaluation;

    }
}   
public double getSum(){
    return sum;
}

public String toString()
{
    String s = "";
    for (int i=0; i <= degree; i++)
    {
        s += coefficient[i];
        switch (i) {
            case 0:
                s += " + ";
                break;
            case 1:
                s += "x + ";
                break;
            default:
                s += "x^" + i + ((i==degree)?"":" + ");
        }
    }
    return s; 

}

public static void main(String[] args) {

    int degree;
    double sum;
    int coefficient;

    Scanner key = new Scanner(System.in);
    System.out.println("Enter the degree of the polynomial");
    degree=key.nextInt();

    Polynomial fun = new Polynomial(degree);



    fun.Evaluate(3.0);

    System.out.println(" The sum of the polynomial is " + fun.getSum());

    System.out.println(fun);

}

}

匿名用户

使类的对象可打印的通常方法是在类中提供一个toString方法，该方法指定如何将该类的对象表示为String。诸如println和其他输出值的方法如果需要打印该类的对象，将调用该类的toString方法。

您应该对您的Polynomial类采用相同的模式——编写一个带有所有输出逻辑的toString方法。然后在您的PolynomialTester类中，您只需要编写System. out.println（有趣）；其余的就会发生。您会发现这比编写一个实际执行打印的方法更通用。例如，您将能够编写如下内容 

System.out.println("My polynomial is " + fun + " and " + fun + " is my polynomial.");

如果这就是你的乐趣。

关于你的课，我还关心一些其他的事情。

  • 你似乎只存储了一个系数和一个指数。我希望多项式有一个完整的系数数组。
  • 您有评估和sum的字段-但这些只有在评估多项式时才真正有意义。它们不是多项式的长期属性。所以不要将它们存储在字段中。让它们作为评估方法的局部变量，并返回评估结果。
  • 我希望这样的类是不可变的。也就是说，您应该在创建对象时提供所有系数，并且此后永远不要更改它们。如果这样做，则无需编写setter方法。

所以我已经编写了我自己的类版本，它修复了上面列出的那些问题，并实现了一个toString方法，您可以使用它来打印它。toString的第二个版本允许您指定要将哪个字母用于x。我在构造函数中使用了“varargs”，因此您可以使用如下行构造多项式 

Polynomial fun = new Polynomial (7, 2, 5, 0, 1);

指定从常量项到按顺序到指数最高的项的系数。或者您可以只传递一个数组。

请注意，我稍微改变了逻辑——我的版本按常规顺序打印多项式，从最高指数到最低指数。如果系数是整数，它会省略小数。它不会在x前面打印1。它干净地处理-符号。

import java.util.Arrays;

public class Polynomial {

    private double[] coefficients;

    public Polynomial(double... coefficients) {
        this.coefficients = Arrays.copyOf(coefficients, coefficients.length);
    }

    public int getDegree() {
        int biggestExponent = coefficients.length - 1;
        while(biggestExponent > 0 && coefficients[biggestExponent] == 0.0) {
            biggestExponent--;
        }
        return biggestExponent;
    }

    public double getCoefficient(int exponent) {
        if (exponent < 0 || exponent > getDegree()) {
            return 0.0;
        } else {
            return coefficients[exponent];
        }
    }

    public double evaluateAt(double x) {
        double toReturn = 0.0;
        for (int term = 0; term < coefficients.length; term++) {
            toReturn += coefficients[term] * Math.pow(x, term);
        }
        return toReturn;
    }

    @Override
    public String toString() {
        return toString('x');
    }

    public String toString(char variable) {

        boolean anythingAppendedYet = false;
        StringBuilder toReturn = new StringBuilder();

        for (int exponent = coefficients.length - 1; exponent >= 0; exponent--) {
            if (coefficients[exponent] != 0.0) {
                appendSign(toReturn, exponent, anythingAppendedYet);
                appendNumberPart(toReturn, exponent);
                appendLetterAndExponent(toReturn, exponent, variable);
                anythingAppendedYet = true;
            }
        }

        if (anythingAppendedYet) {
            return toReturn.toString();
        } else {
            return "0";
        }
    }

    private void appendSign(StringBuilder toAppendTo, int exponent, boolean anythingAppendedYet) {
        if (coefficients[exponent] < 0) {
            toAppendTo.append(" - ");
        } else if (anythingAppendedYet) {
            toAppendTo.append(" + ");
        }
    }

    private void appendNumberPart(StringBuilder toAppendTo, int exponent) {
        double numberPart = Math.abs(coefficients[exponent]);
        if (numberPart != 1.0 || exponent == 0) {
            //Don't print 1 in front of the letter, but do print 1 if it's the constant term.
            if (numberPart == Math.rint(numberPart)) {
                // Coefficient is an integer, so don't show decimals
                toAppendTo.append((long) numberPart);
            } else {
                toAppendTo.append(numberPart);
            }
        }
    }

    private void appendLetterAndExponent(StringBuilder toAppendTo, int exponent, char variable) {
        if (exponent > 0) {
            toAppendTo.append(variable);
        }

        if (exponent > 1) {
            toAppendTo.append("^");
            toAppendTo.append(exponent);
        }
    }
}

所以我用这门课测试了一下

public class PolynomialTester {
    public static void main(String[] args) {
        Polynomial fun = new Polynomial (7, 2, 5, 0, 1);
        System.out.println(fun.getDegree());
        System.out.println(fun.evaluateAt(3));
        System.out.println(fun);
    }
}

并且输出是

4
139.0
x^4 + 5x^2 + 2x + 7

然后我意识到您希望能够在循环中输入系数。所以我将PolynomialTester更改为这个。看看我如何构建数组然后创建对象。

import java.util.Scanner;

public class PolynomialTester {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.println("Enter the degree:");
        int degree = input.nextInt();

        double[] coefficients = new double[degree + 1];
        for( int exponent = 0; exponent <= degree; exponent++) {
            System.out.println("Enter the coefficient of x^" + exponent);
            coefficients[exponent] = input.nextDouble();
        }
        Polynomial fun = new Polynomial (coefficients);
        System.out.println(fun.evaluateAt(3));
        System.out.println(fun);
        input.close();
    }
}

请注意，如果您真的希望您的多项式以“反向”顺序打印，首先使用常量项，您可以将toString方法中的循环更改为此。

for (int exponent = 0; exponent < coefficients.length; exponent++) {

匿名用户

您可以添加一个类成员String poly，然后修改以下方法。

public void Evaluate(double value)
{
    for (int i=0; i<=degree; i++)
    {
        System.out.println("Enter coefficent for position " + i);
        this.coefficient= key.nextInt();
        evaluation = Math.pow(value, i)*coefficient ;
        this.sum += evaluation;
        this.poly = "";
        if(coefficient != 0)
        {
            if(i > 0)
            {
                this.poly += " + " + Integer.toString(coefficient) + "x^" + Integer.toString(i); // you may replace x with the actual value if you want
            }
            else
            {
                this.poly = Integer.toString(coefficient)
            }
        }
     }
}

相关问题



热门标签
Java JavaScript Python PHP C# Android Html jQuery C++ Css IOS MySQL NodeJS