Question

我正在使用Java进行作业，遇到了一个相当独特的问题。基本上，我的包中有两个文件：一个用于测试的驱动程序文件，然后是实际的类文件。我想知道如何从驱动程序/测试文件调用或执行两个类深的语句？（即我们有公共类Hello，在这个类中我们有另一个声明为public class Goodbye的类。我们想在Goodbye中执行语句。）

以下是我的类声明和驱动程序文件的代码。我试图执行的函数是InOrder / PostOrder / PreOrder类。我甚至不确定使用“public void main（String args []）”是否是定义此函数的正确方法。如果您有另外一种方法来定义函数，我愿意接受建议。

驱动程序文件：

package binTreeImprovedTwo;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Random;


/**
 * Class TreeTest.
 */
public class TreeTest {

    /**
     * The main method.
     *
     * @param default arguments
     */
    public static void main (String[] args) {
        BufferedReader br = new BufferedReader (new InputStreamReader(System.in));
        BinTree tree = new BinTree();
        int value;
        String loop = "";
        Random randomNumber = new Random();
        System.out.println("Bulding binary tree...");
        for (int i = 1; i <= 10; i++) {
            value = randomNumber.nextInt(100);
            System.out.printf("%d ", value);
            tree.insertNode(tree.root, value);
        }
        while(loop != "quit"){
                System.out.println("\nPlease select a traveral path:");
                System.out.println("(Enter the choice in parenthesis EXACTLY)\n");
                System.out.println("(inorder)Invokes InOrder Traversal");
                System.out.println("(postorder)Invokes PostOrder Traversal");
                System.out.println("(preorder)Invokes PreOrder Traversal");
                System.out.println("(quit)Quits the Program");
                System.out.println("Your choice: ");

                try{
                    loop = br.readLine();
                } catch (IOException ioe) {
                    System.out.println("IO error trying to read your choice!\n");
                    System.exit(1);
                }

                System.out.println("\n");

                if(loop == "inorder"){
                    InOrder.main();     //the calls for executing the statements
                } else if(loop == "postorder"){
                    PostOrder.main();   // ''   
                } else if(loop == "preorder"){
                    PreOrder.main();    // ''
                } else if (loop == "quit");
        }

    }

}

班级声明：

package binTreeImprovedTwo;

import binTreeImprovedTwo.BinTree.Node;

/**
 * Class BinTree.
 */
public class BinTree {

    /** The root. */
    public Node root = new Node(1111);

    /**
     * The Class Node.
     */
    static class Node{

        /** The left. */
        Node left;

        /** The right. */
        Node right;

        /** The data. */
        int data;

        /**
         * Instantiates a new node.
         *
         * @param newData the new data
         */
        public Node(int newData){
            left = null;
            right = null;
            this.data = newData;
        }
    }

    /**
     * Bin tree.
     */
    public void BinTree(){
    }

    /**
     * Insert node.
     *
     * @param root is the root
     * @param value is the value to be inserted
     */
    public void insertNode(Node root, int value){
        if(root.data == 1111){
            root.data = value;
        } else if(value < root.data){
            if(root.left != null){
                insertNode(root.left, value);
            } else {
                root.left = new Node(value);
                }
        } else if(value > root.data){
            if(root.right != null){
                insertNode(root.right, value);
            } else {
                root.right = new Node(value);
            }
        }
    }

    /**
     * Super Class traverse.
     *
     */
    public class Traverse{

        public void left(Node root){
            if(root != null){
                left(root.left);
            }
        }   //end left function

        public void print(){
            System.out.println(" " + root.data);
        }   //end of print function

        public void right(Node root){
            if(root != null){
                right(root.right);
            }
        }   //end right function
    }   //end of class traverse

    public class InOrder extends Traverse{
        public void main(String args[]){
            super.left(root);
            super.print();
            super.right(root);
        }       
    }   //end of InOrder class

    public class PostOrder extends Traverse{
        public void main(String args[]){
            super.left(root);
            super.right(root);
            super.print();
        }
    }   //end of PostOrder class

    public class PreOrder extends Traverse{
        public void main(String args[]){
            super.print();
            super.left(root);
            super.right(root);
        }
    }   //end of PreOrder class
}

Answer 1

看起来您正在将类定义与应用程序中创建的实际对象混合在一起。特别是，如果要调用Node的方法，则需要在代码中查找Node对象。查看您的代码，我发现您可能希望在名为root的Node实例上调用Node方法。

您所做的只是先引用根节点，然后调用方法：

tree.root.<method>

您尚未在Node上定义任何公共方法，因此我不知道您要使用哪个方法名称。

我认为你需要改变你的Traverse API：

对于超类：

    public abstract static class Traverse {
        public abstract void run(Node node);

        protected void print(Node node) {
            System.out.println(" " + node.data);
        }
    }

对于实施。我把它称为AnOrder并留给你决定你想要的订单。

    public static class AnOrder extends Traverse {
        public void run(Node node) {
            run(node.left);
            run(node.right);
            print(node);
        }
    }

这就是你在代码中调用它的方式。创建时：

Traverse traverse = new AnOrder() // or any other XXXOrder based on user input

使用时：

traverse.run(tree.root);

Answer 2

你问的是错误的问题。

我通常不会这样做 - 我主要赞成回答某人提出的问题，但在我认为我比他们更了解问题的情况下，我会例外。

OO编程背后的想法是使用类来表示程序中的“对象”;你可能不会这样做的提示是你的一些类的名称 - 有序，后序等。这些是操作，而不是对象。您可以通过这种方式组织代码，但有些方法可能会更容易找到，并且肯定会更符合大多数其他人的方式。

快速猜测，您的“BinTree”类可以使用这些名称对其进行操作; BinTree类包含代表编程问题中的对象（二叉树）的代码。您可以声明该类型的变量（BinTree树=新BinTree（）;或其他），用它的节点填充它，然后在它上面调用操作（tree.inOrder（））。

static void main（String [] args）不是你正在做的事情的正确方法。这是一个特殊的方法名称;将它放在一个类中可以将该类作为java程序调用，参数来自命令行或等效的。

所以我建议你再试一次 - 在驱动程序类中使用static void main（）;让它创建一个BinTree对象，用节点填充对象，然后调用该类的操作。

Java嵌套类函数

2 个答案: