When to use an interface instead of an abstract class and vice versa?

when to use interface and abstract class in c#
when to use abstract class and interface java
when to use abstract class and interface in java with real time example
difference between abstract class and interface in python
abstract class vs interface
interface class
when interface is preferred over abstract class
interface and abstract class program in java

This may be a generic OOP question. I wanted to do a generic comparison between an interface and an abstract class on the basis of their usage.

When would one want to use an interface and when would one want to use an abstract class?


I wrote an article about that:

Abstract classes and interfaces

Summarizing:

When we talk about abstract classes we are defining characteristics of an object type; specifying what an object is.

When we talk about an interface and define capabilities that we promise to provide, we are talking about establishing a contract about what the object can do.

When to use an abstract class vs. interface in C#, In an interface, we define what kind of operation an object can perform. These operations are defined by the classes that implement the interface. Abstract classes should be used primarily for objects that are closely related, whereas interfaces are best suited for providing common functionality to unrelated classes. If you are designing small, concise bits of functionality, use interfaces. If you are designing large functional units, use an abstract class.


An abstract class can have shared state or functionality. An interface is only a promise to provide the state or functionality. A good abstract class will reduce the amount of code that has to be rewritten because it's functionality or state can be shared. The interface has no defined information to be shared

When to Use Abstract Class and Interface, Answered: When should one prefer Interface over Abstract Class and vice versa? Originally Answered: Can we use interface instead of abstract class? Abstract classes may also provide members that have already been implemented. Therefore, you can ensure a certain amount of identical functionality with an abstract class, but cannot with an interface. Here are some recommendations to help you to decide whether to use an interface or an abstract class to provide polymorphism for your components.


Personally, I almost never have the need to write abstract classes.

Most times I see abstract classes being (mis)used, it's because the author of the abstract class is using the "Template method" pattern.

The problem with "Template method" is that it's nearly always somewhat re-entrant - the "derived" class knows about not just the "abstract" method of its base class that it is implementing, but also about the public methods of the base class, even though most times it does not need to call them.

(Overly simplified) example:

abstract class QuickSorter
{
    public void Sort(object[] items)
    {
        // implementation code that somewhere along the way calls:
        bool less = compare(x,y);
        // ... more implementation code
    }
    abstract bool compare(object lhs, object rhs);
}

So here, the author of this class has written a generic algorithm and intends for people to use it by "specializing" it by providing their own "hooks" - in this case, a "compare" method.

So the intended usage is something like this:

class NameSorter : QuickSorter
{
    public bool compare(object lhs, object rhs)
    {
        // etc.
    }
}

The problem with this is that you've unduly coupled together two concepts:

  1. A way of comparing two items (what item should go first)
  2. A method of sorting items (i.e. quicksort vs merge sort etc.)

In the above code, theoretically, the author of the "compare" method can re-entrantly call back into the superclass "Sort" method... even though in practise they will never want or need to do this.

The price you pay for this unneeded coupling is that it's hard to change the superclass, and in most OO languages, impossible to change it at runtime.

The alternative method is to use the "Strategy" design pattern instead:

interface IComparator
{
    bool compare(object lhs, object rhs);
}

class QuickSorter
{
    private readonly IComparator comparator;
    public QuickSorter(IComparator comparator)
    {
        this.comparator = comparator;
    }

    public void Sort(object[] items)
    {
        // usual code but call comparator.Compare();
    }
}

class NameComparator : IComparator
{
    bool compare(object lhs, object rhs)
    {
        // same code as before;
    }
}

So notice now: All we have are interfaces, and concrete implementations of those interfaces. In practise, you don't really need anything else to do a high level OO design.

To "hide" the fact that we've implemented "sorting of names" by using a "QuickSort" class and a "NameComparator", we might still write a factory method somewhere:

ISorter CreateNameSorter()
{
    return new QuickSorter(new NameComparator());
}

Any time you have an abstract class you can do this... even when there is a natural re-entrant relationship between the base and derived class, it usually pays to make them explicit.

One final thought: All we've done above is "compose" a "NameSorting" function by using a "QuickSort" function and a "NameComparison" function... in a functional programming language, this style of programming becomes even more natural, with less code.

When should I use an interface over an abstract class?, and when should we use interface over the abstract class and vice versa. Table of We can use abstract keyword to make a class abstract but interfaces are a  Interface. It is also user defined type like a class which only contains abstract members in it. These abstract members should be given the implementation under a child class of an interface. A class can be inherited from a class or from an interface.


OK, having just "grokked" this myself - here it is in layman's terms (feel free to correct me if I am wrong) - I know this topic is oooooold, but someone else might stumble across it one day...

Abstract classes allow you to create a blueprint, and allow you to additionally CONSTRUCT (implement) properties and methods you want ALL its descendants to possess.

An interface on the other hand only allows you to declare that you want properties and/or methods with a given name to exist in all classes that implement it - but doesn't specify how you should implement it. Also, a class can implement MANY interfaces, but can only extend ONE Abstract class. An Interface is more of a high level architectural tool (which becomes clearer if you start to grasp design patterns) - an Abstract has a foot in both camps and can perform some of the dirty work too.

Why use one over the other? The former allows for a more concrete definition of descendants - the latter allows for greater polymorphism. This last point is important to the end user/coder, who can utilise this information to implement the A.P.I(nterface) in a variety of combinations/shapes to suit their needs.

I think this was the "lightbulb" moment for me - think about interfaces less from the author's perpective and more from that of any coder coming later in the chain who is adding implementation to a project, or extending an API.

Difference between Abstract Class and Interface in Java, A class can be inherited from a class or from an interface. Points to remember. Interface contains only abstract methods. We cannot create object  The abstract class is extended from when you are writing new classes or modifying classes that you want to extend it (assuming they extend from java.lang.Object). You should always (unless you have a really good reason not to) declare variables (instance, class, local, and method parameters) as the interface. share.


If you are looking at java as OOP language,

"interface does not provide method implementation" is no longer valid with Java 8 launch. Now java provides implementation in interface for default methods.

In simple terms, I would like to use

interface: To implement a contract by multiple unrelated objects. It provides "HAS A" capability.

abstract class: To implement the same or different behaviour among multiple related objects. It establishes "IS A" relation.

Oracle website provides key differences between interface and abstract class.

Consider using abstract classes if :

  1. You want to share code among several closely related classes.
  2. 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).
  3. You want to declare non-static or non-final fields.

Consider using interfaces if :

  1. You expect that unrelated classes would implement your interface. For example,many unrelated objects can implement Serializable interface.
  2. You want to specify the behaviour of a particular data type, but not concerned about who implements its behaviour.
  3. You want to take advantage of multiple inheritance of type.

Example:

Abstract class ( IS A relation)

Reader is an abstract class.

BufferedReader is a Reader

FileReader is a Reader

FileReader and BufferedReader are used for common purpose : Reading data, and they are related through Reader class.

Interface ( HAS A capability )

Serializable is an interface.

Assume that you have two classes in your application, which are implementing Serializable interface

Employee implements Serializable

Game implements Serializable

Here you can't establish any relation through Serializable interface between Employee and Game, which are meant for different purpose. Both are capable of Serializing the state and the comparasion ends there.

Have a look at these posts :

How should I have explained the difference between an Interface and an Abstract class?

When To Use Abstract Class and Interface In Real Projects, Abstract class and interfaces both we have to declare methods. at what why use an abstract class instead of an interface (and vice versa)? An abstract class is generally used as a building basis for similar classes. Implementation that is common for the classes can be in the abstract class. An interface is generally used to specify an ability for classes, where the classes doesn't have to be very similar. share. Share a link to this answer.


why we use interface instead of abstract class (Beginning Java , As you can see, all three interfaces (IEmployee, IDeveloper, and IPillage) have When should you use an interface instead of an abstract class, and vice versa? Use interfaces if you can make the statement “A is capable of [doing] as”, or also, abstract for what a class is, interface for what a class can do. Por example, we can say a triangle is a polygon but it makes no sense to say a triangle is capable of being a polygon. Anyway, as ever, the rule of thumb for this is: use your common sense


Beginning PHP and Oracle: From Novice to Professional, Media classes then inherit this abstract class, ensuring conformity among the When should you use an interface instead of an abstract class, and vice versa? Abstract classes have the advantage of allowing better forward compatibility. Once clients use an interface, you cannot change it; if they use an abstract class, you can still add behavior without breaking existing code. If compatibility is a concern, consider using abstract classes.


Beginning PHP and PostgreSQL 8: From Novice to Professional, Media classes then inherit this abstract class, ensuring conformity among the When should you use an interface instead of an abstract class, and vice versa? Phân biệt lớp abstract và Interface trong Java - Học Java cơ bản và nâng cao cho người mới học về Ngôn ngữ hướng đối tượng, Ví dụ Java, Phương thức, Ghi đè, Tính kế thừa, Tính trừu tượng, Tính đa hình, Overriding, Inheritance, Polymorphism, Interfaces, Packages, Collections, Lập trình mạng, Đa luồng, Tuần tự hóa, Networking