1. 概述

在这篇文章中，我们将探讨如何在Java中计算二次方程的解。我们将首先定义什么是二次方程，然后无论是在实数系统还是复数系统中，都会计算其解。

2. 二次方程的解

给定不为零的实数a、b和c，考虑以下二次方程：( ax^2 + bx + c = 0 )。

2.1. 多项式的根

这个方程的解也被称为多项式( ax^2 + bx + c )的根。让我们定义一个Polynom类，并在a系数等于0时抛出IllegalArgumentException：

public class Polynom {

    private double a;
    private double b;
    private double c;

    public Polynom(double a, double b, double c) {
        if (a==0) {
            throw new IllegalArgumentException("a can not be equal to 0");
        }
        this.a = a;
        this.b = b;
        this.c = c;
    }

    // getters and setters
}

我们将在这个方程的实数系统中求解它：为此，我们将寻找一些Double类型的解。

2.2. 复数系统

我们还将展示如何在复数系统中解决这个问题。Java中没有内置的复数表示，所以我们需要自定义一个。我们可以添加一个静态方法ofReal，方便将实数转换。这将在后续步骤中很有帮助：

public class Complex {

    private double realPart;
    private double imaginaryPart;

    public Complex(double realPart, double imaginaryPart) {
        this.realPart = realPart;
        this.imaginaryPart = imaginaryPart;
    }

    public static Complex ofReal(double realPart) {
        return new Complex(realPart, 0);
    }

    // getters and setters
}

3. 计算判别式

判别式Δ = b² – 4ac是二次方程的判别式。 在Java中计算b的平方有两种方法：

将b乘以自身
使用Math.pow函数将其平方

我们选择第一种方法，并在Polynom类中添加一个getDiscriminant方法：

public double getDiscriminant() {
    return b*b - 4*a*c;
}

4. 获取解

根据判别式的值，我们可以知道解的数量并计算它们。

4.1. 判别式为正

如果判别式严格大于0，方程有两个实数解：(-b – √Δ) / 2a 和 (-b + √Δ) / 2a:

Double solution1 = (-polynom.getB() - Math.sqrt(polynom.getDiscriminant())) / (2 * polynom.getA());
Double solution2 = (-polynom.getB() + Math.sqrt(polynom.getDiscriminant())) / (2 * polynom.getA());

在复数系统中，我们只需进行相应的转换：

Complex solution1 = Complex.ofReal((-polynom.getB() - Math.sqrt(polynom.getDiscriminant())) / (2 * polynom.getA()));
Complex solution2 = Complex.ofReal((-polynom.getB() + Math.sqrt(polynom.getDiscriminant())) / (2 * polynom.getA()));

4.2. 判别式等于0

如果判别式等于0，方程有一个唯一的实数解 -b / 2a:

Double solution = (double) -polynom.getB() / (2 * polynom.getA());

同样，在复数系统中，我们需要将解决方案转换为：

Complex solution = Complex.ofReal(-polynom.getB() / (2 * polynom.getA()));

4.3. 判别式为负

如果判别式严格小于0，方程在实数系统中无解。然而，在复数系统中可以求解：解为 (-b – i√-Δ) / 2a 和其共轭 (-b + i√-Δ) / 2a:

Complex solution1 = new Complex(-polynom.getB() / (2* polynom.getA()), -Math.sqrt(-polynom.getDiscriminant()) / 2* polynom.getA());
Complex solution2 = new Complex(-polynom.getB() / (2* polynom.getA()), Math.sqrt(-polynom.getDiscriminant()) / 2* polynom.getA());

4.4. 整理结果

总的来说，让我们构建一个方法，当方程有解时，将解填入一个List。 在实数系统中，这个方法看起来像这样：

public static List<Double> getPolynomRoots(Polynom polynom) {
    List<Double> roots = new ArrayList<>();
    double discriminant = polynom.getDiscriminant();
    if (discriminant > 0) {
        roots.add((-polynom.getB() - Math.sqrt(discriminant)) / (2 * polynom.getA()));
        roots.add((-polynom.getB() + Math.sqrt(discriminant)) / (2 * polynom.getA()));
    } else if (discriminant == 0) {
        roots.add(-polynom.getB() / (2 * polynom.getA()));
    }
    return roots;
}

而在复数系统中，我们将使用：

public static List<Complex> getPolynomRoots(Polynom polynom) {
    List<Complex> roots = new ArrayList<>();
    double discriminant = polynom.getDiscriminant();
    if (discriminant > 0) {
        roots.add(Complex.ofReal((-polynom.getB() - Math.sqrt(discriminant)) / (2 * polynom.getA())));
        roots.add(Complex.ofReal((-polynom.getB() + Math.sqrt(discriminant)) / (2 * polynom.getA())));
    } else if (discriminant == 0) {
        roots.add(Complex.ofReal(-polynom.getB() / (2 * polynom.getA())));
    } else {
        roots.add(new Complex(-polynom.getB() / (2* polynom.getA()), -Math.sqrt(-discriminant) / 2* polynom.getA()));
        roots.add(new Complex(-polynom.getB() / (2* polynom.getA()), Math.sqrt(-discriminant) / 2* polynom.getA()));
    }
    return roots;
}

5. 总结

在这篇教程中，我们了解了如何在Java中处理实数或复数系统下的二次方程求解。

如常，代码可以在GitHub上找到。

Persistence

REST

Security