無法在Java 6中調用作為上限（“extends”）泛型接收的類的靜態方法？

Question

我在Java（版本6）中遇到模板和靜態方法問題，可能會分為兩個子問題：

首先，我需要找到一種方法，如何返回模板化的Iterable （在靜態上下文之外），在每次迭代中創建抽象類（例如A）的某個子類（例如，B）的新實例。 （背景：我需要將一個對象（例如，一個String）從一個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);
        }
    }
}

而且，我定義了以下類層次結構：

/* 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將始終是超類A中的factory ，即使模板T的類型為B.

我正在尋找關於如何調用子類工廠的任何想法/建議，即模板<T>附帶的類（例如，B）。 任何幫助都非常感謝！

（注意：我發現在Java 7中，可以使用接口並繼承/覆蓋靜態方法，但我必須使用Java 6 ...）

Answer 1

Java關鍵字static對編譯器有意義：它允許編譯器在編譯時將方法調用靜態綁定到方法。 因此，在編譯行return T.factory(i.next()).時，編譯器將對方法A.factory(String)的調用寫入生成的字節代碼中return T.factory(i.next()).

您顯然希望覆蓋B中的工廠方法，以便在運行程序時具有動態行為。 對於該行為，您必須刪除static關鍵字。