interface as a method parameter in Java

This is in fact one of the most common and useful ways to use an interface. The interface defines a contract, and your code can work with any class that implements the interface, without having to know the concrete class - it can even work with classes that didn't exist yet when the code was written.

There are many examples in the Java standard API, especially in the collections framework. For example, Collections.sort() can sort anything that implements the List interface (not just ArrayList or LinkedList, though implementing your own List is uncommon) and whose contents implement the Comparable interface (not just String or the numerical wrapper classes - and having your own class implement Comparable for that purpose is quite common).

It's not the interface "object" being passed to the method, still just a regular object. It's just a way of saying "this parameter will accept any object that supports this interface". It's equivalent to accepting some object of a base class type, even if you're passing in a subclass.

This is called programming to interfaces. You don't code to a specific implementation class of node lists but to the interface implemented by all those implementations.

That way your code will still work if someone writes a new and much better implementation of NodeList after you wrote your reverse method and you don't have to adapt your code for each new implementation of NodeList.

The argument needs an object, which class implements an interface (the parameter).

In pseudo Java the code:

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

is equal to:

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

Note; read more on Interfaces here: http://java.sun.com/docs/books/tutorial/java/IandI/interfaceAsType.html

This is one possible implementation:

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

Program output:

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

I am very curious to know if this problem can be solved by using an anonymous class. Any ideas?

Had this same confusion while learning lambda stuff. This video didnt explain the concept, but it's a clear way for you to see how it works in terms of passing an interface as a parameter.

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

The major benefit of using interfaces, IMHO, is being able to test easily. Suppose you have an interface called, PatientManager.

You can write specific unit tests for imaginable things like "CachingPatientManager" or "LDAPPatientManager", the use case could be myriad.

The benefit is because the programming to interface becomes highly reusable and testable.

You cannot create an instance (/object ) of an Interface. Yes, you can pass Interface as a parameter in the function. But the question seems incomplete. Interface isn't implemented by any class. Something is missing. If you try to run this, compiler will not show any error.

But, in the reverse() method you need to create an instance of class that implements NodeList interface. I hope this makes sense.

Maybe it's too late, but still i leave my answer here as I found your question helpful.

When an interface is used as the parameter type of a method, it means that this method accepts any object that contains implementations of the interface.

There is a good example for this usage, and it's when you try to pass an ArrayList to a method. As you know, you can pass your ArrayList as List as below:

public int getListSize(List<String> myList){
 return myList.size();
}

and then, this will give you the flexibility to pass any object which implements List methods. For example, you can do:

List<String> myList1 = new ArrayList<>();
List<String> myList2 = new LinkedList<>();
List<String> myList3 = new Vector<>();
int size1 = getListSize(myList1); // Valid, myList1 is an ArrayList
int size2 = getListSize(myList2); // Valid, myList2 is a LinkedList
int size3 = getListSize(myList3); // Valid, myList3 is a Vector

• java
• oop
• interface