Question

1）假设您有以下抽象类定义：

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

并使用之前未声明或实现的新方法实现此类：

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;
    }
}

你如何避免让所有左右儿童都被投射？

2）同样假设我在AbstractBinaryTree中有以下抽象定义：

    public abstract AbstractBinaryTree<T> findMinTree();

及其在BST中的实施：

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

如何避免演员

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

或者当我给孩子打电话时？

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

我对铸造不过敏，但在这种情况下非常重。提前感谢您的回答！

Answer 1

您可以使用更多的泛型，即CRTP：

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

Answer 2

而不是具有抽象超类的类引用自身对树结构的引用，我会让它使用一个Node类，它引用了它的父Node，并且和正确的孩子Nodes。 AbstractBinaryTree类将引用根Node。

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

然后，子类不需要Node的类型随其类型而变化; BinarySearchTree也会使用Node s。

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

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

2 个答案: