When Should I Use Interfaces and

Index

Overview
Example #1 -- Drawable
Example #2 -- List and ArrayList
Conclusion

When you have the choice, always declare an interface over a class."

Of course, for "construction" you'll need a class:

List<Integer> nums = new ArrayList<>();

But note even in this common example, on the left side we declare an interface.

Why? Let's look at a couple examples.

Example #1 -- Drawable

Sketch

We have a diverse set of classes.
All the classes implement the interface "Drawable"

Method Parameter Using Class Type

public void drawAll1(List<Book> books)  {
	//...
}

We define a method that declares a method parameter List that has element types of Book.

Then we can only send books to this method. We can only draw books... 😢

Method Parameter Using Interface Type

public void drawAll2(List<Drawable> drawables)  {
	//...
}

We change the method header so that the method parameter List now has element types of Drawable.
We only need to change the method header (not any code body).

Now we can send all of our objects to the "draw" method! 👍🏽

Example #2 -- List and ArrayList

Example -- Declaring ArrayList

public void analyze1(#1ArrayList<String> list)  {
	//Tool that analyzes a list
	//and prints out a summary report
	//...
}

public void testShowDiffs1()  {
	//Test #1
	List<String> list = null;
	ArrayList<String> arrayList = null;
	LinkedList<String> linkedList = null;
	SuperFastList<String> superFastList = null;
	
	//...
	
	//Test #1
	#2this.analyze1(list);
	
	this.analyze1(arrayList);
	
	#3this.analyze1(linkedList);
	
	#4this.analyze1(superFastList);
}

We declare type ArrayList in our new method
Compile Errors
Compile Errors
Compile Errors

We just completed a list analyzer.
My teammates want to try it.
It fails (compile errors) for most of my teammates' lists. 😢

Example -- Declaring List

public String analyze2(#1List<String> list)  {
	/*Tool that analyzes list1 and list2 and shows report of:
		Elements only in list1, only in list2, in both */
	//...
	return null;
}

public void testShowDiffs2()  {
	
	List<String> list = null;
	ArrayList<String> arrayList = null;
	LinkedList<String> linkedList = null;
	SuperFastList<String> superFastList = null;
	
	//...

	//#2Test #2
	
	this.analyze2(list);
	
	this.analyze2(arrayList);
	
	this.analyze2(linkedList);
	
	this.analyze2(superFastList);
}

We declare type List in our new method
Everything compiles fine.

We just completed a list analyzer.
My teammates want to try it.
We only changed one declaration -- ArrayList to List -- We didn't need to change any other code -- and everything compiled fine!
😊

Conclusion

From the examples:

Interfaces are more flexible, dynamic, and general
Classes are more inflexible, specific and fixed
When we have the choice between an interface and a class, we want to choose an interface

However, note that there will be places we'll use a class:

When an object needs to be constructed (interaces cannot be constructed)
When a class does not implement an interface
When we need to use methods that are specific to that class (not declared on the interface).

OO With Java

Chapter Interfaces When Should I Use Interfaces and When Classes?

Search Site Home Back To Top