Java Lists (also Collection) have method implementations (add(),get()) so how can they be INTERFACES?
I would expect:
List <Integer> nums = ArrayList <Integer>();
nums.add(5);
that the above code would be in error since add() should be implemented in ArrayList not List(being an interface) But that is not the case, the code works fine. Can someone explain this?
This is just polymorphism in action. An ArrayList is-a List, and can therefore be assigned to a variable of type List.
The interface defines the contract of any class that implements it. It doesn't implement the methods (caveat: this is changing as of Java 8).
The variable nums is a List, but its concrete type is an ArrayList due to the assignment. The runtime treats it as polymorphic, and therefore the runtime dynamically binds to the add on the actual type that is stored in nums: i.e. it calls the add method on ArrayList.
I recommend reading The Java Tutorials > Polymorphism, and the pages on Interfaces in the same section.
You seem to be somewhat confused as to what an interface is, or at least how you use them. interface in Java defines a set of method signatures that any class which implements the interface must provide (or else be abstract). ArrayList is one such class which implements the List interface. When you do the following:
List<Integer> nums = ArrayList<Integer> ()
You are creating an instance of ArrayList, which implements all the methods of List, and assigning it to a variable which can hold any object that implements List. This means that when using nums, you can only access methods exposed by List. However, the methods actually being called are those of ArrayList.
Java encourages using interfaces because they aren't bound to a particular inheritance chain. Consider the following method signatures:
public <T> void foo(List<T> input)
public <T> void bar(ArrayList<T> input)
The foo method can take anything that implements List; this could be one of the standard library objects, like ArrayList or LinkedList, or it could be a user-defined class that provides completely different functionality in addition to the standard List operations. This makes it much more flexible; foo is simply stating that expects an object that looks and acts like a List, but doesn't care what that object is.
The bar method, on the other hand, uses ArrayList directly. If later on you realize you want to use a different collection, you're stuck, because you can only use an ArrayList or a class which extends ArrayList.
An interface is a contract, and there is guaranteed to be some concrete implementation behind it. For example, you could use
List<Integer> nums = ArrayList<>();
or
List<Integer> nums = LinkedList<>();
They differ in terms of their internal implementation (but both ArrayList and LinkedList fulfil the contract specified by the List interface). Finally, in Java 8+ interface(s) can have default methods.
implements List is a promise that the class has all the methods declared in the interface List. If all you need from an object is the List methods, it does not matter which class it actually is, as long as that class implements List.
List nums = new ArrayList (); declares nums to be a List reference. That means that any object it ever points to must be an instance of a class that implements List, and therefore has all the methods that List declares.
nums.add(5); uses the add method that any object nums references must supply, because it must implement List.
As you can see here(OpenJDK source code): http://www.docjar.com/html/api/java/util/List.java.html
List is an interface with no implementation. You need to declare an ArrayList or another List which implements this interface
You should study about inheritance. List is an interface that does not contain any implementation. But ArrayList contains all implementations of List interface.
When you call nums.add(5) you see List.add() method is being called but actually it calls ArrayList.add(5) method in background. That is the secret of Inheritance
Check this: http://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html
Body of method is loaded dynamically (at runtime) based on actual type of object held by reference (it is called late or dynamic binding), so for code
List <Integer> nums = ArrayList <Integer>();
actual object in nums reference would be instance of ArrayList class, so code of add/get would be loaded from ArrayList.
List doesn't actually have implementation of get() method, but calling
nums.add(5);
it is not a problem for compiler, because it knows that ArrayList will contain some implementation for all abstract (without body) methods from List interface.