Java 每次我试图修复代码时都会发生StackOverflowerError

我正在写一个程序，可以添加两个分数。我有3个类：UI、Rechnen和RechnenTest。UI和RechnenTest类已经给出，我必须编写Rechnen类，它添加分数。问题是，程序运行良好，但JUnit测试失败。这些是课程：

import javax.swing.JFrame;
import javax.swing.JOptionPane;
import javax.swing.JTextField;

public class UserInterface {
    public static void main(String[] args) {
        while (true) {
            String[] userData = getData_Dialog();
            if (userData == null)
                break;
            int z1 = 0;
            int n1 = 0;
            int z2 = 0;
            int n2 = 0;
            try {
                z1 = Integer.parseInt(userData[0]);
                n1 = Integer.parseInt(userData[1]);
                z2 = Integer.parseInt(userData[2]);
                n2 = Integer.parseInt(userData[3]);
            } catch (NumberFormatException e) {
                JOptionPane.showMessageDialog(null,
                        "Bitte nur ganze Zahlen eingeben, Nenner != 0");
                continue;
            }
            try {
                JOptionPane.showMessageDialog(null,
                        "Summe: " + Rechnen.bruchAddition(z1, n1, z2, n2));
            } catch (IllegalArgumentException e) {
                JOptionPane
                        .showMessageDialog(null,
                                "Mindestens eine der Zahlen war nicht im vorgebenen Bereich");
            }
        }
        JOptionPane.showMessageDialog(null, "Danke und auf Wiedersehen!");
        System.exit(0);
    }

    private static String[] getData_Dialog() {
        JTextField z1TF = new JTextField();
        JTextField n1TF = new JTextField();
        JTextField z2TF = new JTextField();
        JTextField n2TF = new JTextField();
        Object[] message = { "Zaehler 1", z1TF, "Nenner 1", n1TF, "Zaehler 2",
                z2TF, "Nenner 2", n2TF };
        Object[] options = { "Addition", "Abbruch" };
        int n = JOptionPane.showOptionDialog(new JFrame(), message,
                "Brueche Addieren", JOptionPane.YES_NO_OPTION,
                JOptionPane.QUESTION_MESSAGE, null, options, options[0]);
        if (n == JOptionPane.OK_OPTION) { // Zustimmung
            return new String[] { z1TF.getText(), n1TF.getText(),
                    z2TF.getText(), n2TF.getText() };
        } else if (n == JOptionPane.NO_OPTION // Verneinung
                || n == JOptionPane.CLOSED_OPTION) { // Dialogfenster
                                                        // geschlossen
            return null;
        } else {
            return null;
        }
    }
}

---

语言是德语

---

谢谢

当我自己运行代码时，我得到：

org.junit.ComparisonFailure: expected:<[Zaehler = 1 Nenner = ]1> but was:<[1/]1>

这让我们完成了前三个断言，但随后调用

Rechnen.bruchAddition（-1,3,2,3）

失败，出现

illegargumentexception

。这是因为

bruchAddition

拒绝z1或z2<0的调用

如果您将

bruchAddition

更改为接受负的z1和z2（根据单元测试的要求），那么由于

ggt

递归调用自身，并且显然没有正确结束递归，您将得到一个

java.lang.StackOverflowerError

---

您使用

ggt

、

max

和

min

查找最大公约数的技术似乎已经失败<代码>最小值（1，-3）返回-3。你确定这就是你想要的吗？我感觉您的算法需要在这种情况下返回1，即最小的绝对值。

您的每个断言都应该在自己的单元测试中！你能为我们这些非德语国家的人提供一些翻译吗？这个函数签名中的分子和分母是什么

publicstaticstringbruchaddition（intz1，intn1，intz2，intn2）

正如@dshiga所说，我必须更改

bruchAddition中的返回字符串格式，然后它就工作了。
bruchAddition
接受负的分子，因为测试需要负的分子，但是当我得到
java.lang.StackOverflowerError
时，我不知道如何修复它，这样在运行
JUnit测试时就不会出现任何错误
z1，z2
是分子
n1，n2
是分母。正如你所说，我更改了字符串格式，它成功了。但是我如何修复
java.lang.StackOverflowerr
？如果不知道它试图做什么，很难知道为什么
ggt
会失败。你能编辑这个问题来解释ggt的目的吗？事实上，只有当其中一个论点是否定的时，它才会失败，这表明该案例的逻辑有问题。还可以编辑问题的标题，以澄清测试不应受到责备-某些问题需要在被测试的类中解决。
ggt
是
最大公约数
import static org.junit.Assert.*;
import org.junit.Test;

public class RechnenTest {
    @Test
    public void test() {
        assertEquals("Zaehler = 1 Nenner = 1",
                rechnen.Rechnen.bruchAddition(1, 3, 2, 3));
        assertEquals("Zaehler = 1 Nenner = 1",
                rechnen.Rechnen.bruchAddition(5, 8, 3, 8));
        assertEquals("Zaehler = 1 Nenner = 1",
                rechnen.Rechnen.bruchAddition(10, 16, 3, 8));
        assertEquals("Zaehler = 1 Nenner = 3",
                rechnen.Rechnen.bruchAddition(-1, 3, 2, 3));
        assertEquals("Zaehler = -1 Nenner = 2",
                rechnen.Rechnen.bruchAddition(0, 2, -1, 2));
        assertEquals("Zaehler = -2 Nenner = 3",
                rechnen.Rechnen.bruchAddition(-1, 3, 1, -3));
        try {
            rechnen.Rechnen.bruchAddition(1, 1, 1, 0);
            fail();
        } catch (IllegalArgumentException e) {
            assertTrue(true);
        }
        try {
            rechnen.Rechnen.bruchAddition(Integer.MAX_VALUE, 1, 1, 1);
            fail();
        } catch (IllegalArgumentException e) {
            assertTrue(true);
        }
        assertEquals("Zaehler = 1 Nenner = " + Integer.MAX_VALUE,
                rechnen.Rechnen.bruchAddition(0, Integer.MAX_VALUE, 1,
                        Integer.MAX_VALUE));
    }
}

org.junit.ComparisonFailure: expected:<[Zaehler = 1 Nenner = ]1> but was:<[1/]1>

return "Zaehler = " + m / ggt(m, n) + " Nenner = " + n / ggt(m, n);