二叉树怎么打印，为什么图中的left和right会报红？

import javax.swing.tree.TreeNode;  //这玩意儿也有导包，可以在非主方法里赋类型啥的
import java.util.ArrayList;
import java.util.List;

public class demoEz94 {  //深度优先搜索跟递归有关跟深度优先搜索也有关
    public static void main(String[] args) {
        Tree bt = new Tree();
        bt.createBinTree(bt.root);
    }



    public List<Integer> solution(TreeNode root){
        List<Integer> res = new ArrayList<Integer>();
        inorder(root, res);
        return res;

    }

    public void inorder(TreeNode root, List<Integer> res){
        if(root == null){
            return;
        }
        inorder(root.left, res);
        res.add(root.val);
        inorder(root.right, res);

    }
}

给你写了个树，然后按照二叉树排序了一个数组，然后按中序遍历打印树的结点值

public class Tree {

    public int value;
    public Tree left;
    public Tree right;

    Tree(int v) {
        value = v;
    }

    public void AddLeft(int v) {
        left = new Tree(v);
    }

    public void AddRight(int v) {
        right = new Tree(v);
    }

    public void Add(int v) {
        if (v < value) {
            if (left == null) {
                AddLeft(v);
            } else {
                left.Add(v);
            }
        } else {
            if (right == null) {
                AddRight(v);
            } else {
                right.Add(v);
            }
        }
    }

    public void Print() {
        if (left != null) {
            left.Print();
        }
        System.out.println(value);
        if (right != null) {
            right.Print();
        }
    }

    public static void main(String[] args) {
        int values[] = new int[] { 4, 2, 3, 1, 5, 6, 2, 7, 8 };
        Tree bt = new Tree(values[0]);
        for (int i = 1; i < values.length; i++) {
            bt.Add(values[i]);
        }
        bt.Print();
    }

}

那问下该怎么改
我旁边只有一个网上copy下来的 Tree类

```java


public class Tree {

    private TreeNode root = null;

    public Tree() {
        root = new TreeNode(1, "A");
    }

    private class TreeNode {
        private int key;
        private String data;
        private boolean isVisted;
        private TreeNode leftChild;
        private TreeNode rightChild;

        public TreeNode(int key, String data) {
            this.key = key;
            this.data = data;
            this.leftChild = null;
            this.rightChild = null;
            this.isVisted = false;
        }
    }

    /**
     * 创建一颗二叉树
     * A
     * B        C
     * D   E            F
     * createBinTree:().
     *
     * @param root
     * @author
     */
    public void createBinTree(TreeNode root) {
        TreeNode newNodeB = new TreeNode(2, "B");
        TreeNode newNodeC = new TreeNode(3, "C");
        TreeNode newNodeD = new TreeNode(4, "D");
        TreeNode newNodeE = new TreeNode(5, "E");
        TreeNode newNodeF = new TreeNode(6, "F");
        root.leftChild = newNodeB;
        root.rightChild = newNodeC;
//        newNodeC.rightChild = newNodeF;
//        newNodeB.leftChild = newNodeD;
//        newNodeB.rightChild = newNodeE;
        root.rightChild.rightChild = newNodeF;
        root.leftChild.leftChild = newNodeD;
        root.leftChild.rightChild = newNodeE;
    }

    public boolean isEmpty() {
        return root == null;
    }

    //树的高度
    public int height() {
        return height(root);
    }

    //节点个数
    public int size() {
        return size(root);
    }

    private int height(TreeNode subTree) {
        if (subTree == null)
            return 0;

        int i = height(subTree.leftChild);
        int j = height(subTree.rightChild);

        return i < j ? j + 1 : i + 1;
    }

    private int size(TreeNode subTree) {
        if (subTree == null)
            return 0;
        return 1 + size(subTree.leftChild) + size(subTree.rightChild);
    }

    //返回双亲节点
    public TreeNode parent(TreeNode element) {
        return (root == null || root == element)
                ? null : parent(root, element);
    }

    public TreeNode parent(TreeNode subTree, TreeNode element) {
        if (subTree == null)
            return null;
        if (subTree.leftChild == element || subTree.rightChild == element) {
            //返回父节点地址
            return subTree;
        }
        TreeNode p;
        //先在左子树中查找，如果左子树中没有找到，则到右子树中查找
        if ((p = parent(subTree.leftChild, element)) != null)
            return p; //递归左子树中搜索
        else
            return parent(subTree.rightChild, element);
    }

    public TreeNode getLeftChildNode(TreeNode element) {
        return element != null ? element.leftChild : null;
    }

    public TreeNode getRightChildNode(TreeNode element) {
        return element != null ? element.rightChild : null;
    }

    public TreeNode getRoot() {
        return root;
    }

    //在释放某个节点时，该节点的左右子树都已经释放，
    //所以应该采用后续遍历，当访问某个节点时将该节点的存储空间释放
    public void distroy(TreeNode subTree) {
        //删除根为subTree的子树
        if (subTree != null) {
            //删除左子树
            distroy(subTree.leftChild);
            //删除右子树
            distroy(subTree.rightChild);
            //删除根节点
            subTree = null;
        }
    }
}

```

你导入了import javax.swing.tree.TreeNode;
这个类里没有left,right,val属性，所以会标红。

Tree 不应该自己定义么，如果是使用javax.swing.tree.TreeNode，它并没有定义left,right,val这些属性，会就是告诉你不对啊。。。