interface as a method parameter in Java

I had an interview days ago and was thrown a question like this.

Q: Reverse a linked list. Following code is given:

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

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

I was confused because I did not know an interface object could be used as a method parameter. The interviewer explained a little bit but I am still not sure about this. Could somebody enlighten me?

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

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

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?

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.