ClassName c = new ClassName(); In this statement you are creating (by declaring it) a variable on the left hand side. The name of the variable is c. It has a "type" of ClassName - which means that only things which can "prove" that they provide the same variables/methods as the class ClassName has can be referenced by this variable without a compiler error.
On the right hand side you are instantiating the variable c. You are creating an object on the heap that will hold the "state" of the object (the current value of each of its varables) and putting a reference to it in the variable c. Notice that the "new"
word is used to do the object creating. The "ClassName()" is a call to the constructor of the class ClassName. In this case the parenthesis do not hold any parameters so you are calling the default constructor which takes no parameters.
The variable in this statement is a different thing than the object in this statement.
Variables have a "type", objects have a "class".
You can create a variable that is the "type" of an interface, and any object of any class that implements that interface can be referenced by that variable. However you can not actually create an object which is the "class" of an interface - because of course an interface is NOT a fully defined class.
Map myMap = new HashMap();
The variable is of "type" Map. So since this line compiles, the thing that it is referencing must be either a class that implements Map, or a Sublass of Map (since it is obviously NOT the "same" type). You can't really tell which just by looking at this code. As it turns out Map is an interface, so HashMap must implement that interface.