<identifier>预期(Java)

Question

我对Java很陌生。我正在编写代码，它将创建Pascal三角的一个对象，以及一种方法，使我能够得到牛顿的二项式因子值。我得到了神秘的“期望”错误，但并没有告诉我太多。我搜索过谷歌等等，但都没有用。我很抱歉，我的母语的评论和类名，但这是导师想要的。我的代码在C++中工作，如果有任何帮助的话。

问题在第17和56行(方法和构造函数)。

下面是这个类的代码：

package kp_lista04_java;

import java.util.List;
import java.util.ArrayList;

class TrojkatPascalaException extends Exception {
    TrojkatPascalaException(String w) {super(w);}
}

class TrojkatPascala {
    private List<List<Integer>> matrix;
    private List<Integer> row_final;
    private List<Integer> row_temporary;

    public int wspolczynnik (int param_r, int param_p) throws (TrojkatPascalaException) {
        // r - numerator wiersza Pascala
        int r = param_r;
        // p - numerator elementu wiersza Pascala
        int p = param_p;
        if (p < 0 || p > r) {
            throw new TrojkatPascalaException("    Element " + p + ": index out of range");
        }
        else {
            // q - wartosc zadanego elementu
            // wiemy, ze zerowe i ostatnie elementy sa zawsze rowne 1
            int q;
            if (p == 0 || p == r) {
                q = 1;
            }
            // wiemy, ze pierwsze i przedostatnie elementy
            // sa rowne numerowi wiersza
            else if (p == 1 || p == r-1) {
                q = r;
            }
            // przejscie (funkcja w rozumieniu matematycznym)
            // miedzy wierszem trojkata Pascala
            // a zapisanym w pamieci wektorem

            // w - numerator elementu wektora
            else {
                int w;
                if (p < Math.ceil((float) r/2)) {
                    w = p - 2;
                }
                else {
                    w = r - p - 2;
                }
                q = matrix.get(r).get(w);
            }
            return q;
        }
    }

    TrojkatPascala (int n_param) throws (TrojkatPascalaException) {
        int n = n_param;
        if (n < 0) {
            throw new TrojkatPascalaException("Row " + n + ": index out of domain");
        }
        else {
            matrix = new ArrayList<List<Integer>>();
            for (int u = 0; u < n + 1; ++u) {
                row_final = new ArrayList<Integer>();
                row_temporary = new ArrayList<Integer>();
                row_final.clear();
                // inicjalizacja - wartosc elementu 2 w wierszu 4
                // elementow zerowych, pierwszych, ostatnich i przedostatnich
                // nie zapamietujemy
                row_final.add( 6 );

                //
                //// petla generujaca odpowiedni wiersz
                //

                // i - numer budowanego wiersza
                for (int i = 5; i < u+1; ++i) {
                    // wektor roboczy
                    row_temporary.clear();

                    // tworzony jest pierwszy element wektora roboczego
                    row_temporary.add(i-1 + row_final.get(0));

                    // j - liczba elementow wektora roboczego
                    // korzystamy z faktu, ze wystarczy zapamietac
                    // ~polowe elementow (wiersze sa symetryczne)
                    int j = Math.ceil((float) i/2) - 2;

                    // r - numer tworzonego elementu wiersza roboczego
                    for (int r = 1; r < j; ++r) {
                        // korzystamy z zaleznosci rekurencyjnej tworzenia
                        // elementow
                        row_temporary.add(row_final.get(r-1) + row_final.get(r));
                    }

                    // w przypadku parzystych wierszy dodajemy dwukrotnosc
                    // ostatniego elementu poprzedniego wiersza
                    // wynika to z faktu, ze wiersze sa symetryczne
                    if (i % 2 == 0) {
                        row_temporary.add(2 * row_final.get(row_final.size() - 1));
                    }

                    // zastepujemy wiersz wejsciowy
                    // wierszem wyjsciowym (roboczym)
                    row_final.clear();
                    row_final = row_temporary;
                    // usuwamy zbedna kopie wiersza roboczego z pamieci
                    row_temporary.clear();
                }
                matrix.add(row_final);
            }
        }
    }
}

以及测试类的代码：

package kp_lista04_java;

public class TrojkatPascalaTest {
    public static void main( String[] arg ) {
        try {

            if (arg.length == 0) {
                throw new TrojkatPascalaException("No arguments were given");
            }

            else {
                TrojkatPascala pascal_triangle;
                // n - zadany numer wiersza      
                int n = Integer.parseInt(arg[0]);
                System.out.println("Row range from " + 0 + " to " + n);
                pascal_triangle = new TrojkatPascala(n);
                // p - zadany numer elementu w zadanym wierszu
                for (int i = 1; i < arg.length; i = i + 2) {
                    try {
                        System.out.println("-----");
                        try {
                            Integer.parseInt(arg[i]);
                        }
                        catch (NumberFormatException e){
                            throw new TrojkatPascalaException("Row " + arg[i] + ": index is not an integer");
                        }
                        int r = Integer.parseInt(arg[i]);
                        if (r < 0 || r > n) {
                            throw new TrojkatPascalaException("Row " + r + ": index out of range");
                        }
                        System.out.println("Row " + r + ":");
                        System.out.println("    Element range from 0 to " + r);
                        try {
                            Integer.parseInt(arg[i+1]);
                        }
                        catch (NumberFormatException e){
                            throw new TrojkatPascalaException("    Element " + arg[i+1] + ": index is not an integer");
                        }
                        int p = Integer.parseInt(arg[i+1]);
                        int elemele = pascal_triangle.wspolczynnik(r, p);
                        System.out.println("    Element " + p + ": " + elemele);
                    }
                    catch (TrojkatPascalaException w) {
                        System.out.println(w.getMessage());
                    }
                }
            }
        }
        catch (TrojkatPascalaException w) {
            System.out.println(w.getMessage());
        }
    }
}

提前谢谢。

Answer 1

方法和构造函数中的Exception不应该有括号。

因此，改变：

public int wspolczynnik (int param_r, int param_p) throws (TrojkatPascalaException) {

至：

public int wspolczynnik (int param_r, int param_p) throws TrojkatPascalaException {

构造函数也是如此。

Answer 2

变化

public int wspolczynnik (int param_r, int param_p) throws (TrojkatPascalaException)

和

TrojkatPascala (int n_param) throws (TrojkatPascalaException)

分别到

public int wspolczynnik (int param_r, int param_p) throws TrojkatPascalaException
TrojkatPascala (int n_param) throws TrojkatPascalaException