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

Question

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

User · Answer

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

User · Answer

One interesting location where interfaces fare better than abstract classes is when you need to add extra functionality to a group of  related or unrelated  objects  If you cannot give them a base abstract class  e g   they are sealed or already have a parent   you can give them a dummy  empty  interface instead  and then simply write extension methods for that interface

User · Answer

An abstract class can have implementations   An interface doesn t have implementations  it simply defines a kind of contract   There can also be some language-dependent differences  for example C  does not have multiple inheritance  but multiple interfaces can be implemented in a class

User · Answer

An abstract class can have implementations   An interface doesn t have implementations  it simply defines a kind of contract   There can also be some language-dependent differences  for example C  does not have multiple inheritance  but multiple interfaces can be implemented in a class

User · Answer

When to prefer an abstract class over interface    If one plans on updating a base class throughout the life of a program project  it is best to allow that the base class be an abstract class If one is trying to build a backbone for objects that are closely related in a hierarchy  it is highly beneficial to use an abstract class   When to prefer an interface over abstract class    If one is not dealing with a massive hierarchical type of framework  interfaces would be a great choice Because multiple inheritance is not supported with abstract classes diamond problem   interfaces can save the day

User · Answer

This can be a very difficult call to make     One pointer I can give  An object can implement many interfaces  whilst an object can only inherit one base class  in a modern  OO language like c   I know C   has multiple inheritance - but isn t that frowned upon

User · Answer

Purely on the basis of inheritance  you would use an Abstract where you re defining clearly descendant  abstract relationships  i e  animal- cat  and or require inheritance of virtual or non-public properties  especially shared state  which Interfaces cannot support    You should try and favour composition  via dependency injection  over inheritance where you can though  and note that Interfaces being contracts support unit-testing  separation of concerns and  language varying  multiple inheritance in a way Abstracts cannot

User · Answer

One interesting location where interfaces fare better than abstract classes is when you need to add extra functionality to a group of  related or unrelated  objects  If you cannot give them a base abstract class  e g   they are sealed or already have a parent   you can give them a dummy  empty  interface instead  and then simply write extension methods for that interface

User · Answer

Basic thumb rule is  For  Nouns  use Abstract class and for  Verbs  use interface  E g  car is an abstract class and drive  we can make it an interface

User · Answer

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

User · Answer

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     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     Consider using interfaces if     You expect that unrelated classes would implement your interface  For example many unrelated objects can implement Serializable interface  You want to specify the behaviour of a particular data type  but not concerned about who implements its behaviour  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

User · Answer

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

User · Answer

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

User · Answer

1 If you are creating something that provides common functionality to unrelated classes  use an interface   2 If you are creating something for objects that are closely related in a hierarchy  use an abstract class

User · Answer

I think the most succinct way of putting it is the following   Shared properties    abstract class  Shared functionality    interface   And to put it less succinctly     Abstract Class Example     public abstract class BaseAnimal       public int NumberOfLegs   get  set         protected BaseAnimal int numberOfLegs                NumberOfLegs   numberOfLegs           public class Dog   BaseAnimal       public Dog     base 4         public class Human   BaseAnimal        public Human     base 2          Since animals have a shared property - number of legs in this case - it makes sense to make an abstract class containing this shared property  This also allows us to write common code that operates on that property  For example   public static int CountAllLegs List lt BaseAnimal gt  animals        int legCount   0      foreach  BaseAnimal animal in animals                legCount    animal NumberOfLegs            return legCount      Interface Example   public interface IMakeSound       void MakeSound       public class Car   IMakeSound       public void MakeSound     gt  Console WriteLine  Vroom        public class Vuvuzela   IMakeSound       public void MakeSound     gt  Console WriteLine  VZZZZZZZZZZZZZ                 Note here that Vuvuzelas and Cars are completely different things  but they have shared functionality  making a sound  Thus  an interface makes sense here  Further  it will allow programmers to group things that make sounds together under a common interface -- IMakeSound in this case  With this design  you could write the following code   List lt IMakeSound gt  soundMakers   new List lt ImakeSound gt     soundMakers Add new Car     soundMakers Add new Vuvuzela     soundMakers Add new Car     soundMakers Add new Vuvuzela     soundMakers Add new Vuvuzela      foreach  IMakeSound soundMaker in soundMakers        soundMaker MakeSound        Can you tell what that would output   Lastly  you can combine the two   Combined Example   public interface IMakeSound       void MakeSound       public abstract class BaseAnimal   IMakeSound       public int NumberOfLegs   get  set         protected BaseAnimal int numberOfLegs                NumberOfLegs   numberOfLegs             public abstract void MakeSound       public class Cat   BaseAnimal       public Cat     base 4           public override void MakeSound     gt  Console WriteLine  Meow        public class Human   BaseAnimal        public Human     base 2           public override void MakeSound     gt  Console WriteLine  Hello  world         Here  we re requiring all BaseAnimals make a sound  but we don t know its implementation yet  In such a case  we can abstract the interface implementation and delegate its implementation to its subclasses   One last point  remember how in the abstract class example we were able to operate on the shared properties of different objects and in the interface example we were able to invoke the shared functionality of different objects  In this last example  we could do both

User · Answer

When to do what is a very simple thing if you have the concept clear in your mind    Abstract classes can be Derived whereas Interfaces can be Implemented  There is some difference between the two  When you derive an Abstract class  the relationship between the derived class and the base class is  is a  relationship  e g   a Dog is an Animal  a Sheep is an Animal which means that a Derived class is inheriting some properties from the base class   Whereas for implementation of interfaces  the relationship is  can be   e g   a Dog can be a spy dog  A dog can be a circus dog  A dog can be a race dog  Which means that you implement certain methods to acquire something    I hope I am clear

User · Answer

My two cents   An interface basically defines a contract  that any implementing class must adhere to implement the interface members   It does not contain any code   On the other hand  an abstract class can contain code  and there might be some methods marked as abstract which an inheriting class must implement   The rare situations I ve used abstract classes is when i have some default functionality that the inheriting class might not be interesting in overriding  in say an abstract base class  that some specialized classes inherit from   Example a very rudimentary one   Consider a base class called Customer which has abstract methods like CalculatePayment    CalculateRewardPoints   and some non-abstract methods like GetName    SavePaymentDetails      Specialized classes like RegularCustomer  and GoldCustomer will inherit from the Customer base class and implement their own CalculatePayment   and CalculateRewardPoints   method logic  but re-use the GetName   and SavePaymentDetails   methods   You can add more functionality to an abstract class non abstract methods that is  without affecting child classes which were using an older version  Whereas adding methods to an interface would affect all classes implementing it as they would now need to implement the newly added interface members   An abstract class with all abstract members would be similar to an interface

User · Answer

An abstract class can have implementations   An interface doesn t have implementations  it simply defines a kind of contract   There can also be some language-dependent differences  for example C  does not have multiple inheritance  but multiple interfaces can be implemented in a class

User · Answer

in java you can inherit from one  abstract  class to  provide  functionality and you can implement many interfaces to  ensure  functionality

User · Answer

My two cents   An interface basically defines a contract  that any implementing class must adhere to implement the interface members   It does not contain any code   On the other hand  an abstract class can contain code  and there might be some methods marked as abstract which an inheriting class must implement   The rare situations I ve used abstract classes is when i have some default functionality that the inheriting class might not be interesting in overriding  in say an abstract base class  that some specialized classes inherit from   Example a very rudimentary one   Consider a base class called Customer which has abstract methods like CalculatePayment    CalculateRewardPoints   and some non-abstract methods like GetName    SavePaymentDetails      Specialized classes like RegularCustomer  and GoldCustomer will inherit from the Customer base class and implement their own CalculatePayment   and CalculateRewardPoints   method logic  but re-use the GetName   and SavePaymentDetails   methods   You can add more functionality to an abstract class non abstract methods that is  without affecting child classes which were using an older version  Whereas adding methods to an interface would affect all classes implementing it as they would now need to implement the newly added interface members   An abstract class with all abstract members would be similar to an interface

User · Answer

The answers vary between languages  For example  in Java a class can implement  inherit from  multiple interfaces but only inherit from one abstract class  So interfaces give you more flexibility  But this is not true in C

User · Answer

in java you can inherit from one  abstract  class to  provide  functionality and you can implement many interfaces to  ensure  functionality

User · Answer

For me   I would go with interfaces in many cases  But  I prefer abstract classes in some cases   Classes in OO generaly refers to implementation   I use abstract classes when I want to force some implementation details to the childs else I go with interfaces   Of course  abstract classes are useful not only in forcing  implementation but also in sharing some specific details among many related classes

User · Answer

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     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     Consider using interfaces if     You expect that unrelated classes would implement your interface  For example many unrelated objects can implement Serializable interface  You want to specify the behaviour of a particular data type  but not concerned about who implements its behaviour  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

User · Answer

One interesting location where interfaces fare better than abstract classes is when you need to add extra functionality to a group of  related or unrelated  objects  If you cannot give them a base abstract class  e g   they are sealed or already have a parent   you can give them a dummy  empty  interface instead  and then simply write extension methods for that interface

User · Answer

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

User · Answer

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    A way of comparing two items  what item should go first  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

User · Answer

Purely on the basis of inheritance  you would use an Abstract where you re defining clearly descendant  abstract relationships  i e  animal- cat  and or require inheritance of virtual or non-public properties  especially shared state  which Interfaces cannot support    You should try and favour composition  via dependency injection  over inheritance where you can though  and note that Interfaces being contracts support unit-testing  separation of concerns and  language varying  multiple inheritance in a way Abstracts cannot

User · Answer

The short answer  An abstract class allows you to create functionality that subclasses can implement or override  An interface only allows you to define functionality  not implement it  And whereas a class can extend only one abstract class  it can take advantage of multiple interfaces

User · Answer

Use an abstract class if you want to provide some basic implementations

User · Answer

Use an abstract class if you want to provide some basic implementations

User · Answer

1 If you are creating something that provides common functionality to unrelated classes  use an interface   2 If you are creating something for objects that are closely related in a hierarchy  use an abstract class

User · Answer

When to do what is a very simple thing if you have the concept clear in your mind    Abstract classes can be Derived whereas Interfaces can be Implemented  There is some difference between the two  When you derive an Abstract class  the relationship between the derived class and the base class is  is a  relationship  e g   a Dog is an Animal  a Sheep is an Animal which means that a Derived class is inheriting some properties from the base class   Whereas for implementation of interfaces  the relationship is  can be   e g   a Dog can be a spy dog  A dog can be a circus dog  A dog can be a race dog  Which means that you implement certain methods to acquire something    I hope I am clear

User · Answer

For me   I would go with interfaces in many cases  But  I prefer abstract classes in some cases   Classes in OO generaly refers to implementation   I use abstract classes when I want to force some implementation details to the childs else I go with interfaces   Of course  abstract classes are useful not only in forcing  implementation but also in sharing some specific details among many related classes

User · Answer

in java you can inherit from one  abstract  class to  provide  functionality and you can implement many interfaces to  ensure  functionality

User · Answer

I wrote an article of when to use an abstract class and when to use an interface  There is a lot more of a difference between them other than  one IS-A    and one CAN-DO      To me  those are canned answers  I mention a few reasons when to use either of them  Hope it helps   http   codeofdoom com wordpress 2009 02 12 learn-this-when-to-use-an-abstract-class-and-an-interface

User · Answer

Purely on the basis of inheritance  you would use an Abstract where you re defining clearly descendant  abstract relationships  i e  animal- cat  and or require inheritance of virtual or non-public properties  especially shared state  which Interfaces cannot support    You should try and favour composition  via dependency injection  over inheritance where you can though  and note that Interfaces being contracts support unit-testing  separation of concerns and  language varying  multiple inheritance in a way Abstracts cannot

User · Answer

Use an abstract class if you want to provide some basic implementations

User · Answer

This can be a very difficult call to make     One pointer I can give  An object can implement many interfaces  whilst an object can only inherit one base class  in a modern  OO language like c   I know C   has multiple inheritance - but isn t that frowned upon

User · Answer

The answers vary between languages  For example  in Java a class can implement  inherit from  multiple interfaces but only inherit from one abstract class  So interfaces give you more flexibility  But this is not true in C

User · Answer

One interesting location where interfaces fare better than abstract classes is when you need to add extra functionality to a group of  related or unrelated  objects  If you cannot give them a base abstract class  e g   they are sealed or already have a parent   you can give them a dummy  empty  interface instead  and then simply write extension methods for that interface

User · Answer

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    A way of comparing two items  what item should go first  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

User · Answer

in java you can inherit from one  abstract  class to  provide  functionality and you can implement many interfaces to  ensure  functionality

User · Answer

This can be a very difficult call to make     One pointer I can give  An object can implement many interfaces  whilst an object can only inherit one base class  in a modern  OO language like c   I know C   has multiple inheritance - but isn t that frowned upon

User · Answer

Basic thumb rule is  For  Nouns  use Abstract class and for  Verbs  use interface  E g  car is an abstract class and drive  we can make it an interface

User · Answer

When to prefer an abstract class over interface    If one plans on updating a base class throughout the life of a program project  it is best to allow that the base class be an abstract class If one is trying to build a backbone for objects that are closely related in a hierarchy  it is highly beneficial to use an abstract class   When to prefer an interface over abstract class    If one is not dealing with a massive hierarchical type of framework  interfaces would be a great choice Because multiple inheritance is not supported with abstract classes diamond problem   interfaces can save the day

User · Answer

I think the most succinct way of putting it is the following   Shared properties    abstract class  Shared functionality    interface   And to put it less succinctly     Abstract Class Example     public abstract class BaseAnimal       public int NumberOfLegs   get  set         protected BaseAnimal int numberOfLegs                NumberOfLegs   numberOfLegs           public class Dog   BaseAnimal       public Dog     base 4         public class Human   BaseAnimal        public Human     base 2          Since animals have a shared property - number of legs in this case - it makes sense to make an abstract class containing this shared property  This also allows us to write common code that operates on that property  For example   public static int CountAllLegs List lt BaseAnimal gt  animals        int legCount   0      foreach  BaseAnimal animal in animals                legCount    animal NumberOfLegs            return legCount      Interface Example   public interface IMakeSound       void MakeSound       public class Car   IMakeSound       public void MakeSound     gt  Console WriteLine  Vroom        public class Vuvuzela   IMakeSound       public void MakeSound     gt  Console WriteLine  VZZZZZZZZZZZZZ                 Note here that Vuvuzelas and Cars are completely different things  but they have shared functionality  making a sound  Thus  an interface makes sense here  Further  it will allow programmers to group things that make sounds together under a common interface -- IMakeSound in this case  With this design  you could write the following code   List lt IMakeSound gt  soundMakers   new List lt ImakeSound gt     soundMakers Add new Car     soundMakers Add new Vuvuzela     soundMakers Add new Car     soundMakers Add new Vuvuzela     soundMakers Add new Vuvuzela      foreach  IMakeSound soundMaker in soundMakers        soundMaker MakeSound        Can you tell what that would output   Lastly  you can combine the two   Combined Example   public interface IMakeSound       void MakeSound       public abstract class BaseAnimal   IMakeSound       public int NumberOfLegs   get  set         protected BaseAnimal int numberOfLegs                NumberOfLegs   numberOfLegs             public abstract void MakeSound       public class Cat   BaseAnimal       public Cat     base 4           public override void MakeSound     gt  Console WriteLine  Meow        public class Human   BaseAnimal        public Human     base 2           public override void MakeSound     gt  Console WriteLine  Hello  world         Here  we re requiring all BaseAnimals make a sound  but we don t know its implementation yet  In such a case  we can abstract the interface implementation and delegate its implementation to its subclasses   One last point  remember how in the abstract class example we were able to operate on the shared properties of different objects and in the interface example we were able to invoke the shared functionality of different objects  In this last example  we could do both

User · Answer

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    A way of comparing two items  what item should go first  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

User · Answer

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

User · Answer

When to do what is a very simple thing if you have the concept clear in your mind    Abstract classes can be Derived whereas Interfaces can be Implemented  There is some difference between the two  When you derive an Abstract class  the relationship between the derived class and the base class is  is a  relationship  e g   a Dog is an Animal  a Sheep is an Animal which means that a Derived class is inheriting some properties from the base class   Whereas for implementation of interfaces  the relationship is  can be   e g   a Dog can be a spy dog  A dog can be a circus dog  A dog can be a race dog  Which means that you implement certain methods to acquire something    I hope I am clear

User · Answer

The answers vary between languages  For example  in Java a class can implement  inherit from  multiple interfaces but only inherit from one abstract class  So interfaces give you more flexibility  But this is not true in C

User · Answer

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

User · Answer

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

User · Answer

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

User · Answer

I wrote an article of when to use an abstract class and when to use an interface  There is a lot more of a difference between them other than  one IS-A    and one CAN-DO      To me  those are canned answers  I mention a few reasons when to use either of them  Hope it helps   http   codeofdoom com wordpress 2009 02 12 learn-this-when-to-use-an-abstract-class-and-an-interface

User · Answer

The short answer  An abstract class allows you to create functionality that subclasses can implement or override  An interface only allows you to define functionality  not implement it  And whereas a class can extend only one abstract class  it can take advantage of multiple interfaces

User · Answer

When to do what is a very simple thing if you have the concept clear in your mind    Abstract classes can be Derived whereas Interfaces can be Implemented  There is some difference between the two  When you derive an Abstract class  the relationship between the derived class and the base class is  is a  relationship  e g   a Dog is an Animal  a Sheep is an Animal which means that a Derived class is inheriting some properties from the base class   Whereas for implementation of interfaces  the relationship is  can be   e g   a Dog can be a spy dog  A dog can be a circus dog  A dog can be a race dog  Which means that you implement certain methods to acquire something    I hope I am clear

User · Answer

Purely on the basis of inheritance  you would use an Abstract where you re defining clearly descendant  abstract relationships  i e  animal- cat  and or require inheritance of virtual or non-public properties  especially shared state  which Interfaces cannot support    You should try and favour composition  via dependency injection  over inheritance where you can though  and note that Interfaces being contracts support unit-testing  separation of concerns and  language varying  multiple inheritance in a way Abstracts cannot

User · Answer

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

User · Answer

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    A way of comparing two items  what item should go first  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

User · Answer

The answers vary between languages  For example  in Java a class can implement  inherit from  multiple interfaces but only inherit from one abstract class  So interfaces give you more flexibility  But this is not true in C

User · Answer

Use an abstract class if you want to provide some basic implementations

User · Answer

This can be a very difficult call to make     One pointer I can give  An object can implement many interfaces  whilst an object can only inherit one base class  in a modern  OO language like c   I know C   has multiple inheritance - but isn t that frowned upon

User · Answer

Classes may inherit from only one base class  so if you want to use abstract classes to provide polymorphism to a group of classes  they must all inherit from that 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    If you anticipate creating multiple versions of your component  create an abstract class  Abstract classes provide a simple and easy way to version your components  By updating the base class  all inheriting classes are automatically updated with the change  Interfaces  on the other hand  cannot be changed once created in that way  If a new version of an interface is required  you must create a whole new interface      If the functionality you are creating will be useful across a wide range of disparate objects  use an 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      If you want to provide common  implemented functionality among all implementations of your component  use an abstract class  Abstract classes allow you to partially implement your class  whereas interfaces contain no implementation for any members   Copied from   http   msdn microsoft com en-us library scsyfw1d 28v vs 71 29 aspx

User · Answer

An abstract class can have implementations   An interface doesn t have implementations  it simply defines a kind of contract   There can also be some language-dependent differences  for example C  does not have multiple inheritance  but multiple interfaces can be implemented in a class

User · Answer

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 inheritances    Source

User · Answer

Classes may inherit from only one base class  so if you want to use abstract classes to provide polymorphism to a group of classes  they must all inherit from that 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    If you anticipate creating multiple versions of your component  create an abstract class  Abstract classes provide a simple and easy way to version your components  By updating the base class  all inheriting classes are automatically updated with the change  Interfaces  on the other hand  cannot be changed once created in that way  If a new version of an interface is required  you must create a whole new interface      If the functionality you are creating will be useful across a wide range of disparate objects  use an 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      If you want to provide common  implemented functionality among all implementations of your component  use an abstract class  Abstract classes allow you to partially implement your class  whereas interfaces contain no implementation for any members   Copied from   http   msdn microsoft com en-us library scsyfw1d 28v vs 71 29 aspx

User · Answer

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 inheritances    Source

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

Examples related to oop

Examples related to inheritance

Examples related to interface

Examples related to abstract-class