An interface is a 100-percent abstract class. But while an abstract class can define both abstract and non-abstract methods, an interface can have only abstract methods. Another way interfaces differ from abstract classes is that interfaces have very little flexibility in how the methods and variables defined in the interface are declared.
An interface is used to achieve multiple inheritances and loose coupling.
* All interface methods are implicitly public and abstract. In other words, you do not need to actually type the public or abstract modifiers in the method declaration, but the method is still always public and abstract. Because interface methods are abstract, they cannot be marked final, strictfp, or native.
* All variables defined in an interface must be public, static, and final — in other words, interfaces can declare only constants, not instance variables. Because interface constants are defined in an interface, they don't have to be declared as public, static, or final. They must be public, static, and final, but you don't have to actually declare them that way.
* An interface can extend one or more other interfaces; An interface cannot extend anything but another interface.
* An interface cannot implement another interface or class.
* Interface types can be used polymorphically.
* Since Java8 we can have static methods in an interface (with body). You need to call them using the name of the interface, just like static methods of a class. We can invoke static content like methods using an interface name directly.
* Since Java8 we can have default methods in an interface (with body). Like regular interface methods, default methods are implicitly public — there's no need to specify the public modifier. Unlike regular interface methods, they are declared with the default keyword at the beginning of the method signature, and they provide an implementation.