如何避免使用通配符转换继承的递归类？

Question

1) Suppose you have the following abstract class definition:

abstract class AbstractBinaryTree<T> {
    AbstractBinaryTree<T> parent;
    AbstractBinaryTree<T> leftChild;
    AbstractBinaryTree<T> rightChild;
    T value;     
}

and an implementation of this class with a new method not previously declared or implemented:

public class BinarySearchTree<T extends Comparable<T>> extends AbstractBinaryTree<T> {
    public BinarySearchTree(T pVal) {
        super(pVal);
    }


    public Boolean isBST(){
    if(leftChild != null && rightChild != null){
        return (leftChild.value.compareTo(value) < 0 
                && rightChild.value.compareTo(value) >= 0 )
                && ((BinarySearchTree<T>) leftChild).isBST() 
                && ((BinarySearchTree<T>) rightChild).isBST();
    }
    else if(leftChild != null){
        return leftChild.value.compareTo(value) < 0 
                && ((BinarySearchTree<T>) leftChild).isBST() ;
    }
    else if (rightChild != null){
        return rightChild.value.compareTo(value) >= 0
        && ((BinarySearchTree<T>) rightChild).isBST();
    }
    else{
        return true;
    }
}

How do you avoid having to cast all left and right children?

2) Similarly suppose i had the following abstract definition in AbstractBinaryTree:

    public abstract AbstractBinaryTree<T> findMinTree();

and its implementation in BST:

/***
 * @return the subtree rooted at the min value
 */
public BinarySearchTree<T> findMinTree(){
    if(leftChild != null)
        return (BinarySearchTree<T>) leftChild.findMinTree();
    return this;
}

How do I avoid the cast in

public BinarySearchTree<T> findMinTree(){
    if(leftChild != null)
        return (BinarySearchTree<T>) leftChild.findMinTree();
    return this;
}

or when i call it on a child?

BinarySearchTree<T> y = ((BinarySearchTree<T>) x.rightChild).findMinTree();

I am not allergic to casting but its very heavy in this case. Thanks in advance for your answers!

Answer 1

You can use even more generics, namely the CRTP :

abstract class AbstractBinaryTree<T, TTree extends AbstractBinaryTree<T, TTree>> {
    TTree parent;
    TTree leftChild;
    TTree rightChild;
    T value;     
}

Answer 2

Instead of the class having the abstract superclass refer to a reference of itself for the structure of the tree, I would have it use a Node class that has references to its parent Node , and left and right children Nodes . The AbstractBinaryTree class would have a reference to the root Node .

abstract class AbstractBinaryTree<T> {
    Node<T> root;
    static class Node<E>
    {
        Node<E> parent;
        Node<E> leftChild;
        Node<E> rightChild;
        E value;
    }
}

Then subclasses wouldn't need the type of the Node to vary with its own type; BinarySearchTree would also use Node s.

class BinarySearchTree<T extends Comparable<T>> extends AbstractBinaryTree<T>
{
    // No need to redefine the structure types here.
}