java - 无法调用在 Java 6 中作为上界 ("extends"泛型接收的类的静态方法？

Question

我在 Java(版本 6)中遇到模板和静态方法 a 的问题，这可能分为两个子问题:

首先，我需要找到一种方法来返回模板化的 Iterable (在静态上下文之外)在每次迭代中创建抽象类(例如，A)的某些子类(例如，B)的新实例。 (背景:我需要将一个对象(例如，一个字符串)从一个可迭代对象转换为另一个对象)。我找到了一种使用模板/泛型的方法:

import java.util.HashSet;
import java.util.Iterator;

public class Test {

    public static <T extends A> Iterable<T> getIterable(final Iterator<String> i) {

        return new Iterable<T>() {

            public Iterator<T> iterator() {

                return new Iterator<T>() {

                    public boolean hasNext() {
                        return i.hasNext();
                    }

                    public T next() {
                        try {
                            /* this is where things go wrong:        *
                             * T is considered as class A and not B  */
                            return T.factory(i.next());
                        } catch (Exception e) {
                            e.printStackTrace();
                            return null;
                        }
                    }

                    public void remove() {
                        i.remove();
                    }        
                };

            }

       };

    }

    public static void main(String[] args) {

        HashSet<String> st = new HashSet<String>();
        st.add("x1");

        Iterable<B> bi = getIterable(st.iterator());
        for (B b : bi)
        {
            System.out.println(b);
        }
    }
}

此外，我定义了以下类层次结构:

/* super class */
abstract class A
{
    public static <T extends A> T factory(String c)
    {
         /* returns nothing, should never be called */
         return null;
    }
}

/* child class */
class B extends A
{
    String s;
    public B (String s) { this.s = s; }

    public static B factory(String s)
    {
        return new B(s);
    }
}

总体方法似乎可行(原则上)。但是，静态方法 factory called 将始终是父类(super class) A 中的那个，即使模板 T属于B型。

我正在寻找有关如何调用子类工厂的任何想法/建议，即模板附带的类 <T> (例如，B)。非常感谢任何帮助!

(注意:我发现在 Java 7 中，可以使用接口(interface)并继承/覆盖静态方法，但我绑定(bind)到 Java 6 ...)

Answer 1

Java 关键字 static 对编译器有意义:它允许编译器静态在编译时将方法调用绑定(bind)到方法。因此，编译器在编译 return T.factory(i.next()). 行时将对方法 A.factory(String) 的调用写入生成的字节代码中

您显然想覆盖 B 中的工厂方法，以便在运行程序时具有动态行为。对于该行为，您必须删除 static 关键字。