无法调用在Java 6中作为上界（“extends”）泛型接收的类的静态方法？

我对Java（版本6）中的模板和静态方法a有问题，这可能分为两个子问题：

首先，我需要找到一种方法，可以返回一个模板化的

Iterable

（脱离静态上下文），在每次迭代中创建抽象类（例如a）的某些子类（例如B）的新实例。（背景：我需要将一个对象（例如字符串）从iterable转换为另一个对象）。我找到了使用模板/泛型的方法：

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

import java.util.HashSet；
导入java.util.Iterator；
公开课考试{
公共静态Iterable getIterable（最终迭代器i）{
返回新的Iterable（）{
公共迭代器迭代器（）{
返回新的迭代器（）{
公共布尔hasNext（）{
return i.hasNext（）；
}
公共交通工具{
试一试{
/*这就是问题所在：*
*T被视为A类而非B类*/
返回T.factory（i.next（））；
}捕获（例外e）{
e、 printStackTrace（）；
返回null；
}
}
公共空间删除（）{
i、 删除（）；
}        
};
}
};
}
公共静态void main（字符串[]args）{
HashSet st=新的HashSet（）；
st.add（“x1”）；
Iterable bi=getIterable（st.iterator（））；
对于（B:bi）
{
系统输出打印ln（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);
    }
}

/*超级类*/
抽象A类
{
公共静态T工厂（字符串c）
{
/*不返回任何内容，不应调用*/
返回null；
}
}
/*儿童班*/
B类扩展了A类
{
字符串s；
公共B（字符串s）{this.s=s；}
公共静态B工厂（字符串s）
{
返回新的B（s）；
}
}

整体的方法似乎（原则上）可行。然而，调用的静态方法

factory

将始终是超级类A中的方法，即使模板

T

是类型B

我正在寻找关于如何调用子类工厂的任何想法/建议，即模板

（例如，B）附带的类的工厂。非常感谢您的帮助

---

（注意：我发现在Java 7中，可以使用接口和继承/重写静态方法，但我绑定到Java 6…

Java关键字

static

对编译器有一个意义：它允许编译器在编译时将方法调用静态绑定到方法。因此，编译器在编译行

return T.factory（i.next（））时，将对方法
a.factory（String）
的调用写入生成的字节码中。

---

显然，您希望重写B中的工厂方法，以便在运行程序时具有动态行为。对于这种行为，您必须删除

static

关键字。

删除

[templates]

标记，因为Java没有模板。