java - 概念继承实现

Question

我正在编写一个空间数据结构，我对什么是最好的 NODE 实现有疑问。根据我的设计，我有一个抽象节点实体和三个继承自它的类:EMPTYNODE、FULLNODE、INTERNALNODE。

第一个没有具体数据。

第二个有 1 个对通用元素的引用。

第三个有 2 个对其他节点的引用。

我找到了几种实现这种情况的方法(我已经编写了代码)，但我无法决定哪种方法最好。

我发现的第一个解决方案是使用单个类 Node，它可能以这种方式执行所有操作:

private static class Node {
    private Elem elem = null;
    private Node left = null, right = null;
    public Elem getElem() {
        assert isFull();
        return elem;
    }

    public boolean isEmpty() {
        return elem == null && left == null;
    }

    public boolean isFull() {
        return  elem != null;
    }


    public boolean isInternal() {
        return elem == null && left != null;
    }
}

第二种解决方案是按类编写明确的划分，其中每个类仅提供其方法。显然，在这种方式下，我们不得不对节点对象执行多次转换。

private static abstract class Node {

    public abstract boolean isEmpty();

    public abstract boolean isFull();

    public abstract boolean isInternal();

}


private static class FullNode extends Node{

    private ITriangle elem;

    @Override
    public boolean isEmpty() {
        return false;
    }

    @Override
    public final boolean isFull() {
        return true;
    }

    @Override
    public final boolean isInternal() {
        return false;
    }

    public Elem getElem() {
        return elem;
    }
}

第三种解决方案是使用继承允许每个类提供所有方法，但对象类型应该通过“isEmpty()”和类似方法检查。如果调用错误，我们将抛出异常。

private static abstract class Node {

    public abstract boolean isEmpty();

    public abstract boolean isFull();

    public abstract boolean isInternal();

    public abstract Elem getElem();

}


private static class Empty extends Node{

    @Override
    public boolean isEmpty() {
        return true;
    }

    @Override
    public final boolean isFull() {
        return false;
    }

    @Override
    public final boolean isInternal() {
        return false;
    }

    @Override
    public Elem getElem() {
        throw new AssertionError();
    }
}

您如何看待这三种解决方案？

你会用哪个？

任何想法将不胜感激。

Answer 1

答案取决于节点的使用方式。创建节点后，它是否需要从空变为内部再变为全，还是不可变的？

根据给出的选项，如果节点是不可变的，那么我会选择选项 3，如果您期望内部状态发生变化，那么我会选择选项 1。

如果您想要一个行为会发生变化的可变节点，我会考虑使用 Node 类来保存数据，并使用枚举来保存状态，然后该节点将委托(delegate)给适当的枚举来实现它。例如:

public class Node {

   private enum NodeState {
      /* each state overrides specific methods to implement custom behaviour */
      FULL { public boolean isFull() { return true; } },
      INTERNAL { public boolean isInternal() { return true; } },
      EMPTY { public boolean isEmpty() { return true; } };

      /* the default behaviour */
      public boolean isFull() { return false; }
      public boolean isEmpty() { return false; }
      public boolean isInternal() { return false; }
   }

   private NodeState state = NodeState.EMPTY;
   private Elem      elem  = null;
   private Node      left  = null, right = null;

   public Elem getElem() {
      assert isFull();
      return elem;
   }

   /* TODO: constructors/mutators implement state changes go here */

   public boolean isEmpty() {
      return state.isEmpty();
   }

   public boolean isFull() {
      return state.isFull();
   }

   public boolean isInternal() {
      return state.isInternal();
   }
}

class Elem {
   /* implementation of this class */
}