By Sarfraz


2009-12-16 08:15:15 8 Comments

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

30 comments

@Tokala Sai Teja 2019-08-14 07:48:48

In practicality terms(JAVA), the major difference between abstract class and interface is Abstract class can hold state. Other than holding state we can achieve rest operations with Interface also.

@Rick Sanchez 2018-01-17 13:33:58

The general idea of abstract classes and interfaces is to be extended/implemented by other classes (cannot be constructed alone) that use these general "settings" (some kind of a template), making it simple to set a specific-general behaviour for all the objects that later extend it.

An abstract class has regular methods set AND abstract methods. Extended classes can include unset methods after being extended by an abstract class. When setting abstract methods - they are defined by the classes that are extending it later.

Interfaces have the same properties as an abstract class, but includes only abstract methods, which could be implemented in an other class/es (and can be more than one interface to implement), this creates a more permanent-solid definishion of methods/static variables. Unlike the abstract class, you cannot add custom "regular" methods.

@Vatsal Shah 2018-05-23 09:19:35

A simple yet effective explanation of abstract class and interface on php.net:

An Interface is like a protocol. It doesn't designate the behavior of the object; it designates how your code tells that object to act. An interface would be like the English Language: defining an interface defines how your code communicates with any object implementing that interface.

An interface is always an agreement or a promise. When a class says "I implement interface Y", it is saying "I promise to have the same public methods that any object with interface Y has".

On the other hand, an Abstract Class is like a partially built class. It is much like a document with blanks to fill in. It might be using English, but that isn't as important as the fact that some of the document is already written.

An abstract class is the foundation for another object. When a class says "I extend abstract class Y", it is saying "I use some methods or properties already defined in this other class named Y".

So, consider the following PHP:

<?php
class X implements Y { } // this is saying that "X" agrees to speak language "Y" with your code.

class X extends Y { } // this is saying that "X" is going to complete the partial class "Y".
?>

You would have your class implement a particular interface if you were distributing a class to be used by other people. The interface is an agreement to have a specific set of public methods for your class.

You would have your class extend an abstract class if you (or someone else) wrote a class that already had some methods written that you want to use in your new class.

These concepts, while easy to confuse, are specifically different and distinct. For all intents and purposes, if you're the only user of any of your classes, you don't need to implement interfaces.

@Pransh Tiwari 2017-10-03 06:25:57

If you have some common methods that can be used by multiple classes go for abstract classes. Else if you want the classes to follow some definite blueprint go for interfaces.

Following examples demonstrate this.

Abstract class in Java:

abstract class animals
{
    // They all love to eat. So let's implement them for everybody
    void eat()
    {
        System.out.println("Eating...");
    }
    // The make different sounds. They will provide their own implementation.
    abstract void sound();
}

class dog extends animals
{
    void sound()
    {
        System.out.println("Woof Woof");
    }
}

class cat extends animals
{
    void sound()
    {
        System.out.println("Meoww");
    }
}

Following is an implementation of interface in Java:

interface Shape
{
    void display();
    double area();
}

class Rectangle implements Shape 
{
    int length, width;
    Rectangle(int length, int width)
    {
        this.length = length;
        this.width = width;
    }
    @Override
    public void display() 
    {
        System.out.println("****\n* *\n* *\n****"); 
    }
    @Override
    public double area() 
    {
        return (double)(length*width);
    }
} 

class Circle implements Shape 
{
    double pi = 3.14;
    int radius;
    Circle(int radius)
    {
        this.radius = radius;
    }
    @Override
    public void display() 
    {
        System.out.println("O"); // :P
    }
    @Override
    public double area() 
    { 
        return (double)((pi*radius*radius)/2);
    }
}

Some Important Key points in a nutshell:

  1. The variables declared in Java interface are by default final. Abstract classes can have non-final variables.

  2. The variables declared in Java interface are by default static. Abstract classes can have non-static variables.

  3. Members of a Java interface are public by default. A Java abstract class can have the usual flavors of class members like private, protected, etc..

@MRMF 2018-10-29 07:00:32

usually Abstract class used for core of something but interface used for appending peripheral.

when you want to create base type for vehicle you should use abstract class but if you want to add some functionality or property that is not part of base concept of vehicle you should use interface,for example you want to add "ToJSON()" function.

interface has wide range of abstraction rather than abstract class. you can see this in passing arguments.look this example:

enter image description here

if you use vehicle as argument you just can use one of its derived type (bus or car-same category-just vehicle category). but when you use IMoveable interface as argument you have more choices.

@Vivek 2013-09-15 08:59:45

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

@Ben Voigt 2014-03-07 04:16:30

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

@realPK 2014-03-09 04:29:24

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

@Pra Jazz 2014-07-18 10:57:20

Typo it not Cunstructor .. Its Constructor..

@Xar E Ahmer 2014-08-05 08:21:12

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

@LarsH 2016-07-29 16:19:37

I think "functionality" in this answer means "implementation." Not sure what "behavior" means -- maybe "signatures"?

@Peter Mortensen 2016-11-20 14:26:32

What is the targetted programming language here? C#?

@Shashank Bodkhe 2018-09-04 14:34:04

We have various structural/syntactical difference between interface and abstract class. Some more differences are

[1] Scenario based difference:

Abstract classes are used in scenarios when we want to restrict the user to create object of parent class AND we believe there will be more abstract methods will be added in future.

Interface has to be used when we are sure there can be no more abstract method left to be provided. Then only an interface is published.

[2] Conceptual difference:

"Do we need to provide more abstract methods in future" if YES make it abstract class and if NO make it Interface.

(Most appropriate and valid till java 1.7)

@e-satis 2009-12-16 08:37:12

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 :-)

@supercat 2013-03-27 21:28:43

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.

@Dan Lugg 2013-09-11 21:40:12

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

@Xynariz 2013-10-09 16:11:53

@AshwinP - see this question, specificially this answer.

@Ashwin Parmar 2013-10-10 04:36:16

Now I understand that Declare method in interface is implicit Public, But when we implement it should be as Public otherwise it is Protected. Right @Xynariz

@Geek 2014-04-24 13:18:25

@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?

@e-satis 2014-04-24 13:53:08

On some dynamic languages, if you use an interface, the interpretter will just check if the class complies to the implementation. On abstract classes, it will setup the whole inheritence mecanisme, including what you need to find out the Method Resolution Order. If you create a lot of objects, it's an overhead. Not a bit one, but depending of your requirements, you may want to take it into considerations.

@Charles Morin 2014-09-08 15:41:11

That explanation is stellar. As @Sarfraz said, practical explanation are the best.

@RN Kushwaha 2015-04-30 11:37:28

But what if you feel later that a MotorVehicle should also has void break();? In this case all classes implementing MotorVehicle interface must provide implementation for break() method which requires changes in more places. Is that not over killing?

@e-satis 2015-05-04 15:32:54

It depends, you can either add an intermediary parent, or implement your code using composition instead of inheritance. Composition is an important tool for flexible code, and is usually overlooked.

@Asif Mushtaq 2015-09-30 15:48:26

I searched and visit about 5 links, and After that.. your Answer is Awesome and stopped my searching..!! :)

@JsonStatham 2015-10-22 10:01:52

An interface is a contract, an abstract class is a starting point.

@Talk2Nit 2015-10-30 07:38:20

Can we define methods in abstract class as protected?

@Ogen 2015-10-31 01:34:34

@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

@Sravan Kumar 2016-04-15 16:20:03

One of the best ways of explanation I have encountered. :)

@Richard Fu 2016-06-21 03:26:57

This article saying the opposite that class is faster, any comment?

@e-satis 2016-06-21 17:57:59

As usual with computing, concepts are very different from implementations. Languages, versions and runtimes will wildly change the results you get, and time will make any talk about performance lie after a few years. This post is about a generic presentation of the concept, while your article is just a statement that a benchmark shows that a language in a version has an unexpected behavior. Or maybe it's just the line is blurring away more and more in modern VM. We would need a test on a dozen languages accross 3-4 versions to be sure.

@LittleLittleQ 2016-07-11 06:43:00

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

@jmsalcido 2016-10-20 14:27:02

@ogen in Java 8 default methods on interfaces are to have a default impl for newly created methods for framework writters, if you start to have only default methods you are not understanding what interfaces are for. Also, the core differences are that abstract classes could contain a state, interfaces do not.

@Ogen 2016-10-20 21:07:20

@jmsalcido Yeah containing state is a difference but I don't think it's that big. You could put the state in the impl classes specifically and have a little code duplication. On the other hand, the multiple inheritance difference is the biggest one I think. Only being able to inherit one class rather than many interfaces changes the entire architecture of your code entirely.

@jmsalcido 2016-10-22 19:01:58

@Ogen You could put the state in the impl classes specifically and have a little code duplication, but that's not the interface, the implementation is different from the contract. Multiple inheritance, well... that's not inheritance per se, that's polymorphism I would still explain the difference between abstract classes and interfaces in Java 8 with that, abstract classes can have state and interfaces are just a contract, there are no attributes to describe the state of the object. :)

@Watson 2019-03-27 17:50:41

This is a great definition. However, it would be nice to add that interfaces are great to allow a server to support lowest common denominator devices. For example, if a web service says I'll accept a customer interface class it means that the client is free to support the rawest and crudest implementation on a mobile device and a WPF application is free to support the most feature rich and "expensive" implementation on a full windows pc and even the server in turn can have its own implementation and all 3 may need very different functionality which is allowed if the implementation is left out.

@callisto 2019-05-24 09:21:46

In C#, an abstract class could be said to combine the contractual obligation of an interface, and the reusability of a base class all in one. That's not all, but it helped me to understand it when I ended up using both an interface and base class for the same class.

@Jaichander 2014-07-09 18:00:33

I am constructing a building of 300 floors

The building's blueprint interface

  • For example, Servlet(I)

Building constructed up to 200 floors - partially completed---abstract

  • Partial implementation, for example, generic and HTTP servlet

Building construction completed-concrete

  • Full implementation, for example, own servlet

Interface

  • We don't know anything about implementation, just requirements. We can go for an interface.
  • Every method is public and abstract by default
  • It is a 100% pure abstract class
  • If we declare public we cannot declare private and protected
  • If we declare abstract we cannot declare final, static, synchronized, strictfp and native
  • Every interface has public, static and final
  • Serialization and transient is not applicable, because we can't create an instance for in interface
  • Non-volatile because it is final
  • Every variable is static
  • When we declare a variable inside an interface we need to initialize variables while declaring
  • Instance and static block not allowed

Abstract

  • Partial implementation
  • It has an abstract method. An addition, it uses concrete
  • No restriction for abstract class method modifiers
  • No restriction for abstract class variable modifiers
  • We cannot declare other modifiers except abstract
  • No restriction to initialize variables

Taken from DurgaJobs Website

@vimal krishna 2017-07-26 08:33:32

An abstract class can have a constructor

@Sentinel 2017-09-18 07:48:39

I completely disagree with this view. The blueprint is a completely different concept to 'interface.' Blueprint is more analogous to a static model or design specification for a specific implementation. It is closer to 'class,' as the blueprint can be instantiated multiple times through its constructor, but even this is not close enough as the 'class' also contains the specification for how to construct (the ctor), and the means to do so. Interface as a concept is intended to represent some behavior, such as Heat Up/ Cool Down, that can be applied to arange of things, eg: buildings, ovens, etc

@Pritam Banerjee 2017-06-27 01:43:59

In short the differences are the following:

Syntactical Differences Between Interface and Abstract Class:

  1. Methods and members of an abstract class can have any visibility. All methods of an interface must be public. //Does not hold true from Java 9 anymore
  2. A concrete child class of an Abstract Class must define all the abstract methods. An Abstract child class can have abstract methods. An interface extending another interface need not provide default implementation for methods inherited from the parent interface.
  3. A child class can only extend a single class. An interface can extend multiple interfaces. A class can implement multiple interfaces.
  4. A child class can define abstract methods with the same or less restrictive visibility, whereas class implementing an interface must define all interface methods as public.
  5. Abstract Classes can have constructors but not interfaces.
  6. Interfaces from Java 9 have private static methods.

In Interfaces now:

public static - supported
public abstract - supported
public default - supported
private static - supported
private abstract - compile error
private default - compile error
private - supported

@Rahul Chauhan 2017-08-24 14:05:09

You can find clear difference between interface and abstract class.

Interface

  • Interface only contains abstract methods.
  • Force users to implement all methods when implements the interface.
  • Contains only final and static variables.
  • Declare using interface keyword.
  • All methods of an interface must be defined as public.
  • An interface can extend or a class can implement multiple other interfaces.

Abstract class

  • Abstract class contains abstract and non-abstract methods.

  • Does not force users to implement all methods when inherited the abstract class.

  • Contains all kinds of variables including primitive and non-primitive

  • Declare using abstract keyword.

  • Methods and members of an abstract class can be defined with any visibility.

  • A child class can only extend a single class (abstract or concrete).

@Sheo Dayal Singh 2017-08-16 08:43:16

Differences between abstract class and interface on behalf of real implementation.

Interface: It is a keyword and it is used to define the template or blue print of an object and it forces all the sub classes would follow the same prototype,as for as implementation, all the sub classes are free to implement the functionality as per it's requirement.

Some of other use cases where we should use interface.

Communication between two external objects(Third party integration in our application) done through Interface here Interface works as Contract.

Abstract Class: Abstract,it is a keyword and when we use this keyword before any class then it becomes abstract class.It is mainly used when we need to define the template as well as some default functionality of an object that is followed by all the sub classes and this way it removes the redundant code and one more use cases where we can use abstract class, such as we want no other classes can directly instantiate an object of the class, only derived classes can use the functionality.

Example of Abstract Class:

 public abstract class DesireCar
  {

 //It is an abstract method that defines the prototype.
     public abstract void Color();

  // It is a default implementation of a Wheel method as all the desire cars have the same no. of wheels.   
 // and hence no need to define this in all the sub classes in this way it saves the code duplicasy     

  public void Wheel() {          

               Console.WriteLine("Car has four wheel");
                }
           }


    **Here is the sub classes:**

     public class DesireCar1 : DesireCar
        {
            public override void Color()
            {
                Console.WriteLine("This is a red color Desire car");
            }
        }

        public class DesireCar2 : DesireCar
        {
            public override void Color()
            {
                Console.WriteLine("This is a red white Desire car");
            }
        }

Example Of Interface:

  public interface IShape
        {
          // Defines the prototype(template) 
            void Draw();
        }


  // All the sub classes follow the same template but implementation can be different.

    public class Circle : IShape
    {
        public void Draw()
        {
            Console.WriteLine("This is a Circle");
        }
    }

    public class Rectangle : IShape
    {
        public void Draw()
        {
            Console.WriteLine("This is a Rectangle");
        }
    }

@user3775501 2017-06-28 10:49:48

To give a simple but clear answer, it helps to set the context : you use both when you do not want to provide full implementations.

The main difference then is an interface has no implementation at all (only methods without a body) while abstract classes can have members and methods with a body as well, i.e. can be partially implemented.

@philantrovert 2017-06-28 11:19:58

Since you answered it just now, your answer does not take into account the default keyword in Java 8 with which you can define concrete methods in interfaces as well.

@user3775501 2019-02-12 11:30:49

As I said this was meant to be a "simple but clear answer" for someone at the stage of learning what the difference is. For someone like that, it isn't of any benefit to know about that sort of exception, it would only be very confusing.

@g00dnatur3 2014-07-22 23:36:36

It's pretty simple actually.

You can think of an interface as a class which is only allowed to have abstract methods and nothing else.

So an interface can only "declare" and not define the behavior you want the class to have.

An abstract class allows you to do both declare (using abstract methods) as well as define (using full method implementations) the behavior you want the class to have.

And a regular class only allows you to define, not declare, the behavior/actions you want the class to have.

One last thing,

In Java, you can implement multiple interfaces, but you can only extend one (Abstract Class or Class)...

This means inheritance of defined behavior is restricted to only allow one per class... ie if you wanted a class that encapsulated behavior from Classes A,B&C you would need to do the following: Class A extends B, Class C extends A .. its a bit of a round about way to have multiple inheritance...

Interfaces on the other hand, you could simply do: interface C implements A, B

So in effect Java supports multiple inheritance only in "declared behavior" ie interfaces, and only single inheritance with defined behavior.. unless you do the round about way I described...

Hopefully that makes sense.

@Sentinel 2017-03-06 21:46:53

Interface: Turn ( Turn Left, Turn Right.)

Abstract Class: Wheel.

Class: Steering Wheel, derives from Wheel, exposes Interface Turn

One is for categorizing behavior that can be offered across a diverse range of things, the other is for modelling an ontology of things.

@Toothless 2016-12-15 17:47:09

I'd like to add one more difference which makes sense. For example, you have a framework with thousands of lines of code. Now if you want to add a new feature throughout the code using a method enhanceUI(), then it's better to add that method in abstract class rather in interface. Because, if you add this method in an interface then you should implement it in all the implemented class but it's not the case if you add the method in abstract class.

@Vivek Vermani 2014-08-25 17:53:31

The only difference is that one can participate in multiple inheritance and other cannot.

The definition of an interface has changed over time. Do you think an interface just has method declarations only and are just contracts? What about static final variables and what about default definitions after Java 8?

Interfaces were introduced to Java because of the diamond problem with multiple inheritance and that's what they actually intend to do.

Interfaces are the constructs that were created to get away with the multiple inheritance problem and can have abstract methods, default definitions and static final variables.

See Why does Java allow static final variables in interfaces when they are only intended to be contracts?.

@Govind Parmar 2019-02-07 20:38:36

While that is an important difference, that is not the only difference.

@Shamim Ahmed 2013-08-25 21:56:14

In an interface all methods must be only definitions, not single one should be implemented.

But in an abstract class there must an abstract method with only definition, but other methods can be also in the abstract class with implementation...

@sculptor 2012-05-28 04:42:31

When you want to provide polymorphic behaviour in an inheritance hierarchy, use abstract classes.

When you want polymorphic behaviour for classes which are completely unrelated, use an interface.

@Dhananjay 2012-04-11 05:18:54

Let's work on this question again:

The first thing to let you know is that 1/1 and 1*1 results in the same, but it does not mean that multiplication and division are same. Obviously, they hold some good relationship, but mind you both are different.

I will point out main differences, and the rest have already been explained:

Abstract classes are useful for modeling a class hierarchy. At first glance of any requirement, we are partially clear on what exactly is to be built, but we know what to build. And so your abstract classes are your base classes.

Interfaces are useful for letting other hierarchy or classes to know that what I am capable of doing. And when you say I am capable of something, you must have that capacity. Interfaces will mark it as compulsory for a class to implement the same functionalities.

@Andrew 2017-01-16 22:49:23

Good answer, but the math metaphor is useless and made me waste roughly an equivalent amount of time reading it as writing this comment. Now multiply that by all the other people that have read this question.

@Dhananjay 2017-03-16 17:01:47

" math metaphor is useless" , why do you think so ?

@Justin Johnson 2009-12-16 10:11:40

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).

@Joshua K 2011-07-10 18:01:03

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

@SASM 2013-07-09 20:48:50

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

@Jiazzy user 2013-12-27 12:33:57

I thought a class that implement the interface need to define all the methods in the interface?

@Justin Johnson 2014-01-28 20:44:14

@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.

@Nick 2014-03-10 17:21:41

"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.

@Justin Johnson 2014-03-10 19:31:49

You're absolutely right. I've edited the answer to make that clarification.

@Eddie B 2014-09-29 08:54:56

Please update to reflect java 8.

@Justin Johnson 2014-10-17 05:14:16

When this question was first posed, it was a PHP question. However, this discussion seems to be no longer language specific and enumerating language specific features would be tedious.

@Talk2Nit 2015-10-30 07:37:28

Can we define methods in abstract class as "Protected"?

@Justin Johnson 2015-10-30 17:40:00

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

@Haithem KAROUI 2016-02-10 11:45:53

Can we really have constants inside an interface? (i don't think so), We can have properties and method stubs inside it not constants

@Justin Johnson 2016-02-10 21:31:53

I suppose it's language dependant. When this question was originally asked, it was done so in the scope of PHP, which does allow constants on interfaces. Java allows allows this. Whether or not it's a good practice is a different question and answer altogether.

@azkotoki 2009-12-16 08:48:00

Not really the answer to the original question, but once you have the answer to the difference between them, you will enter the when-to-use-each dilemma: When to use interfaces or abstract classes? When to use both?

I've limited knowledge of OOP, but seeing interfaces as an equivalent of an adjective in grammar has worked for me until now (correct me if this method is bogus!). For example, interface names are like attributes or capabilities you can give to a class, and a class can have many of them: ISerializable, ICountable, IList, ICacheable, IHappy, ...

@Tutu Kumari 2016-09-20 19:12:18

An abstract class is a class whose object cannot be created or a class which cannot be instantiated. An abstract method makes a class abstract. An abstract class needs to be inherited in order to override the methods that are declared in the abstract class. No restriction on access specifiers. An abstract class can have constructor and other concrete(non abstarct methods ) methods in them but interface cannot have.

An interface is a blueprint/template of methods.(eg. A house on a paper is given(interface house) and different architects will use their ideas to build it(the classes of architects implementing the house interface) . It is a collection of abstract methods , default methods , static methods , final variables and nested classes. All members will be either final or public , protected and private access specifiers are not allowed.No object creation is allowed. A class has to be made in order to use the implementing interface and also to override the abstract method declared in the interface. An interface is a good example of loose coupling(dynamic polymorphism/dynamic binding) An interface implements polymorphism and abstraction.It tells what to do but how to do is defined by the implementing class. For Eg. There's a car company and it wants that some features to be same for all the car it is manufacturing so for that the company would be making an interface vehicle which will have those features and different classes of car(like Maruti Suzkhi , Maruti 800) will override those features(functions).

Why interface when we already have abstract class? Java supports only multilevel and hierarchal inheritance but with the help of interface we can implement multiple inheritance.

@Ravindra babu 2015-11-27 12:42:35

I don't want to highlight the differences, which have been already said in many answers ( regarding public static final modifiers for variables in interface & support for protected, private methods in abstract classes)

In simple terms, I would like to say:

interface: To implement a contract by multiple unrelated objects

abstract class: To implement the same or different behaviour among multiple related objects

From the Oracle documentation

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.

abstract class establishes "is a" relation with concrete classes. interface provides "has a" capability for classes.

If you are looking for Java as programming language, here are a few more updates:

Java 8 has reduced the gap between interface and abstract classes to some extent by providing a default method feature. An interface does not have an implementation for a method is no longer valid now.

Refer to this documentation page for more details.

Have a look at this SE question for code examples to understand better.

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

@Moch Yusup 2014-09-29 09:54:08

The main point is that:

  • Abstract is object oriented. It offers the basic data an 'object' should have and/or functions it should be able to do. It is concerned with the object's basic characteristics: what it has and what it can do. Hence objects which inherit from the same abstract class share the basic characteristics (generalization).
  • Interface is functionality oriented. It defines functionalities an object should have. Regardless what object it is, as long as it can do these functionalities, which are defined in the interface, it's fine. It ignores everything else. An object/class can contain several (groups of) functionalities; hence it is possible for a class to implement multiple interfaces.

@Andrew 2017-01-16 22:51:02

Thank you now we are getting somewhere with a good high level response. Funny how far deep into the comments you have to go to find a more understanding-based response.

@Sentinel 2017-03-06 21:41:22

The other answers are too technical. This is getting towards what I would feel is a 'right' answer. The whole point of OOP is semantics, and whether or not a private nested classes public getters are invoked through CPU expensive lookups is pretty much irrelevant here

@Sergiu Dumitriu 2016-06-19 09:02:34

Many junior developers make the mistake of thinking of interfaces, abstract and concrete classes as slight variations of the same thing, and choose one of them purely on technical grounds: Do I need multiple inheritance? Do I need some place to put common methods? Do I need to bother with something other than just a concrete class? This is wrong, and hidden in these questions is the main problem: "I". When you write code for yourself, by yourself, you rarely think of other present or future developers working on or with your code.

Interfaces and abstract classes, although apparently similar from a technical point of view, have completely different meanings and purposes.

Summary

  1. An interface defines a contract that some implementation will fulfill for you.

  2. An abstract class provides a default behavior that your implementation can reuse.

Alternative summary

  1. An interface is for defining public APIs
  2. An abstract class is for internal use, and for defining SPIs

On the importance of hiding implementation details

A concrete class does the actual work, in a very specific way. For example, an ArrayList uses a contiguous area of memory to store a list of objects in a compact manner which offers fast random access, iteration, and in-place changes, but is terrible at insertions, deletions, and occasionally even additions; meanwhile, a LinkedList uses double-linked nodes to store a list of objects, which instead offers fast iteration, in-place changes, and insertion/deletion/addition, but is terrible at random access. These two types of lists are optimized for different use cases, and it matters a lot how you're going to use them. When you're trying to squeeze performance out of a list that you're heavily interacting with, and when picking the type of list is up to you, you should carefully pick which one you're instantiating.

On the other hand, high level users of a list don't really care how it is actually implemented, and they should be insulated from these details. Let's imagine that Java didn't expose the List interface, but only had a concrete List class that's actually what LinkedList is right now. All Java developers would have tailored their code to fit the implementation details: avoid random access, add a cache to speed up access, or just reimplement ArrayList on their own, although it would be incompatible with all the other code that actually works with List only. That would be terrible... But now imagine that the Java masters actually realize that a linked list is terrible for most actual use cases, and decided to switch over to an array list for their only List class available. This would affect the performance of every Java program in the world, and people wouldn't be happy about it. And the main culprit is that implementation details were available, and the developers assumed that those details are a permanent contract that they can rely on. This is why it's important to hide implementation details, and only define an abstract contract. This is the purpose of an interface: define what kind of input a method accepts, and what kind of output is expected, without exposing all the guts that would tempt programmers to tweak their code to fit the internal details that might change with any future update.

An abstract class is in the middle between interfaces and concrete classes. It is supposed to help implementations share common or boring code. For example, AbstractCollection provides basic implementations for isEmpty based on size is 0, contains as iterate and compare, addAll as repeated add, and so on. This lets implementations focus on the crucial parts that differentiate between them: how to actually store and retrieve data.

APIs versus SPIs

Interfaces are low-cohesion gateways between different parts of code. They allow libraries to exist and evolve without breaking every library user when something changes internally. It's called Application Programming Interface, not Application Programming Classes. On a smaller scale, they also allow multiple developers to collaborate successfully on large scale projects, by separating different modules through well documented interfaces.

Abstract classes are high-cohesion helpers to be used when implementing an interface, assuming some level of implementation details. Alternatively, abstract classes are used for defining SPIs, Service Provider Interfaces.

The difference between an API and an SPI is subtle, but important: for an API, the focus is on who uses it, and for an SPI the focus is on who implements it.

Adding methods to an API is easy, all existing users of the API will still compile. Adding methods to an SPI is hard, since every service provider (concrete implementation) will have to implement the new methods. If interfaces are used to define an SPI, a provider will have to release a new version whenever the SPI contract changes. If abstract classes are used instead, new methods could either be defined in terms of existing abstract methods, or as empty throw not implemented exception stubs, which will at least allow an older version of a service implementation to still compile and run.

A note on Java 8 and default methods

Although Java 8 introduced default methods for interfaces, which makes the line between interfaces and abstract classes even blurrier, this wasn't so that implementations can reuse code, but to make it easier to change interfaces that serve both as an API and as an SPI (or are wrongly used for defining SPIs instead of abstract classes).

Which one to use?

  1. Is the thing supposed to be publicly used by other parts of the code, or by other external code? Add an interface to it to hide the implementation details from the public abstract contract, which is the general behavior of the thing.
  2. Is the thing something that's supposed to have multiple implementations with a lot of code in common? Make both an interface and an abstract, incomplete implementation.
  3. Is there ever going to be only one implementation, and nobody else will use it? Just make it a concrete class.
    1. "ever" is long time, you could play it safe and still add an interface on top of it.

A corollary: the other way around is often wrongly done: when using a thing, always try to use the most generic class/interface that you actually need. In other words, don't declare your variables as ArrayList theList = new ArrayList(), unless you actually have a very strong dependency on it being an array list, and no other type of list would cut it for you. Use List theList = new ArrayList instead, or even Collection theCollection = new ArrayList if the fact that it's a list, and not any other type of collection doesn't actually matter.

@ujwal dhakal 2016-02-03 03:08:43

Interfaces are generally the classes without logic just a signature. Whereas abstract classes are those having logic. Both support contract as interface all method should be implemented in the child class but in abstract only the abstract method should be implemented. When to use interface and when to abstract? Why use Interface?

class Circle {

protected $radius;

public function __construct($radius)

{
    $this->radius = $radius
}

public function area()
{
    return 3.14159 * pow(2,$this->radius); // simply pie.r2 (square);
}

}

//Our area calculator class would look like

class Areacalculator {

$protected $circle;

public function __construct(Circle $circle)
{
    $this->circle = $circle;
}

public function areaCalculate()
{
    return $circle->area(); //returns the circle area now
}

}

We would simply do

$areacalculator = new Areacalculator(new Circle(7)); 

Few days later we would need the area of rectangle, Square, Quadrilateral and so on. If so do we have to change the code every time and check if the instance is of square or circle or rectangle? Now what OCP says is CODE TO AN INTERFACE NOT AN IMPLEMENTATION. Solution would be:

Interface Shape {

public function area(); //Defining contract for the classes

}

Class Square implements Shape {

$protected length;

public function __construct($length) {
    //settter for length like we did on circle class
}

public function area()
{
    //return l square for area of square
}

Class Rectangle implements Shape {

$protected length;
$protected breath;

public function __construct($length,$breath) {
    //settter for length, breath like we did on circle,square class
}

public function area()
{
    //return l*b for area of rectangle
}

}

Now for area calculator

class Areacalculator {

$protected $shape;

public function __construct(Shape $shape)
{
    $this->shape = $shape;
}

public function areaCalculate()
{
    return $shape->area(); //returns the circle area now
}

}

$areacalculator = new Areacalculator(new Square(1));
$areacalculator->areaCalculate();

$areacalculator = new Areacalculator(new Rectangle(1,2));
$areacalculator->;areaCalculate();

Isn't that more flexible? If we would code without interface we would check the instance for each shape redundant code.

Now when to use abstract?

Abstract Animal {

public function breathe(){

//all animals breathe inhaling o2 and exhaling co2

}

public function hungry() {

//every animals do feel hungry 

}

abstract function communicate(); 
// different communication style some bark, some meow, human talks etc

}

Now abstract should be used when one doesn't need instance of that class, having similar logic, having need for the contract.

@Justin Time 2016-01-28 21:58:45

The shortest way to sum it up is that an interface is:

  1. Fully abstract, apart from default and static methods; while it has definitions (method signatures + implementations) for default and static methods, it only has declarations (method signatures) for other methods.
  2. Subject to laxer rules than classes (a class can implement multiple interfaces, and an interface can inherit from multiple interfaces). All variables are implicitly constant, whether specified as public static final or not. All members are implicitly public, whether specified as such or not.
  3. Generally used as a guarantee that the implementing class will have the specified features and/or be compatible with any other class which implements the same interface.

Meanwhile, an abstract class is:

  1. Anywhere from fully abstract to fully implemented, with a tendency to have one or more abstract methods. Can contain both declarations and definitions, with declarations marked as abstract.
  2. A full-fledged class, and subject to the rules that govern other classes (can only inherit from one class), on the condition that it cannot be instantiated (because there's no guarantee that it's fully implemented). Can have non-constant member variables. Can implement member access control, restricting members as protected, private, or private package (unspecified).
  3. Generally used either to provide as much of the implementation as can be shared by multiple subclasses, or to provide as much of the implementation as the programmer is able to supply.

Or, if we want to boil it all down to a single sentence: An interface is what the implementing class has, but an abstract class is what the subclass is.

@Santosh 2016-01-22 12:24:54

enter image description here

Here is a very basic understanding over interface vs abstract class.

@aioobe 2016-08-30 06:58:59

How does this explain the difference? Why couldn't Car/Plane/Boat extend an abstract Vehicle class?

@Adib Aroui 2017-04-22 11:04:17

I don't understand, I even don't agree. It contradicts the answer with maximum votes

@Pradeep atkari 2014-11-20 07:55:39

Key Points:

  • Abstract class can have property, Data fields ,Methods (complete / incomplete) both.
  • If method or Properties define in abstract keyword that must override in derived class.(its work as a tightly coupled functionality)
  • If define abstract keyword for method or properties in abstract class you can not define body of method and get/set value for properties and that must override in derived class.
  • Abstract class does not support multiple inheritance.
  • Abstract class contains Constructors.
  • An abstract class can contain access modifiers for the subs, functions, properties.
  • Only Complete Member of abstract class can be Static.
  • An interface can inherit from another interface only and cannot inherit from an abstract class, where as an abstract class can inherit from another abstract class or another interface.

Advantage:

  • It is a kind of contract that forces all the subclasses to carry on the same hierarchies or standards.
  • If various implementations are of the same kind and use common behavior or status then abstract class is better to use.
  • If we add a new method to an abstract class then we have the option of providing default implementation and therefore all the existing code might work properly.
  • Its allow fast execution than interface.(interface Requires more time to find the actual method in the corresponding classes.)
  • It can use for tight and loosely coupling.

find details here... http://pradeepatkari.wordpress.com/2014/11/20/interface-and-abstract-class-in-c-oops/

Related Questions

Sponsored Content

8 Answered Questions

27 Answered Questions

23 Answered Questions

[SOLVED] What is the difference between @staticmethod and @classmethod?

7 Answered Questions

[SOLVED] Understanding Python super() with __init__() methods

28 Answered Questions

16 Answered Questions

[SOLVED] What are metaclasses in Python?

7 Answered Questions

[SOLVED] Difference between abstract class and interface in Python

34 Answered Questions

[SOLVED] Interface vs Abstract Class (general OO)

7 Answered Questions

[SOLVED] What are the differences between type() and isinstance()?

15 Answered Questions

[SOLVED] How do you declare an interface in C++?

Sponsored Content