首页 > Java资讯 > 正文

Java静态方法泛型示例

2022-07-25 11:11:00
1423次动力节点

就像类型声明一样，方法声明也可以是泛型的。在本文中，动力节点小编将向您展示静态泛型方法的示例。

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() 时使用各种实际参数值。如果是这种情况，应该使用通配符，这意味着它可以采用任何类型。

运行时测试用例的输出：