Java “错误”；在类“中找不到主（字符串[]）方法”；

获取错误消息：“错误：在类：TreeNode中找不到main（String[]）方法” 我把它保存为“MySearchTree.java” 它编译得很好（javac），但我一碰到java它就会显示这个错误消息。我不知道怎么修理它。假设该程序实现一个二进制搜索树，并有一个泛型类来存储泛型类型的值。并显示一些信息。 对于本计划：

 import java.util.Stack;

// tree node (generic)
// BST Is based comparison so it needs Comparable<T>
class TreeNode<T extends Comparable<T>> {
        T x;
        // left right
        TreeNode<T> left = null, right = null;
        TreeNode<T> parent; // parent node
        boolean leaf = true;
        int height; // height associated with it
        
        public TreeNode(T x) {
                this.x = x;
        }
}

// unbalanced BST (generic)
public class MySearchTree<T extends Comparable<T>> {
        private int parentNodes = 0, leaves = 0; // parent leaf count
        private TreeNode<T> root = null; // root node
        int height = 0; // total height
        
        // add to BST
        public void add(T x) {
                if(root == null) {
                        // first time
                        root = new TreeNode<T>(x);
                        root.height = 1;
                        height = 1;
                } else {
                        // find insertion point
                        TreeNode<T> node = root;
                        while(true) {
                                int c = x.compareTo(node.x);
                                if(c <= 0) {
                                        // put it on left side
                                        if(node.left == null) {
                                                // insert right here
                                                if(node.leaf) {
                                                        parentNodes++; // become a parent node
                                                        leaves--;
                                                }
                                                node.left = new TreeNode<T>(x);
                                                node.left.height = node.height + 1;
                                                height = Math.max(node.left.height, height); // update height
                                                node.leaf = false; // mark as parent
                                                node.left.parent = node;
                                                break;
                                        } else {
                                                // move
                                                node = node.left;
                                        }
                                } else {
                                        // on right side
                                        if(node.right == null) {
                                                // insert right here
                                                if(node.leaf) {
                                                        parentNodes++; // become a parent node
                                                        leaves--;
                                                }
                                                node.right = new TreeNode<T>(x);
                                                node.leaf = false; // mark as parent
                                                node.right.height = node.height + 1;
                                                height = Math.max(node.right.height, height); // update height
                                                node.right.parent = node;
                                                break;
                                        } else {
                                                // move
                                                node = node.right;
                                        }
                                }
                        }
                }
                leaves++;
        }
        
        // finds a key
        public boolean find(T x) {
                TreeNode<T> node = root;
                while(node != null) {
                        int c = x.compareTo(node.x);
                        if(c == 0) {
                                return true;
                        } else if(c < 0) {
                                // on left side
                                node = node.left;
                        } else {
                                // on right side
                                node = node.right;
                        }
                }
                return false;
        }
        
        // pre-computed values
        public int leafCount() {
                return leaves;
        }
        
        public int parentCount() {
                return parentNodes;
        }
        
        public int height() {
                return height;
        }
        
        boolean perfect(TreeNode<T> node) {
                if(node.leaf) {
                        // base case
                        return true;
                } else if(node.left != null && node.right != null) {
                        return perfect(node.left) && perfect(node.right);
                } else {
                        return false; // not perfect
                }
        }
        
        // complete full check
        public boolean isPerfect() {
                // solve recursively
                return perfect(root);
        }
        
        // print all parents
        public void ancestors(T x) {
                TreeNode<T> node = root;
                Stack<T> track = new Stack<>();
                while(node != null) {
                        track.add(node.x);
                        int c = x.compareTo(node.x);
                        if(c == 0) {
                                // found (TODO need to think in case of duplicate values)
                                track.pop();
                                break;
                        } else if(c < 0) {
                                // on left side
                                node = node.left;
                        } else {
                                // on right side
                                node = node.right;
                        }
                }
                System.out.println("Ancestors of " + x);
                while(!track.isEmpty()) {
                        System.out.print(track.pop() + " ");
                }
        }
        
        void inorder(TreeNode<T> node) {
                if(node == null) {
                        return;
                } else {
                        inorder(node.left);
                        System.out.print(node.x + " ");
                        inorder(node.right);
                }
        }
        
        // in order
        public void inOrderPrint() {
                System.out.println("Inorder.");
                inorder(root);
                System.out.println();
        }
        
        void preorder(TreeNode<T> node) {
                if(node == null) {
                        return;
                } else {
                        System.out.print(node.x + " ");
                        preorder(node.left);
                        preorder(node.right);
                }
        }
        
        // in order
        public void preOrderPrint() {
                System.out.println("Preorder.");
                preorder(root);
                System.out.println();
        }
        
        // driver program
        public static void main(String[] args) {
                MySearchTree<Integer> bst = new MySearchTree<Integer>();
                bst.add(50);
                System.out.println("Perfect: " + bst.isPerfect());
                bst.add(20);
                bst.add(80);
                System.out.println("Perfect: " + bst.isPerfect());
                bst.add(90);
                bst.add(75);
                bst.add(100);
                bst.add(120);
                bst.add(70);
                bst.add(85);
                System.out.println("Height: " + bst.height());
                System.out.println("Parents: " + bst.parentCount());
                System.out.println("leaves: " + bst.leafCount());
                System.out.println("Perfect: " + bst.isPerfect());
                System.out.println("Find 100: " + bst.find(100));
                System.out.println("Find 110: " + bst.find(110));
                bst.inOrderPrint();
                bst.preOrderPrint();
                bst.ancestors(100);
        }
}

import java.util.Stack；
//树节点（通用）
//BST基于比较，因此需要可比性
三烯类{
tx；
//左右
TreeNode left=null，right=null；
TreeNode父节点；//父节点
布尔叶=真；
int height；//与之关联的高度
公共树节点（T x）{
这个.x=x；
}
}
//不平衡BST（通用）
公共类MySearchTree{
private int parentNodes=0，leaves=0；//父叶计数
私有树节点root=null；//根节点
int height=0；//总高度
//添加到BST
公共无效添加（T x）{
if（root==null）{
//第一次
根=新的树节点（x）；
根高=1；
高度=1；
}否则{
//查找插入点
树节点=根；
while（true）{
int c=x.compareTo（node.x）；
如果不考虑（cDesign），您的文件似乎已编译并运行。我刚刚将您的文件作为MySearchTree.java保存在一个文件夹中并运行：

javac MySearchTree.java

java MySearchTree

结果是：

Perfect: true
Perfect: true
Height: 5
Parents: 5
leaves: 4
Perfect: false
Find 100: true
Find 110: false
Inorder.
20 50 70 75 80 85 90 100 120
Preorder.
50 20 80 75 70 90 85 100 120
Ancestors of 100
90 80 50

请提供数百行代码，这无助于找出您的问题所在。此外，请正确设置代码格式，这意味着正确的缩进，目前这只是一个问题。java还试图在文件的第一个类中查找
main
-方法。通常，您不应将多个类放在同一个文件中在Java中，不鼓励这样做，只需将
TreeNode
类放在
TreeNode.Java
文件中。然后错误应该消失。最后，请显示用于执行程序的命令。您是如何开始的？
Javamysearchtree
或
Javamysearchtree.Java
？（second不会从文件运行已编译的类，而是以源文件模式启动，即在内存中编译并尝试在该文件中启动第一个类（
TreeNode
））如果使用
java MySearchTree.java