What to use here, abstract class or Interface?

Question

I have an abstract class say CTest which contains only the abstract method f1() and nothing else. Similiarly, i have a Interface ITest with the only method f1(). Here both the CTest abstract class and ITest interface does the same thing.

The one difference is that, the Interface provides the flexibility that it can be implemented in any classes which already derived from other class but abstract classes cannot.

Apart from the above difference, What is the actual difference between these two? and which one is efficient here(CTest or ITest)? When i should use what? Any specific scenario's in OO Design and any general suggessions on this are helpful

Answer 1

Other than inheritance, it depends on the scenario. Check this code project article with an excellent example.

[From the article]

Lets Assume you need to make three classes, first is CAR, second is MAN, third is WOMAN. Now you need a function in each of them to define how they Move. Now all three can move but CAR moves entirely in different way than MAN and WOMAN. So here we use an Interface IMOVEMENT and declare a function MOVE in it. Now all three classes can inherit this interface. So the classes goes like this.

public interface IMovement
{
    void Move();
}

public class Car : IMovement
{
    public void Move()
    {
        //Provide Implementation
    }
}

public class Man : IMovement
{
    public void Move()
    {
        //Provide Implementation
    }
}

public class Woman : IMovement
{
    public void Move()
    {
        //Provide Implementation
    }
}

But, since MAN and WOMAN walk in similar way, so providing same behavior in two different methods will be code redundancy, in simpler words code is not re-used. So we can now define a Abstract Class for Human Beings movements, so this class can be HUMANBEINGMOVEMENT. Also the same can be applied to CAR class, since there are lot of manufactures for cars and all cars move in similar way so we can also define a abstract class for Cars movement which can be CARSMOVEMENT. So our refactored code will be .

public interface IMovement
{
    void Move();
}

public abstract class CarsMovement : IMovement
{

    public virtual void Move()
    {
        //default behavior for cars movement
    }
}

public class SuzukiCar : CarsMovement
{
    public override void Move()
    {
        //Provide Implementation
    }
}

public abstract class HumanBeingMovement : IMovement
{

    public virtual void Move()
    {
        //default behavior for human being movement
    }
}

public class Man : HumanBeingMovement
{
    public override void Move()
    {
        //Provide Implementation
    }
}

public class Woman : HumanBeingMovement
{
    public override void Move()
    {
        //Provide Implementation
    }
}

Answer 2

In Java prefer Interfaces to Abstract Classes. Refer Item 18 in Effective Java

Main Points :

• Existing classes can be retroffited to implement a new interface.

• Interfaces are ideal for defining mixins.

• Interfaces allow the construction of nonheirarchical type frameworks.

• Interfaces enable safe, powerful functionality enhancements.

Answer 3

in c# it allows only single level inheritance. therefore interfaces can be use to do multiple inheritances

and also for more details :

http://www.dotnetfunda.com/forums/thread4085-difference-between-interface-and-abstract-class.aspx

http://sadi02.wordpress.com/2008/05/08/what-is-difference-in-an-abstract-class-and-an-interface/

Answer 4

For me it better to use interface here. Abstract class should be used when you could extract some code there (you could implement method or there is other stuff that want to invoke it).

Answer 5

In this case, and assuming that your Abstract Class will only contain abstract methods, you should, in my opinion, go with the Interface. Abstract classes with abstract methods and interfaces serve the same purpose, however, you can extend only one class but implement as many as you want, thus making your code less prone to significant changes should you decide the inherit some functionality from some other class.

Regarding your question: But What is the actual difference between these two? and which one is efficient here(CTest or ITest)? When i should use what? Any specific scenario's in OO Design and any general suggessions on this are helpful

Interfaces are similar to contracts, when a class implements an interface, it guarantees an implementation. This is usually helpful when someone wants to provide functionality but does not want to reveal internal code, so the developer will just throw out the interface so that you can make your calls without knowing how is each method implemented. You can obviously implement as many interfaces as you like.

Abstract classes allow you to create a class which has certain behaviours which are specified and some others which are left to be implemented in the future. Unlike interfaces however, each class can only extend one class, so you should extend classes with caution from this point of view. Abstract classes also allow you to inject behaviour to one class and have it automatically spread through its child classes. This usually makes certain sections of development/maintenance easier.

Answer 6

In this case there is no difference but CTest class has the only class which could be inherited as a Class . However ITest interface can be inherited by other class and interface at the same time.

Answer 7

In the scenario you have mentioned, that there is only one method, which will have no definition, the best way to go for is interface.

The major advantage an interface gives in Java that you can implement more than one interfaces, but you can extend only one class. So if you are already extending the one abstract class, you are not left with an option of extending any other class.

Golden rule: Interface is better than abstract class if we only need to define methods and not declare them.

Having said that an interface is better in your case, a programmer should also think of his code from a future perspective. Do you feel the class/ interface you are creating will have more methods in future. Would you like to define those methods or just declare? Answer to these question will let you know if an interface is sufficient or will need an abstract class.

Answer 8

Advantage:

Implementation of Abstract class is better than Interface because method looking up of abstract class is fast than interface. If you modify your interface , you have to update your implementation class but any modification of abstract class , no effect on implementation class.

disadvantage:

If you want to implement more than one parent class method , it is not possible.
But regarding to interface you can implement more than one.