Categories
abstract-class interface oop

What is the difference between an interface and abstract class?

1936

What exactly is the difference between an interface and an abstract class?

5

  • 110

    This is an extremely common interview question. It’s surprising since an abstract class is rarely used in solutions compared to other things. Your question has helped me Safraz.

    – Catto

    Feb 28, 2014 at 2:34

  • 6

    This question might also help to understand the concept of interfaces stackoverflow.com/q/8531292/1055241

    – gprathour

    Jul 7, 2014 at 5:28

  • 10

    I’ve removed the PHP tag form this question, since almost none of the answer are language specific, and the question itself is not language specific.

    – brice

    Feb 2, 2017 at 17:41

  • 2

    back in the day in c++ an interface is a pure abstract base class with all the method implementations = 0. If a single method was not = 0, then it has an implementation and the abstract base is no longer pure, and no longer an interface. I think the VMT has less indirection when multiple inheritance uses only pure abstract bases, but I don’t remember how they look anymore, been too long.

    – Jim

    Jun 26, 2019 at 5:59


  • In kotlin: Interfaces cannot store a state Only abstract classes can store state

    May 14 at 11:41

2413

Interfaces

An interface is a contract: The person writing the interface says, “hey, I accept things looking that way“, and the person using the interface says “OK, the class I write looks that way“.

An interface is an empty shell. There are only the signatures of the methods, which implies that the methods do not have a body. The interface can’t do anything. It’s just a pattern.

For example (pseudo code):

// I say all motor vehicles should look like this:
interface MotorVehicle
{
    void run();

    int getFuel();
}

// My team mate complies and writes vehicle looking that way
class Car implements MotorVehicle
{

    int fuel;

    void run()
    {
        print("Wrroooooooom");
    }


    int getFuel()
    {
        return this.fuel;
    }
}

Implementing an interface consumes very little CPU, because it’s not a class, just a bunch of names, and therefore there isn’t any expensive look-up to do. It’s great when it matters, such as in embedded devices.


Abstract classes

Abstract classes, unlike interfaces, are classes. They are more expensive to use, because there is a look-up to do when you inherit from them.

Abstract classes look a lot like interfaces, but they have something more: You can define a behavior for them. It’s more about a person saying, “these classes should look like that, and they have that in common, so fill in the blanks!“.

For example:

// I say all motor vehicles should look like this:
abstract class MotorVehicle
{

    int fuel;

    // They ALL have fuel, so lets implement this for everybody.
    int getFuel()
    {
         return this.fuel;
    }

    // That can be very different, force them to provide their
    // own implementation.
    abstract void run();
}

// My teammate complies and writes vehicle looking that way
class Car extends MotorVehicle
{
    void run()
    {
        print("Wrroooooooom");
    }
}

Implementation

While abstract classes and interfaces are supposed to be different concepts, the implementations make that statement sometimes untrue. Sometimes, they are not even what you think they are.

In Java, this rule is strongly enforced, while in PHP, interfaces are abstract classes with no method declared.

In Python, abstract classes are more a programming trick you can get from the ABC module and is actually using metaclasses, and therefore classes. And interfaces are more related to duck typing in this language and it’s a mix between conventions and special methods that call descriptors (the __method__ methods).

As usual with programming, there is theory, practice, and practice in another language 🙂

21

  • 6

    The key point about interfaces is not so much that they say what a class does, but allow objects that can Wizzle to make themselves useful to code that needs a Wizzler. Note that in many cases neither the person who writes the thing that can Wizzle, nor the person who needs a Wizzler, will be the person who writes the interface.

    – supercat

    Mar 27, 2013 at 21:28

  • 220

    I don’t think that CPU consumption is the highlight-worthy point on interfaces.

    – Dan Lugg

    Sep 11, 2013 at 21:40

  • 7

    @e-satis Can you please explain your point on CPU utilization? Why does abstract class being a class increase CPU utilization? What kind of lookup are you referring to here?

    – Geek

    Apr 24, 2014 at 13:18

  • 45

    @e-satis With Java 8, you can define default methods in interfaces which is the equivalent of having non-abstract methods in abstract classes. With this addition, I can no longer see the real difference between abstract classes and interface besides the fact that I should use interfaces because classes can implement multiple interfaces but can only inherit one class

    – Ogen

    Oct 31, 2015 at 1:34

  • 32

    I think the comparison between interface and class from Head First Java is vivid that A class defines who you are, and an interface tells what roles you could play

    Jul 11, 2016 at 6:43


947

The key technical differences between an abstract class and an interface are:

  • Abstract classes can have constants, members, method stubs (methods without a body) and defined methods, whereas interfaces can only have constants and methods stubs.

  • Methods and members of an abstract class can be defined with any visibility, whereas all methods of an interface must be defined as public (they are defined public by default).

  • When inheriting an abstract class, a concrete child class must define the abstract methods, whereas an abstract class can extend another abstract class and abstract methods from the parent class don’t have to be defined.

  • Similarly, an interface extending another interface is not responsible for implementing methods from the parent interface. This is because interfaces cannot define any implementation.

  • A child class can only extend a single class (abstract or concrete), whereas an interface can extend or a class can implement multiple other interfaces.

  • A child class can define abstract methods with the same or less restrictive visibility, whereas a class implementing an interface must define the methods with the exact same visibility (public).

11

  • 133

    i think this is the best answer because it highlights all of the key differences. an example’s not really necessary.

    – Joshua K

    Jul 10, 2011 at 18:01

  • 5

    And normally with classes you can instantiate an object from it unlike the abstract classes which CANNOT be instantiated.

    – SASM

    Jul 9, 2013 at 20:48

  • 2

    @Jiazzyuser If an abstract class implements an interface, it does not have to actually define the interface’s methods. That requirement can be deferred to inheriting/child concrete classes. However, a concrete class must implement all interface methods that are not implemented by its parent class. I’ll add example to illustrate this point.

    Jan 28, 2014 at 20:44


  • 8

    “When inheriting an abstract class, the child class must define the abstract methods, whereas an interface can extend another interface and methods don’t have to be defined.” – This is not true. Just as an interface can extend an interface without defining methods, an abstract class can inherit an abstract class without defining methods.

    – Nick

    Mar 10, 2014 at 17:21


  • 1

    Yes. “Methods and members of an abstract class can be defined with any visibility,”

    Oct 30, 2015 at 17:40

157

An Interface contains only the definition / signature of functionality, and if we have some common functionality as well as common signatures, then we need to use an abstract class. By using an abstract class, we can provide behavior as well as functionality both in the same time. Another developer inheriting abstract class can use this functionality easily, as they would only need to fill in the blanks.

enter image description here
Taken from:

http://www.dotnetbull.com/2011/11/difference-between-abstract-class-and.html

http://www.dotnetbull.com/2011/11/what-is-abstract-class-in-c-net.html
http://www.dotnetbull.com/2011/11/what-is-interface-in-c-net.html

6

  • 18

    You need to say what language this applies to (“Abstract class does not support multiple inheritance” is far from being universally true)

    – Ben Voigt

    Mar 7, 2014 at 4:16


  • Last comparison is confusing as per table! Methods in interface can’t be static but variables are static final Implemented methods in abstract class can be static

    – realPK

    Mar 9, 2014 at 4:29

  • 11

    Member of the interface must be static final . Last statement is wrong.

    Aug 5, 2014 at 8:21

  • I think “functionality” in this answer means “implementation.” Not sure what “behavior” means — maybe “signatures”?

    – LarsH

    Jul 29, 2016 at 16:19


  • 3

    What is the targetted programming language here? C#?

    Nov 20, 2016 at 14:26