Question

进行一些研究实现数据结构我在尝试使用与父类相同的泛型类创建两个子类时发现了一个问题。

之前我没有发现这个问题，因为我通常会避免做私有子类，虽然这次我想做一个快速测试并找到它。

我可以将function foo() { console.log(getFuncName()) } foo() // Logs: "foo"作为Node<T>类型，但current，然后转换为Node，使其无效。但我想知道为什么编译器不理解它与Node中的T相同。它认为节点中的T和T中的T是两个不同的LinkedStackIterator，即使节点中的T在T中被识别为T {1}}。

LinkedStack

public class LinkedStack<T> implements Iterable<T>{
    private Node<T> first = null;

    private class Node<T>{
        private T       item;
        private Node    next;
    }

    private class LinkedStackIterator<T> implements Iterator<T>{
        private Node<T> current = first; //Error here

        public boolean hasNext() { return current.next == null; }
        public void     remove() { throw new UnsupportedOperationException(); }
        public T        next()
        {
            T item      = current.item;
            current     = current.next;
            return item;
        }
    }
}

感谢您的帮助。

Answer 1

在此声明两种截然不同的 public class LinkedStack<T> implements Iterable<T>{ ... private class LinkedStackIterator<T> implements Iterator<T>{ ... }类型：

 private Node<T> current = first;

所以这个语句无法编译：

first

因为current变量指的是与first变量不同的类型 LinkedStack引用T＆＃39; current LinkedStackIterator引用T＆＃39; s T

要允许这两个类使用相同的T类型，不要在内部类中声明第二次private class LinkedStackIterator implements Iterator<T>{，而是重用在外部类中声明的那个：

customValidator(group: any) {
    if ((group.controls.transfer_qty.value > group.parent.parent.controls.approved_qty.value)) {
      return { out1: true }
    }
    if ((group.controls.transfer_qty.value > group.controls.available_qty.value)) {
      return { out2: true }
    }
    return null;
  }

Answer 2

您无需将通用类型添加到第二个类LinkedStackIterator。它将从外部类继承类型。

请注意，尽管使用相同的名称T，但对于type参数，它将是与不同的参数。出于同样的原因，在第一个内部类Node中，最好为参数使用不同的名称，例如Node<U>，明确区别。

以下代码为我编译好（在LinkedStack摘要之后）：

public abstract class LinkedStack<T> implements Iterable<T>{
    private Node<T> first = null;

    private class Node<U>{
        private U       item;
        private Node<U>    next;
    }

    private class LinkedStackIterator implements Iterator<T>{
        private Node<T> current = first; //Error here

        public boolean hasNext() { return current.next == null; }
        public void     remove() { throw new UnsupportedOperationException(); }
        public T        next()
        {
            T item      = current.item;
            current     = current.next;
            return item;
        }
    }
}

Answer 3

泛型类型 T 继承自 LinkedStack<T> 类
所以 Node

有两种可能的定义

这是我更喜欢的 - 请注意 static

private static class Node<T> {
  private T item;
  private Node<T> next;
}

如果您出于某些原因需要 Node 为非静态
（只有 item 必须属于 T ）

private class Node {
  private T item;
  private Node next;
}

两个私有子类中的相同类型变量不被识别为相同

3 个答案: