interface als Methodenparameter in Java

Ich hatte vor Tagen ein Vorstellungsgespräch und bekam eine Frage wie diese.

F: Kehren Sie eine verkettete Liste um. Folgender Code ist gegeben:

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

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

    }
}

Ich war verwirrt, weil ich nicht wusste, dass ein Schnittstellenobjekt als Methodenparameter verwendet werden kann. Der Interviewer hat es ein bisschen erklärt, aber ich bin mir immer noch nicht sicher. Könnte mich jemand aufklären?

Dies ist in der Tat eine der gebräuchlichsten und nützlichsten Arten, eine Schnittstelle zu verwenden. Die Schnittstelle definiert einen Vertrag, und Ihr Code kann mit jeder Klasse arbeiten, die die Schnittstelle implementiert, ohne die konkrete Klasse kennen zu müssen – er kann sogar mit Klassen arbeiten, die noch nicht existierten, als der Code geschrieben wurde.

Es gibt viele Beispiele in der Java-Standard-API, insbesondere im Collections-Framework. Zum Beispiel, Sammlungen.sort() kann alles sortieren, was das implementiert List Schnittstelle (nicht nur ArrayList oder LinkedListobwohl Sie Ihre eigenen implementieren List ist ungewöhnlich) und deren Inhalte implementieren die Comparable Schnittstelle (nicht nur String oder die numerischen Wrapper-Klassen – und Ihre eigene Klassenimplementierung haben Comparable dafür ist ziemlich gemeinsames).

Es ist nicht das “Objekt” der Schnittstelle, das an die Methode übergeben wird, sondern nur ein normales Objekt. Es ist nur eine Art zu sagen “dieser Parameter akzeptiert jedes Objekt, das diese Schnittstelle unterstützt”. Es ist gleichbedeutend mit dem Akzeptieren eines Objekts eines Basisklassentyps, selbst wenn Sie eine Unterklasse übergeben.

Dies wird als Programmieren von Schnittstellen bezeichnet. Sie codieren nicht für eine bestimmte Implementierungsklasse von Knotenlisten, sondern für die Schnittstelle, die von all diesen Implementierungen implementiert wird.

Auf diese Weise funktioniert Ihr Code immer noch, wenn jemand eine neue und viel bessere Implementierung von schreibt NodeList nachdem Sie Ihre umgekehrte Methode geschrieben haben und Sie Ihren Code nicht für jede neue Implementierung von anpassen müssen NodeList.

Das Argument benötigt ein Objekt, dessen Klasse eine Schnittstelle (den Parameter) implementiert.

Im Pseudo- Java-Code:

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

ist gleich:

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

Notiz; Lesen Sie hier mehr über Schnittstellen: http://java.sun.com/docs/books/tutorial/java/IandI/interfaceAsType.html

Dies ist eine mögliche Implementierung:

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

Programmausgabe:

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

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

Ich bin sehr neugierig zu wissen, ob dieses Problem durch die Verwendung einer anonymen Klasse gelöst werden kann. Irgendwelche Ideen?

Hatte die gleiche Verwirrung, als ich Lambda-Sachen lernte. Dieses Video hat das Konzept nicht erklärt, aber es ist eine klare Möglichkeit für Sie zu sehen, wie es in Bezug auf die Übergabe einer Schnittstelle als Parameter funktioniert.

https://www.youtube.com/watch?v=mk3erzL70yM

Der Hauptvorteil der Verwendung von Schnittstellen besteht meiner Meinung nach darin, einfach testen zu können. Angenommen, Sie haben eine Schnittstelle namens PatientManager.

Sie können spezifische Unit-Tests für vorstellbare Dinge wie „CachingPatientManager“ oder „LDAPPatientManager“ schreiben, die Anwendungsfälle könnten unzählige sein.

Der Vorteil besteht darin, dass die Programmierung der Schnittstelle in hohem Maße wiederverwendbar und testbar wird.