Java中作为方法参数的接口

几天前我参加了一次面试，被问到这样一个问题

问：反向链接列表。给出了以下代码：

public class ReverseList { 
    interface NodeList {
        int getItem();
        NodeList nextNode();
    }
    void reverse(NodeList node) {

    }
    public static void main(String[] args) {

    }
}

---

我很困惑，因为我不知道接口对象可以用作方法参数。面试官解释了一点，但我还是不确定。有人能告诉我吗？

参数需要一个对象，该对象是实现接口（参数）的类

在pseudoJava中，代码：

void reverse(NodeList node) {
    // your code
}

等于：

reverse(x) {
    if(x == null || x instanceof NodeList) {
         // your code
    }else throw new RuntimeException("Some sort of error.");
}

---

注；阅读更多关于接口的信息：

传递给方法的不是接口“对象”，仍然只是一个常规对象。这只是表示“此参数将接受支持此接口的任何对象”的一种方式。这相当于接受某个基类类型的对象，即使您正在传递子类。

这实际上是使用接口的最常见和最有用的方法之一。接口定义了一个约定，您的代码可以与实现接口的任何类一起工作，而不必知道具体的类-它甚至可以与编写代码时还不存在的类一起工作

---

Java标准API中有许多示例，特别是在集合框架中。例如，可以对实现

列表

接口的任何内容进行排序（不仅仅是

数组列表

或

链接列表

，尽管实现自己的

列表

并不常见），并且其内容实现了

可比

接口（不仅仅是

String

或数值包装类，并且为此目的使用自己的类实现

compariable

是非常常见的）。

这称为接口编程。您不需要为节点列表的特定实现类编码，而是为所有这些实现实现的接口编码

---

这样，如果有人在您编写反向方法后编写了一个新的、更好的

NodeList

实现，您的代码仍然可以工作，并且您不必为

NodeList
的每个新实现调整代码。使用接口的主要好处是IMHO能够轻松测试。假设您有一个他叫了一声，耐心的经理

您可以为“CachingPatientManager”或“LDAPPatientManager”等可以想象的东西编写特定的单元测试，用例可能是无数的

好处是，接口编程变得高度可重用和可测试。
您无法创建接口的实例（/object）。
是的，您可以将接口作为函数中的参数传递。但问题似乎不完整。接口未由任何类实现。缺少某些内容。如果尝试运行此操作，编译器将不会显示任何错误

但是，在reverse（）方法中，您需要创建实现NodeList接口的类的实例。我希望这是有意义的。
这是一种可能的实现：

public class ReverseList { 
interface NodeList {
    int getItem();
    NodeList nextNode();
}

static class Node implements NodeList {
    private int item;
    private Node next;

    @Override
    public int getItem() {
        return item;
    }

    public void setItem(int si) {
        item = si;
    }

    @Override
    public NodeList nextNode() {
        return this.next;
    }

    public void setNext(Node n) {this.next=n;}

}

Node reverse(NodeList head) {
    Node node = (Node) head;
    Node previous = null;
    while(node.nextNode() !=null) {
        Node tempNext = (Node) node.nextNode();
        node.setNext(previous);
        previous = node;
        node = tempNext;
    }
    node.setNext(previous);
    return node;

}
public static void main(String[] args) {
    //Initialization block
    ReverseList rl = new ReverseList();
    Node n1= new Node(); n1.setItem(1);
    Node n2=new Node(); n2.setItem(2);
    Node n3 =new Node(); n3.setItem(3);
    n1.setNext(n2); n2.setNext(n3); n3.setNext(null);

    //Reversing the list
    System.out.println("Before reversal");      
    System.out.println(n1.getItem() +"->" 
                    + n1.nextNode().getItem() + "->"
                    + n1.nextNode().nextNode().getItem() + "->"
                    +n1.nextNode().nextNode().nextNode());


    rl.reverse(n1);

    System.out.println("\nAfter reversal");
    System.out.println(n3.getItem() +"->" 
            + n3.nextNode().getItem() + "->"
            + n3.nextNode().nextNode().getItem() + "->"
            +n3.nextNode().nextNode().nextNode());
        }
}

程序输出：

Before reversal
1->2->3->null

After reversal
3->2->1->null

我很想知道这个问题是否可以通过使用匿名类来解决。有什么想法吗？
在学习lambda内容时也有同样的困惑。
这个视频没有解释这个概念，但它是一个清晰的方式，让您了解它是如何作为参数传递接口的

参数是一种接口类型，参数是一个对象，实际上是一个pedent。参数是一个对象的引用：}感谢Sun教程的链接！谢谢Mike！列表示例非常有启发性且易于理解。很好，很有帮助！！：DInside
reverse（）
我们不能直接处理
节点
，而必须为其分配实现
节点列表的类的实例。毕竟，我们需要处理具体的对象。