Java嵌套類函數

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對象。 看着你的代碼，我發現你可能想調用Node實例的根節點方法。

你要做的就是你首先引用根節點，然後調用方法：

tree.root.<method> 

您尚未定義節點上的任何公共方法，所以我不知道你要哪種方法名喜歡使用。

---

我認爲你需要改變你的遍歷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

你問錯了問題。

我通常不會這樣做 - 我主要是贊成回答別人問的問題，但在我認爲我比他們更瞭解問題的情況下，我會例外。

面向對象編程的思想是使用類來表示程序中的「對象」;你可能不會這樣做的暗示是你的一些類的名字 - inorder，postorder等。這些是操作，而不是對象。你可以用這種方式來組織你的代碼，但是有些方法你可能會更容易找到，而且肯定會更符合大多數其他人的做法。

快速猜測，您的「BinTree」類可以使用這些名稱對其進行操作; BinTree類包含代表編程問題中的對象（二叉樹）的代碼。您可以聲明該類型的變量（BinTree tree = new BinTree（）;或其他），用它的節點填充它，然後調用它的操作（tree.inOrder（））。

static void main（String [] args）不是正確的方法來做你正在做的事情。這是一個特殊的方法名稱;將它放入一個類中，可以將該類作爲java程序調用，並且參數來自命令行或等價物。

所以我建議你再試一次 - 在驅動類中使用static void main（）讓它創建一個BinTree對象，用節點填充對象，然後調用該類的操作。