Question

以下是我认为这两个类的代码的相关部分。首先，TreePointer（原始来源here）：

public abstract class TreePointer<T extends TreeNode>
    implements Iterable<TokenResolver<T>>
{
    //...

    /**
     * What this tree can see as a missing node (may be {@code null})
     */
    private final T missing;

    /**
     * The list of token resolvers
     */
    protected final List<TokenResolver<T>> tokenResolvers;

    /**
     * Main protected constructor
     *
     * <p>This constructor makes an immutable copy of the list it receives as
     * an argument.</p>
     *
     * @param missing the representation of a missing node (may be null)
     * @param tokenResolvers the list of reference token resolvers
     */
    protected TreePointer(final T missing,
        final List<TokenResolver<T>> tokenResolvers)
    {
        this.missing = missing;
        this.tokenResolvers = ImmutableList.copyOf(tokenResolvers);
    }

    /**
     * Alternate constructor
     *
     * <p>This is the same as calling {@link #TreePointer(TreeNode, List)} with
     * {@code null} as the missing node.</p>
     *
     * @param tokenResolvers the list of token resolvers
     */
    protected TreePointer(final List<TokenResolver<T>> tokenResolvers)
    {
        this(null, tokenResolvers);
    }

    //...

    /**
     * Tell whether this pointer is empty
     *
     * @return true if the reference token list is empty
     */
    public final boolean isEmpty()
    {
        return tokenResolvers.isEmpty();
    }

    // .iterator(), .equals(), .hashCode(), .toString() follow
}

然后，JsonPointer，其中包含我想在此分解的.parent()方法（原始来源here：

public final class JsonPointer
    extends TreePointer<JsonNode>
{
    /**
     * The empty JSON Pointer
     */
    private static final JsonPointer EMPTY
        = new JsonPointer(ImmutableList.<TokenResolver<JsonNode>>of());

    /**
     * Return an empty JSON Pointer
     *
     * @return an empty, statically allocated JSON Pointer
     */
    public static JsonPointer empty()
    {
        return EMPTY;
    }

    //...

    /**
     * Return the immediate parent of this JSON Pointer
     *
     * <p>The parent of the empty pointer is itself.</p>
     *
     * @return a new JSON Pointer representing the parent of the current one
     */
    public JsonPointer parent()
    {
        final int size = tokenResolvers.size();
        return size <= 1 ? EMPTY
            : new JsonPointer(tokenResolvers.subList(0, size - 1));
    }

    // ...
}

正如主题中所提到的，我在这里遇到的问题是使用JsonPointer的{{1}}方法。实际上，此方法背后的逻辑适用于所有.parent()实现。除了我必须使用构造函数，当然这样的构造函数是依赖于实现的：/

有没有办法实现TreeNode，以便.parent()的每个实现都接收一个自身的实例而不是TreeNode，或者它只是一个白日梦？

Answer 1

当然，您可以向abstract超类添加parent方法TreePointer。真正的问题是，这有意义吗？我们在这里没有足够的背景知道它是否有意义。

如果对TreePointer的所有情况都有意义，请继续向abstract添加parent方法TreePointer，并在所有子类中添加具体实现。或者，您可以在TreePointer中放置一个默认实现，并将其覆盖在您希望在子类中提供不同行为的位置。

另外，我如何确保对于TreeNode的实现X，返回类型是X而不是TreeNode？这最终是我的问题。

在TreePointer课程中，您只需制作方法public TreePointer<T> parent()。除了new new JsonPointer(...)部分之外，您应该能够使所有代码都通用。您可能必须将其重构为一个单独的方法（可能是protected），您可以在每个具体的子类中覆盖它。

由于你想在子类中返回JsonPointer而不是TreePointer<T>，并且你还需要（非静态）工厂方法的问题，我认为你原来的怀疑是非常正确的。您可以使用父级中的抽象实现来完成此工作，但是您需要覆盖它以在子类中提供更具体的返回类型，我认为这不值得。只需在public abstract TreePointer<T> parent()中声明TreePointer并在public JsonPointer parent()中使用JsonPointer覆盖它。

Answer 2

您可以在JsonPointer上创建一个工厂方法，这样您就不必使用构造函数，并且可以独立于实现。

抽象类和继承者：这里可以“拉起”.parent（）吗？

2 个答案: