A detailed explanation of the differences between abstract classes and interfaces in C #

This article mainly introduces the difference between abstract class and interface in C #. Has a good reference value. Let's take a look at the little series.

1. What is the relationship between interface-oriented programming and object-oriented programming?

First, interface-oriented programming and object-oriented programming are not lateral, it is not an independent programming idea that is more advanced than object-oriented programming, but is attached to the object-oriented ideology, which belongs to its part. Or, it is one of the essence of thought in object-oriented programming system.

2. The nature of the interface

An interface, on the surface, consists of a collection of several method definitions without the principal code, with a unique name that can be implemented by a class or other interface (or, optionally, inherited). It may look like this in form:

interface InterfaceName
{
 void Method1();
 void Method2(int para1);
 void Method3(string para2,string para3);
}

So what is the nature of the interface? Or what the meaning of the interface exists. I think it can be considered from the following two points of view:

1) An interface is a set of rules that specify a set of rules that a class or interface that implements this interface must have. Embodies the nature "if you are ... You must be able to ... "the idea.

For example, in nature, people can eat, that is, "If you are human, you must be able to eat". So the simulation to the computer program, there should be a IPerson (the custom interface name from the "I") interface, and there is a method called Eat (), and then we stipulate that each class that represents "human", must implement the IPerson interface, which simulates the nature "If you are human, you must be able to eat" This rule.

From here, I think you can see a little bit of object-oriented thinking. One of the core of object-oriented thinking is to simulate the real world and abstract the real world into classes, and the whole program relies on each kind of instance to communicate with each other and to cooperate with each other to complete the system function, which is very accord with the real world running condition and the essence of object oriented thought.

2) The interface is an abstract representation of the same thing on a certain granularity view. Note here I emphasize that in a certain granularity view, because the concept of "homogeneous thing" is relative, it differs because of the granularity view.

For example, in my eyes, I am a person, and a pig there is an essential difference, I can accept my classmates and I are similar this statement, but can not accept me and a pig is the same. However, if in the eyes of a zoologist, I and pig should be the same, because we are animals, he can think that "man" and "pig" have achieved ianimal this interface, and he in the study of animal behavior, I and pig will not be treated separately, but from the "animal" This larger grain size study, But he would think I was fundamentally different from a tree.

Now for a geneticist, the situation is different, because the organism can inherit, so in his eyes, I not only with the pig no difference, and a mosquito, a bacterium, a tree, a mushroom and even a SARS virus is no different, Because he would think that we all achieved idescendable this interface (note: Descend VI. Heredity), that is, we are all heritable things, he will not study us separately, but will all creatures as the same kind of research, in his eyes there is no human and virus, only the genetic material and non-hereditary material. But at least, I have a difference with a stone.

But the unfortunate thing happened, one day, on the earth appeared a great man, his name is Lenin, he is familiar with Marx, Engels of dialectical materialism thought after the masterpiece, quite experience, so he made a famous definition: the so-called material, is to be reflected in the consciousness of the objective reality. At this point, I and a stone, a trace of air, an idiom and transmission of mobile phone signal electromagnetic field has no difference, because in Lenin's eyes, we are can be reflected in the consciousness of the objective reality. If Lenin was a programmer, he would say: the so-called matter is all the instances that are generated by all classes that simultaneously implement the "Ireflectabe" and "Iesse" two interfaces. (Note: Reflect v. reflect esse N. Objective reality)

You might think that my example above is a nonsense, but that's what the interface is all about. Object-oriented thinking and one of the core is called polymorphism, what is polymorphism? To put it bluntly is to treat the same things indiscriminately at a certain granularity view level. And the reason to do this is because there is an interface exists. Like the geneticist, he knew that all living creatures had idescendable interfaces, and that, as long as they were creatures, there must be descend (), so that he could study together, rather than study each creature and end up exhausted.

Maybe I can't give you a visual impression of the nature and function of the interface. Then in the following example and in the analysis of several design patterns, you will be more intuitive to experience the connotation of the interface.

3. Overview of interface-oriented programming

So what is interface-oriented programming? My personal definition is: in the system analysis and architecture, distinguish between hierarchy and dependency, each level is not directly to its upper layer to provide services (that is, not directly instantiated in the upper layer), but by defining a set of interfaces, only to the upper layer exposes its interface function, the upper layer for the lower layer is only interface dependence, Rather than relying on specific classes.

The benefits of doing so are obvious, and first of all, a great benefit to system flexibility. When the lower layer needs to change, as long as the interface and interface functions are not changed, the upper layer does not have to make any changes. You can even replace the entire lower layer without altering the upper code, as if we were replacing a WD 60G hard drive with a Seagate 160G hard drive, instead of having to make any changes in the other parts of the computer, we could unplug the original hard drive and plug it into the new hard drive, because the rest of the computer is not dependent on the hard drive. Instead of relying on an IDE interface, you can replace the hard drive by implementing the interface. From this point of view, the interface in the program is very similar to the interface in reality, so I always think that the word interface (interface) is really in the likeness!

Another advantage of using the interface is that different parts or levels of developers can work in parallel, like making a hard disk without the CPU, and do not wait for the display, as long as the interface is consistent, reasonable design, can be developed in parallel, thereby improving efficiency.

Supplement to this article:

1. About "interface" in "interface-oriented programming" and "interfaces" in specific object-oriented languages two words

See a friend that "interface-oriented programming" in the word "interfaces" should be more than the interface in the simple programming language range. I think it makes sense. I did not write that very well here. I think "interface" in an object-oriented language refers to a specific code structure, such as an interface defined in C # with the interface keyword. The "interface" in "interface-oriented programming" can be described as a kind of structural part that hides concrete underlying classes and implements polymorphism from the perspective of software architecture and from a more abstract level. In this sense, if an abstract class is defined and the purpose is to achieve polymorphism, then I think it is reasonable to refer to this abstract class as an "interface". But is it unreasonable to use abstract class to realize polymorphism? Discussed in the second article below.

To summarize, I think that the concept of two "interfaces" is both different and interrelated. The interface in "interface-oriented programming" is an architectural component of the thought-level for polymorphism, software flexibility, and maintainability, and the "interface" in a specific language is the means by which the parts of the idea are implemented into code.

2. About abstract classes and interfaces

If single from the specific Code view, the two concepts are easy to blur, and even feel that the interface is redundant, because single from the specific function, in addition to multiple inheritance (C#,java), abstract class seems to completely replace the interface. However, does the presence of an interface exist to achieve multiple inheritance? Of course not. I think the difference between abstract classes and interfaces is the use of motivation. Abstract classes are used for reuse of code, and the motivation for using interfaces is to achieve polymorphism. So, if you're hesitant about using interfaces or abstract classes somewhere, think about what your motives are.

See a friend to IPerson this interface query, my personal understanding is, IPerson this interface should not be defined, the key to see the specific application is how a situation. If our project has women and man, all inherit person, and women and man most methods are the same, only one method DOSOMETHINGINWC () different (the example is vulgar, you forgive me), Then of course it is reasonable to define a Abstractperson abstract class, because it can include all other methods, the subclass only defines DOSOMETHINGINWC (), and greatly reduces the amount of duplicated code.

However, if the women and man two classes in our program basically do not have common code, and there is a personhandle class that needs to instantiate them and do not want to know that they are male or female, and simply treat them as human beings and realize polymorphism, then it is necessary to define interfaces.

All in all, the difference between an interface and an abstract class lies primarily in the motivation used, not in itself. And whether a thing should be defined as an abstract class or an interface depends on the context of the specific environment.

Furthermore, I think another difference between an interface and an abstract class is that the abstract class and its subclasses should be a general and special relationship, and the interface is just a set of rules that its subclasses should implement. (Of course, sometimes there may be general and special relationship, but we use the purpose of the interface is not here) For example, transportation is defined as abstract class, cars, airplanes, ships defined as sub-categories, is acceptable, because cars, airplanes, ships are a special means of transport. Another example is the IComparable interface, which simply says that the class that implements this interface must be able to be compared, which is a rule. If the car class implements the IComparable, just saying that there is a way in our car to compare two car instances, which may be more expensive than which car, or bigger than which, it does not matter, but we can not say that "the car is a special can be compared", which is not in the grammar.

C#. What is the difference between an abstract class and an interface in net?

The concepts of interfaces and abstract classes are different. An interface is an abstraction of an action, and an abstract class is an abstraction of the root.

The abstract class represents what this object is. The interface represents what this object can do. For example, men, women, these two classes (if it's a class ...) ), their abstract class is human. Description, they are all human.

People can eat, dogs can eat, you can define "eat" as an interface, and then let these classes to implement it.

Therefore, in high-level languages, a class can inherit only one class (abstract class) (just as people cannot be both biological and non-living), but can implement multiple interfaces (eating interfaces, walking interfaces).

Let's talk about the difference between the two applications:

Interface is more in the system architecture design method to play a role, mainly used to define the communication contract between the modules.

Abstract classes play a role in code implementation and can be reused for code

Template method Design pattern is a typical application of abstract class

Best Answer:

1 abstract class

(1) Abstract methods are declared only, not implementations, and can be seen as virtual methods without implementing the body.

(2) Abstract classes cannot be instantiated

(3) Abstract classes can, but do not have to have abstract attributes and abstract methods, but once you have an abstract method, you must declare this class as an abstract class

(4) The specific derived class must override the abstract method of the base class

(5) An abstract derived class can override an abstract method of a base class, or it can be overridden. If they are not overwritten, their specific derived classes must overwrite them. Such as:

using System;
public abstract class A // Abstract class A
{
  private int num = 0;
  public int Num // Abstract class contains attributes
  {
   get
   {
    return num;
   }
   set
   {
    num = value;
   }
  }
  public virtual int getNum () // The abstract class contains virtual methods
  {
   return num;
  }
  public void setNum (int n) // // abstract class contains ordinary methods
  {
   this.num = n;
  }
  public abstract void E (); // Abstract method E in class A
}
public abstract class B: A // Since class B inherits the abstract method E in class A, class B also becomes an abstract class
{
}
public class C: B
{
  public override void E () // Override the abstract method inherited from class A. If class B also defines abstract methods, it must also be overridden
  {
   // throw new Exception ("The method or operation is not implemented.");
  }
}
public class Test
{
  static void Main ()
  {
   C c = new C ();
   c.E ();
  }
}

Second, the interface

(1) interface cannot be instantiated

(2) The interface can only contain method declarations

(3) The members of an interface include methods, properties, indexers, events

(4) The interface cannot contain constants, fields (domains), constructors, destructors, static members. Such as:

public delegate void EventHandler (object sender, Event e);
public interface ITest
{
  // int x = 0;
  int A
  {
   get;
   set;
  }
  void Test ();
  event EventHandler Event;
  int this [int index]
  {
   get;
   set;
  }
} 

(5) All members in the interface default to public, so the interface cannot have the private modifier

(6) Derived classes must implement all members of an interface

(7) A class can directly implement a plurality of interfaces, the interface is separated by commas

(8) An interface can have multiple parent interfaces, and the class implementing the interface must implement all the members of all parent interfaces

III. abstract classes and interfaces

Same point:

(1) Can be inherited

(2) can not be instantiated

(3) can contain method declarations

(4) A derived class must implement a method that is not implemented

Difference

(1) Abstract base classes can define fields, properties, method implementations. An interface can only define properties, indexers, events, and method declarations, and cannot contain fields.

(2) An abstract class is an incomplete class that needs further refinement, while an interface is a code of conduct. Microsoft's custom interface is always behind the able field, proving that it is stating a class of "I can do ... ”

(3) Interfaces can be multiple implementations, abstract classes can only be inherited by a single

(4) The abstract class is more defined in a series of closely related classes, and the interface is mostly loose but all of the classes that implement a function

(5) Abstract class is the concept of abstraction from a series of related objects, so it reflects the internal commonality of things; an interface is a functional contract defined to satisfy an external invocation, so it reflects the external nature of the thing.

(6) The interface basically does not have any specific characteristics of inheritance, it only promises to be able to invoke the method

(7) interfaces can be used to support callbacks, and inheritance does not have this feature

(8) The concrete method of the abstract class implementation is virtual by default, but the interface method in the class that implements the interface defaults to non-virtual, and of course you can declare it as virtual.

(9) If an abstract class implements an interface, it is possible to map a method in an interface to an abstract class as an abstract method without having to implement a method in the subclass of an abstract class to implement an interface