Java 我如何调用这个程序中的方法？

我试图测试我的程序，看看它是如何工作的，但我不确定如何在main方法中调用它。我尝试过执行Assignment5Solution.findOrder（），但它不起作用。在此问题上的任何帮助都将不胜感激。代码应该记录学生必须参加的课程数量以及每门课程的先决条件（如果有），并对学生应该参加的课程进行正确的排序

package Assignment5;

import java.lang.reflect.Array;
import java.util.*;

/**
 *
 * @author harpe
 */
class Assignment5Solution {

    public int[] findOrder(int numCourses, int[][] prerequisites) {
        int E = prerequisites.length;
        Graph G = new Graph(numCourses);
        for (int i = 0; i < E; i++) {
            G.addEdge(prerequisites[i][1], prerequisites[i][0]);
        } // Graph is constructed

        DFS d = new DFS(G); // depth first search
        return d.reverseDFSorder();
    }

    public class DFS {

        private boolean[] marked;
        private int[] courseOrder; // i.e., reverse post order
        private boolean hasCycle;
        private int index; // index for the array courseOrder, index 0 is for the course taken first, …
        private HashSet<Integer> callStack; // used to detect if there are cycles on the graph

        DFS(Graph G) {
            marked = new boolean[G.V()];
            courseOrder = new int[G.V()];
            index = courseOrder.length - 1; // index 0 of courseOrder will be course taken first, lastIndex will be taken last

            callStack = new HashSet<Integer>(); // HashSet is a hash table, for O(1) search

            for (int v = 0; v < G.V(); v++) { // to visit each node, including those on islands or isolated
                if (!marked[v] && !hasCycle) {
                    dfs(G, v);
                }
            }
        }

        private void dfs(Graph G, int v) {
            marked[v] = true;
            callStack.add(v); // use HashSet to simulate callStack
            for (int w : G.adj(v)) {
                if (!marked[w]) {
                    dfs(G, w);
                } else if (callStack.contains(w)) // search in HashSet is O(1)
                {
                    hasCycle = true; // this is a cycle!
                    break;
                }
            }
            callStack.remove(v);
            courseOrder[index--] = v; // index starts from array length -1, decrease by 1 each time, and then ends at 0
        }

        public int[] reverseDFSorder() {
            if (hasCycle) {
                return new int[0]; // return an empty int array (with size 0)
            }
            return courseOrder;
        }
    } // end of class DFS

    public class Graph {

        private int V;
        private List[] adj;

        Graph(int V) // constructor
        {
            this.V = V;
            adj = new List[V];
            for (int i = 0; i < V; i++) {
                adj[i] = new ArrayList<Integer>();
            }
        }

        public void addEdge(int v, int w) {
            adj[v].add(w);
        }

        public Iterable<Integer> adj(int v) {
            return adj[v];
        }

        public int V() {
            return V;
        }
    } // end of class Graph
} // end of class Solution 

包分配5；
导入java.lang.reflect.Array；
导入java.util.*；
/**
*
*@作者哈珀
*/
类分配5解决方案{
公共int[]查找器（int numCourses，int[][]先决条件）{
int E=先决条件长度；
图G=新图（numCourses）；
for（int i=0；i=v；//索引从数组长度-1开始，每次减少1，然后结束于0
}
public int[]reverseDFSorder（）{
if（hasCycle）{
返回新的int[0]；//返回一个空的int数组（大小为0）
}
返回课程顺序；
}
}//类末DFS
公共类图{
私人INTV；
私人名单；
图（intv）//构造函数
{
这个，V=V；
adj=新列表[V]；
对于（int i=0；i

需要：

public static int[] findOrder(int numCourses, int[][] prerequisites) {}

static关键字意味着您不需要声明类的对象就可以使用它。因此，您可以使用：

Assignment5Solution.findOrder(numCourses, prerequisites) 
//numCourses and prerequisites can be any int and int[][] respectively.

编辑：另一个注意事项是，根据主要方法的位置，您可能需要将class Assignment5Solution设置为具有以下内容的公共类：

public class Assignment5Solution {

它当前受软件包保护，因此只有在同一软件包中才能使用

编辑2：

如果要将其用作非静态方法，则需要执行以下操作（将null和0更改为实值）：

---

这是一个类而不是一个方法，您需要在类内部创建一个方法。如果findOrder（）是类中的一个方法，则根据类的其他部分以及它是否是静态的，以不同的方式调用它。意外删除的代码，请再次检查。我将查看它，但此处的选项卡使其几乎不可读。我得到了这些示例进行测试，如何使用这些值int[][]arr={{1,0}，{2,0}，{3,1}，{3,2}；//尝试更多示例int rows=arr.length；查看我的其他编辑

public class Assignment5Solution {

    Assignment5Solution test = new Assignment5Solution() {};
    int numCourses = 0;
    int [][] prereqs = null;
    int[] reverseOrder = test.findOrder(numCourses, prereqs);