分配给Java中更广泛类型的不同实现之间的差异

Question

I know that its considered best practice to assign subclass implementations to variables of an Interface type in order to maintain flexibility like so:

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

My current understanding is that when declaring list as type List , you limit its functionality to only implementations of methods that type List requires, and doesn't allow implementation-specific methods. That said, what's the difference between:

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

and:

List<Integer> list = new LinkedList<Integer>();

Other than some obvious performance differences caused by the different implementations of each class for the List interface, are there any differences?

As another example, using Set , I know that doing:

Set<String> set = new HashSet<String>();

gives you a HashSet as a Set , whereas:

Set<String> set = new TreeSet<String>();

gives you a TreeSet as a Set which means (among other things), that set is automatically sorted. But isn't the automatic sorting an implementation-specific function of the class?

Answer 1

As already correctly stated in the comments, if you are declaring a variable by its interface, you only have access to the methods defined by that interface. The main difference between the concrete types resides in the performance of the implementation.

But some method defined in the interface are also optionally implemented. For example the method add of the java.util.Set interface throws an UnsupportedOperationException , if the add operation is not supported by the concrete type that implents the Set interface.