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: 
Other than inheritance, it depends on the scenario. Check [this code project article](http://www.codeproject.com/Articles/258173/Interfaces-Vs-Abstract-Classes) 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
    }
}

```
**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.

```