Java 如何在程序中为具有多个参数的方法指定简单逻辑，而不需要一堆代码？

我正在编写一个多项式类并实现一些简单的方法，但我想实现高阶多项式，而不需要大量增加编写的代码量。到目前为止，内的方法非常简单（例如添加）；但是，如果我向构造函数中添加高阶多项式，那么这些方法必须非常长，才能容纳构造函数将采用的大量参数。我想知道是否有一种更具分析性的方法来实现这些函数，比如直接指定它们的逻辑，而不是仅仅写出它们。 以下是我目前的代码：

class Polynomial {

final static int MAX_DEGREE = 4;

private int x0;
private int x1;
private int x2;
private int x3;
private int x4;

Polynomial() {
    this(0);
}

Polynomial(int x0) {
    this(x0, 0);
}

Polynomial(int x0, int x1) {
    this(x0, x1, 0);
}

Polynomial(int x0, int x1, int x2) {
    this(x0, x1, x2, 0);
}

Polynomial(int x0, int x1, int x2, int x3) {
    this(x0, x1, x2, x3, 0);
}

Polynomial(int x0, int x1, int x2, int x3, int x4) {
    this.x0 = x0;
    this.x1 = x1;
    this.x2 = x2;
    this.x3 = x3;
    this.x4 = x4;
}

public static Polynomial add(Polynomial p1, Polynomial p2) {
    return new Polynomial((p1.x0 + p2.x0), (p1.x1 + p2.x1), (p1.x2 + p2.x2), (p1.x3 + p2.x3), (p1.x4 + p2.x4));
}

public static int getGetx(int i, Polynomial p) {
    if (i == 0) return p.x0;
    else if (i == 1) return p.x1;
    else if (i == 2) return p.x2;
    else if (i == 3) return p.x3;
    else if (i == 4) return p.x4;
    else throw new IllegalArgumentException("Degree called is too big");
}

public static Polynomial negate(Polynomial p) {
    return new Polynomial(-1*p.x0, -1*p.x1, -1*p.x2, -1*p.x3, -1*p.x4);
}

public static Polynomial subtract(Polynomial p1, Polynomial p2) {
    return new Polynomial((p1.x0 - p2.x0), (p1.x1 - p2.x1), (p1.x2 - p2.x2), (p1.x3 - p2.x3), (p1.x4 - p2.x4));
}

public static Polynomial simplePolynomialDerivative(Polynomial p) {
    return new Polynomial(p.x1, 2 * p.x2, 3 * p.x3, 4 * p.x4);
}

public static Polynomial stringToPolynomial(String s) {
    if (s.contains("a") | s.contains("b") | s.contains("c") | s.contains("d") | s.contains("e") | s.contains("f") | s.contains("g") | s.contains("h") | s.contains("i") | s.contains("j") | s.contains("k") | s.contains("l") | s.contains("m") | s.contains("n") | s.contains("o") | s.contains("p") | s.contains("q") | s.contains("r") | s.contains("s") | s.contains("t") | s.contains("u") | s.contains("v") | s.contains("w") | s.contains("y") | s.contains("z") | s.contains("!") | s.contains("@") | s.contains("#") | s.contains("$") | s.contains("%") | s.contains("&"))
        throw new IllegalArgumentException("Polynomials may only include independent variable x and numeric types"); //contains bad stuff
    else {
        //do stuff here
    }
    return new Polynomial();
}

public static void printPolynomial(Polynomial p) {
    for (int i = 0; i <= MAX_DEGREE; i++) {
        if (!(getGetx(i, p) == 0)) {
            if (!(i == 0)) System.out.print(" + ");
            if (i == 0) System.out.print(p.x0);
            else if (i == 1) System.out.print(p.x1 + "x");
            else System.out.print(p.getGetx(i, p) + "x^" + i);
        }
    }
}

public static String polynomialToString(Polynomial p) {
    StringBuilder s = new StringBuilder("");
    for (int i = 0; i <= MAX_DEGREE; i++) {
        if (!(getGetx(i, p) == 0)) {
            if (!(i == 0)) s.append(" + ");
            if (i == 0) s.append(p.x0);
            else if (i == 1) s.append(p.x1).append("x");
            else s.append(p.getGetx(i, p)).append("x^").append(i);
        }
    }
    return s.toString();
}

public static double polynomialSubstitute(double i, Polynomial p) {
    return ((p.x0 + i*p.x1 + (Math.pow(i,2))*p.x2 + (Math.pow(i,3))*p.x3 + (Math.pow(i,4))*p.x4));
}

public static long numericalDerivative(Function f) {

    return 0L;
}

public static void main(String[] args) {
    Polynomial p = new Polynomial(1,5,3,2);
    Polynomial pD = simplePolynomialDerivative(p);
    double k = 0.0;
    for(int i = 1; i<100; i++) {
        k -= polynomialSubstitute(k,p)/polynomialSubstitute(k,pD);

    }
    System.out.println(k);
}
}

类多项式{
最终静态int MAX_度=4；
私人int x0；
私有int-x1；
私人int x2；
私人int x3；
私人int x4；
多项式（）{
这（0）；
}
多项式（int-x0）{
这（x0，0）；
}
多项式（int x0，int x1）{
这（x0，x1，0）；
}
多项式（int x0，int x1，int x2）{
这（x0，x1，x2，0）；
}
多项式（整数x0，整数x1，整数x2，整数x3）{
这（x0，x1，x2，x3，0）；
}
多项式（整数x0，整数x1，整数x2，整数x3，整数x4）{
这是x0=x0；
这是1.x1=x1；
这是0.x2=x2；
这1.x3=x3；
这是0.x4=x4；
}
公共静态多项式加法（多项式p1，多项式p2）{
返回新的多项式（（p1.x0+p2.x0），（p1.x1+p2.x1），（p1.x2+p2.x2），（p1.x3+p2.x3），（p1.x4+p2.x4））；
}
公共静态int getx（int i，多项式p）{
如果（i==0）返回p.x0；
如果（i==1），则返回p.x1；
如果（i==2），则返回p.x2；
如果（i==3），则返回p.x3；
如果（i==4），则返回p.x4；
否则抛出新的非法辩论例外（“学位太大”）；
}
公共静态多项式求反（多项式p）{
返回新多项式（-1*p.x0，-1*p.x1，-1*p.x2，-1*p.x3，-1*p.x4）；
}
公共静态多项式减法（多项式p1，多项式p2）{
返回新的多项式（（p1.x0-p2.x0），（p1.x1-p2.x1），（p1.x2-p2.x2），（p1.x3-p2.x3），（p1.x4-p2.x4））；
}
公共静态多项式单纯形多项式导数（多项式p）{
返回新的多项式（p.x1，2*p.x2，3*p.x3，4*p.x4）；
}
公共静态多项式stringToPolynomial（字符串s）{
如果（s.contains）（a）s.contains（b）s.contains（c）s.contains（d）s.contains（e）s.contains（f）s.contains（g）s.contains（h）s.contains（i）s.contains（j）s.contains（k）s.contains（l）s.contains（m）s.contains（n）s.contains（o）s.contains（o）contains（p）s.contains（q）contains（r）contains（r）|s.contains（t）s.contains（u）s.contains（v）s.contains（w）s.contains（y）s.contains（z）s.contains（！）s.contains（“@”）s.contains（“$”）s.contains（“$”）| s.contains（“%”| s.contains（“&”）
抛出新的IllegalArgumentException（“多项式可能只包含自变量x和数字类型”）；//包含不好的内容
否则{
//在这里做事
}
返回新多项式（）；
}
公共静态空间多项式（多项式p）{
对于（int i=0；i，使用矩阵存储x和y值似乎更友好。与其使用大量x和y变量，不如使用两个保存x和y值的矩阵，并使用一个构造函数初始化列表

int[] xValues;
int[] yValues;

public Polynomial(int[] xValues, int[] yValues){
    this.xValues = xValues;
    this.yValues = yValues;
}

您可以先初始化列表，然后使用计数器变量来确定有多少个坐标点，或者确保在使用类之前向类发送一组列表。
使用矩阵存储x和y值似乎更友好。与其使用大量x和y变量，不如使用两个保存x和y值，并使用一个构造函数初始化列表

int[] xValues;
int[] yValues;

public Polynomial(int[] xValues, int[] yValues){
    this.xValues = xValues;
    this.yValues = yValues;
}

您可以先初始化列表，然后使用计数器变量计算坐标点的数量，或者确保在使用类之前向类发送一组列表。
您也可以这样做。请查找内联注释。
希望这有帮助

    import java.util.Scanner;

    public class Polynomial {
        int[] polyArr; 

        Polynomial(int[] arr) {
            //taking an array as argument in the constructor
            polyArr = new int[arr.length];   //create your polyArr of the same
                                             //length as array in argument 
            for(int i = 0;i < arr.length;i++) {
                polyArr[i] = arr[i];
            }
        }

        public static Polynomial add(Polynomial p1, Polynomial p2) {
            int[] arr = new int[p1.polyArr.length];
            for(int i = 0;i < arr.length;i++) {
                arr[i] = p1.polyArr[i] + p2.polyArr[i];  // merge the two polynomials data in 
                                                        //one array
            }
            return new Polynomial(arr);                 //pass that array while creating new Polynomial 
                                                        //object.
        }

        public static void main(String[] args) {
            //this way you can give you input. Index 0,1,2,3 representing x0, x1, x2, x3 respectively
            int arr[] = {1,2,3,4};
            Polynomial poly = new Polynomial(arr);
        }
    }

import java.util.Scanner；
公共类多项式{
int[]polyArr；
多项式（int[]arr）{
//将数组作为构造函数中的参数
polyArr=new int[arr.length]；//创建相同的polyArr
//参数中数组的长度
对于（int i=0；i
您也可以用这种方式完成。请查找内联注释。
希望这有帮助

    import java.util.Scanner;

    public class Polynomial {
        int[] polyArr; 

        Polynomial(int[] arr) {
            //taking an array as argument in the constructor
            polyArr = new int[arr.length];   //create your polyArr of the same
                                             //length as array in argument 
            for(int i = 0;i < arr.length;i++) {
                polyArr[i] = arr[i];
            }
        }

        public static Polynomial add(Polynomial p1, Polynomial p2) {
            int[] arr = new int[p1.polyArr.length];
            for(int i = 0;i < arr.length;i++) {
                arr[i] = p1.polyArr[i] + p2.polyArr[i];  // merge the two polynomials data in 
                                                        //one array
            }
            return new Polynomial(arr);                 //pass that array while creating new Polynomial 
                                                        //object.
        }

        public static void main(String[] args) {
            //this way you can give you input. Index 0,1,2,3 representing x0, x1, x2, x3 respectively
            int arr[] = {1,2,3,4};
            Polynomial poly = new Polynomial(arr);
        }
    }

import java.util.Scanner；
公共类多项式{
int[]polyArr；
多项式（int[]arr）{
//将数组作为构造函数中的参数
polyArr=new int[arr.length]；//创建相同的polyArr
//参数中数组的长度
对于（int i=0；i