Differences between abstract classes and interfaces in C #

Differences between abstract classes and interfaces in C #

The importance of interfaces in C # describes how to declare and use interfaces.

But C # is an abstract class formed by abstract keywords. How should we choose between them!

C # declare classes and functions as abstract objects. Abstract classes cannot be instantiated, and abstract functions cannot be directly implemented. They must be rewritten in non-Abstract Derived classes. Obviously, abstract functions are virtual, but virtual keywords cannot be provided. If a class contains an abstract function, the class is also abstract and must be declared as abstract.

Define abstract classes:

public abstract class Animal{    protected string _name;    public abstract string Name    {        get;    }    public abstract void Show();    public void MakeVoice()    {        Console.WriteLine(All animals can make voice!);    }}

Interface Definition:

public interface IAction{    void Move();}

Implement abstract classes and interfaces:

public class Duck : Animal, IAction{    public Duck(string name)    {        _name = name;    }    public override void Show()    {        Console.WriteLine(_name + is showing for you!);    }    public override string Name    {        get{return _name;}    }    public void Move()    {        Console.WriteLine(Duck also can swim.);    }}public class Dog : Animal, IAction{    public Dog(string name)    {        _name = name;    }    public override void Show()    {        Console.WriteLine(_name + is showing for you!);    }    public override string Name    {        get{return _name;}    }    public void Move()    {        Console.WriteLine(_name + Duck also can run.);    }}

Client implementation:

public class TestAnimal{    public static void Main(string [] args)    {    Animal duck = new Duck(Duck);    duck.MakeVoice();    duck.Show();    Animal dog = new dog(Dog);    dog.MakeVoice;    dog.Show();    IAction dogAction = new Dog(A big dog);    dogAction.Move();    }}

1. abstract classes are used to extract the common expression of a specific class, and interfaces are used to aggregate irrelevant classes into a common group.

2. All codes are shared and scalable. Abstract Class should be used whenever possible.

3. Use interfaces when looking for functional commonalities between objects with large differences. Use abstract classes when looking for functional differences between objects with large differences.

4. If you want to create multiple versions of a component, we recommend that you use an abstract class. If you design small and concise functional blocks, use interfaces.