Abstract Classes vs Interfaces in Java

Everybody knows that in abstract class we can define method body but not in interface, but there are more difference between abstract class and interface. For instance, now in Java 8 we can have default as well as static method in interface. In this post, we look in the difference between them as well as from Java 8 perspective and also the basic knowledge when to use abstract and interface.

	Abstract Classes	Interfaces
Keyword(s) used	Use the abstract and class keywords to define a class	Use the interface keyword to define an interface.
Keyword used by the implementing class	Use the extends keyword to inherit from an abstract class	Use the implements keyword to implement an interface.
Default implementation	An abstract class can provide default implementation of methods	You cannot define methods in an interface; you can only declare them.
Fields	An abstract class can have static and non-static members	You cannot have any instance variables in an interface
Constants	An abstract class can have both static (using static and final keyword) and non-static (using final keyword) constants declarations	Interfaces can contain constant declarations If you declare a field, it must be initialized. All fields are implicitly considered to be declared as public static and final.
Constructors	You can define a constructor in an abstract class (which is useful for initializing fields, for example).	You cannot declare/define a constructor in an interface.
Access specifiers	You can have private and protected members in an abstract class.	You cannot have any private or protected members in an interface; all members are public by default.
Single vs. multiple inheritance	A class can inherit only one class (which can be either an abstract or a concrete class).	A class can implement any number of interfaces.
is-a relationship vs. following a protocol	An abstract base class provides a protocol; in addition, it serves as a base class in an is-a relationship.	An interface provides only a protocol. It specifies functionality that must be implemented by the classes implementing it
Default implementation of a method	An abstract class can provide a default implementation of a method. So, derived class(es) can just use that definition and need not define that method	An interface can only declare a method. All classes implementing the interface must define that method.
Difficulty in making changes	It is possible to make changes to the implementation of an abstract class. For example, you can add a method with default implementation and the existing derived classes will not break.	If there are already many classes implementing an interface, you cannot easily change that interface. For example, if you declare a new method, all the classes implementing that interface will stop compiling since they do not define that method but it is possible with default method of Java 8

Java 8 update : Interface now contain default and static methods. 

Choosing Between an Abstract Class and an Interface

• If you are identifying a base class that abstracts common functionality from a set of related classes, you should use an abstract class. If you are providing common method(s) or protocol(s) that can be implemented even by unrelated classes, this is best done with an interface.
• If you want to capture the similarities among the classes (even unrelated) without forcing a class relationship, you should use interfaces. On the other hand, if there exists an is-a relationship between the classes and the new entity, you should declare the new entity as an abstract class.

Consider using abstract classes if any of these statements apply to your situation:

• You want to share code among several closely related classes.
• You expect that classes that extend your abstract class have many common methods or fields, or require access modifiers other than public (such as protected and private).
• You want to declare non-static or non-final fields. This enables you to define methods that can access and modify the state of the object to which they belong.

Consider using interfaces if any of these statements apply to your situation:

• You expect that unrelated classes would implement your interface. For example, the interfaces Comparable and Cloneable are implemented by many unrelated classes.
• You want to specify the behavior of a particular data type, but not concerned about who implements its behavior.
• You want to take advantage of multiple inheritance of type.

JDK example:
An example of an abstract class in the JDK is AbstractMap, which is part of the Collections Framework. Its subclasses (which include HashMap, TreeMap, and ConcurrentHashMap) share many methods (including get, put, isEmpty, containsKey, and containsValue) that AbstractMap defines.

An example of a class in the JDK that implements several interfaces is HashMap, which implements the interfaces Serializable, Cloneable, and Map<K, V>. By reading this list of interfaces, you can infer that an instance of HashMap (regardless of the developer or company who implemented the class) can be cloned, is serializable (which means that it can be converted into a byte stream; see the section Serializable Objects), and has the functionality of a map. In addition, the Map<K, V> interface has been enhanced with many default methods such as merge and forEach that older classes that have implemented this interface do not have to define.

Example :
Let’s look at an example of choosing between abstract classes and interfaces in the Paint application. You can have Shape as an abstract base class for all shapes (like Circle, Square, etc.); this is an example of an is-a relationship. Also, common implementations, such as parent shape , can be placed in Shape. Hence, Shape as an abstract class is the best choice in this case.

In Paint, the user can perform various actions on shape objects. For example, a few shapes can be rotated, and a few can be rolled. A shape like Square can be rotated and a shape like Circle can be rolled. So, it does not make sense to have rotate() or roll() in the Shape abstract class. The implementation of rotate() or roll() differs with the specific shape, so default implementation could not be provided. In this case, it is best to use interfaces rather than an abstract class.




If you know anyone who has started learning Java, why not help them out! Just share this post with them. Thanks for studying today!...