不知道如何使用Tree Generic Class实现Comparable接口？

Question

我知道这是一个简单的问题，但基本上我被困在这里。我想编写一个Generic Tree Class（下面），为不同类型的Objects实现Comparable接口。

我想要一个可以对任何对象类型进行实例化的Tree类，但它的内部机制必须依赖于用户提供的compareTo（）方法。到目前为止，这是代码。

[如果您有任何更多信息，请在评论部分告诉我们]

public class Tree<T> implements Comparable<T> {

    private Node<T> root;
    private int size;

    public Tree() {
        root = null;
        size = 0;
    }

    public int compareTo(T t) {
        // ?
    }

    public void insert(T value) {
        root = insert(root, value);
        ++size;
    }

    private Node<T> insert(Node<T> node, T value) {
        if(node==null) {
            node = new Node<T>(value);  
        } else {
            //Fix Comparisons // ?
            if(node.data <= value) {
                 node.left = insert(node.left, value);
            } else { 
                 node.right = insert(node.right, value);
            }
        }
        return node;
    }

    public boolean contains(T value) {
        return contains(root, value);
    }

    private boolean contains(Node<T> node, T value) { //same as lookup
        if(node==null)
            return false;

        if(node.data==value)
            return true;
        else if((Integer)node.data <= (Integer)value)
            return contains(node.left, value);
        else
            return contains(node.right, value);
    }

    public int size() {
        return size;
    }

    public T minValue() {
        return minValue(root);
    }

    private T minValue(Node<T> node) {
        Node<T> current = node;
        while(current.left!=null) {
            current = current.left;
        }
        return current.data;
    }

    public int maxDepth() {
        return maxDepth(root); 
    }

    private int maxDepth(Node<T> node) {
        if(node==null)
            return 0;
        else {
            int lDepth = maxDepth(node.left);
            int rDepth = maxDepth(node.right);

            return(Math.max(lDepth, rDepth)+1);
        }
    }

    public void preOrder() {
        preOrder(root);
    }

    private void preOrder(Node<T> node) {
        System.out.println(node.data);
        if(node.left!=null)
            preOrder(node.left);
        if(node.right!=null)
            preOrder(node.right);
    }

    public void postOrder() {
        postOrder(root);
    }

    private void postOrder(Node<T> node) {
        if(node.left!=null)
            preOrder(node.left);
        if(node.right!=null)
            preOrder(node.right);
        System.out.println(node.data);
    }

    public void inOrder() {
        inOrder(root);
    }

    private void inOrder(Node<T> node) {
        if(node.left!=null)
            inOrder(node.left);
        System.out.println(node.data);
        if(node.right!=null) 
            inOrder(node.right);
    }
}