就像類型聲明一樣，方法聲明也可以是泛型的。在本文中，動力節點小編將向您展示靜態泛型方法的示例。

public class Node<E> {
    E mValue;
    Node<E> mNext;
    Node<E> mPrevious; 
    public Node(E value) {
        mValue = value;
    }
        public void linkAfter(Node<E> node) {
        validate(node);
        node.mPrevious = this;
        node.mNext = mNext;
        if (mNext != null) {
            node.mNext.mPrevious = node;
        }
        mNext = node;
    } 
    public E getValue() {
        return mValue;
    }
    public Node<E> getNext() {
        return mNext;
    } 
    public Node<E> getPrevious() {
        return mPrevious;
    }               
}

在示例中，將三個數字節點 1->2->3 連接在一起。

我們的任務是將數字節點轉換為單詞節點。轉換后，希望節點看起來像一->二->三。

首先，將以非通用方式實現它并編寫一個小測試以確保它有效。

現在，讓我們不要過多地關心實現。轉換節點的新方法稱為convert()。它是一種靜態方法。需要注意的是，它需要一個值映射來將一個數字映射到它的單詞值。第二個參數是要轉換的數字節點。

Node 是一個不可變對象，因此我們必須為每個舊節點創建一個新節點，然后按照舊節點的方式建立鏈接。

public static Node convert(Map valueMap, Node node) {
    Node firstNode = null;
    Map convertedNodes = new HashMap();
    while(node != null) {                
        Object o = valueMap.get(node.getValue());     
        Node newNode = (Node) createNode(convertedNodes, node.getValue(), o);
        if (firstNode == null) {
            firstNode = newNode;
        }
        setNode(newNode, NodeType.NEXT_NODE, valueMap, convertedNodes, node);
        setNode(newNode, NodeType.PREV_NODE, valueMap, convertedNodes, node);
        node = node.getNext();
    }
    return firstNode;
}

由于這些方法是非泛型的，因此有很多編譯器警告：

在調用convert()并將結果分配給 Node<String>的語句中存在編譯器警告。

如果convert()為我們希望將節點轉換為的類型返回Node ，那就太好了。

讓我們研究convert()方法以使其通用。

什么是泛型方法?

泛型方法的聲明語法類似于泛型類型的語法。類型參數部分由尖括號分隔并出現在方法的返回類型之前。如果有多個類型參數，則以逗號分隔。

這是通用convert()方法的示例。

    public static <K, V> Node<V> convert(Map<K, V> valueMap, Node<K> node) {
    Node<V> firstNode = null;
    Map<K, Node<V>> convertedNodes = new HashMap<K, Node<V>>();
    while(node != null) {                
        V o = valueMap.get(node.getValue());     
        Node<V> newNode = createNode(convertedNodes, node.getValue(), o);
        if (firstNode == null) {
            firstNode = newNode;
        }
        setNode(newNode, NodeType.NEXT_NODE, valueMap, convertedNodes, node);
        setNode(newNode, NodeType.PREV_NODE, valueMap, convertedNodes, node);
        node = node.getNext();
    }
    return firstNode;
}

該方法有兩個類型參數名稱K和V。K是第一種類型節點的占位符，V是第一種類型將轉換為的下一種類型的占位符。

我們如何調用泛型方法?

測試用例：

在我的測試用例中，我有三個相互連接的整數節點。接下來，創建一個將整數映射到單詞的值映射。

然后調用convert(valueMap, one)傳遞 valueMap 和想要轉換的數字節點。

public void testNodeConvert() {
    Node<Integer> one = new Node<Integer>(1);
    Node<Integer> two = new Node<Integer>(2);
    Node<Integer> three = new Node<Integer>(3);
    one.linkAfter(two);
    two.linkAfter(three);     
    NodeUtils.printNode(one);     
    Map<Integer, String> valueMap = new HashMap<Integer, String>();
    valueMap.put(1, "one");
    valueMap.put(2, "two");
    valueMap.put(3, "three");        
    Node<String> nodeOne = NodeUtils.convert(valueMap, one);            
    System.out.println("Converted to: ");
    NodeUtils.printNode(nodeOne);       
}

在我們的示例中，編譯器將使用類型參數Integer和String自動調用convert()方法的實例化。 形式類型參數K替換為Integer，V替換為String類型。編譯器自動推斷在編譯時，返回類型Node<V>必須替換為Node<String>。

一旦方法是 gerenric，編譯器警告就會消失，因為編譯器推斷convert()將在編譯時返回Node<String>。

另一種查看方法是打印節點方法。

    public static void printNode(Node<?> node) {
        while(node != null) {
            System.out.print(node.getValue());
            if (node.getNext() !=null) {
                System.out.print("->");
            }
            node = node.getNext();
        }
    }
}

請注意，我們使用通配符類型 <?>。問題是為什么我們不使用像 <E>這樣的形參類型：

public static  void printNode(Node node) {
...
}

我們可以使用形式參數并且是完全合法的。但是，類型參數E只使用一次。返回類型是 void 并且不依賴于類型參數或方法中的任何其他參數。在這種情況下，我們只有一個論點。此處類型參數的目的是允許在調用printNode() 時使用各種實際參數值。如果是這種情況，應該使用通配符，這意味著它可以采用任何類型。

運行時測試用例的輸出：

1->2->3Converted to: 
one->two->three

以上就是關于“Java靜態方法泛型示例”的介紹，大家如果想了解更多相關知識，可以關注一下動力節點的Java基礎教程，里面有更豐富的知識等著大家去學習，希望對大家能夠有所幫助哦。