{"id":109,"date":"2007-10-18T11:29:00","date_gmt":"2007-10-18T11:29:00","guid":{"rendered":"https:\/\/wdev-blog.azurewebsites.net\/index.php\/2007\/10\/18\/abstract-versus-interface\/"},"modified":"2007-10-18T11:29:00","modified_gmt":"2007-10-18T11:29:00","slug":"abstract-versus-interface","status":"publish","type":"post","link":"http:\/\/panahy.nl\/index.php\/2007\/10\/18\/abstract-versus-interface\/","title":{"rendered":"Abstract versus Interface"},"content":{"rendered":"
\n

An article on the MSDN<\/a> describes a summary of both the definitions. Although the article is a bit old (2003) and it compares C# with C++ it still provides a good start.<\/o:p><\/span><\/p>\n

<\/o:p><\/span>On the Code Project<\/a> I found a nice article written by Rahman Mahmoodi where her has a nice comparisson for these two definitions. Another article on the Code Project<\/a> which seems even more in dept about abstract class is written by Jayababu.<\/o:p><\/span><\/p>\n

<\/o:p><\/span><\/p>\n

Some important points about Abstract classes<\/h3>\n

<\/p>\n

\u00b7 <\/span><\/span><\/span><\/span>In contrary to other object oriented languages like JAVA, you can not inherit from more than one abstract class<\/o:p><\/span><\/p>\n

\u00b7 <\/span><\/span><\/span><\/span>you can not instanciate them or you get a Compiler Error<\/o:p><\/span><\/p>\n

\u00b7 <\/span><\/span><\/span><\/span>An abstract class may have a non-abstract constructor implementation.<\/o:p><\/span><\/p>\n

\u00b7 <\/span><\/span><\/span><\/span>they might have (also) non-abstract methods having implementation. these non-abstract methods are callable from the<\/p>\n

<\/span>abstract<\/span> <\/span>class<\/span> AbstractClass
{
<\/span>public<\/span> <\/span>void<\/span> NonAbstractMethod()
{
Console.WriteLine(“<\/span>You can call a non-abstract method which is implemented within the abstract method.<\/span>“);
}
}<\/p>\n

<\/span><\/o:p><\/span><\/p>\n

\u00b7 <\/span><\/span><\/span><\/span>You can reimplement the non-abstract method but it would be called by the class internally or any object of that type. If you define an object of abstract type and you instanciate the derived class you still call the implementation within the abstract class. To get the reimplementation you need to instanciate the class using a reference of type of the derived class. For example defining the following in the derived class:<\/p>\n

<\/span>public<\/span> <\/span>new<\/span> <\/span>void<\/span> NonAbstractMethod()
{
Console.WriteLine(“<\/span>This is new implementation of the non-abstract method.<\/span>“);
}<\/span><\/p>\n

and calling it like this<\/p>\n

<\/span>\/\/ Will call the original implementation
<\/span>AbstractClass obj = <\/span>new<\/span> InheritedClass();
obj.NonAbstractMethod();
<\/span>
\/\/ Will call the re-implementation
<\/span>InheritedClass obj2 = <\/span>new<\/span> InheritedClass();
obj2.NonAbstractMethod();
<\/span><\/p>\n

<\/span><\/o:p><\/span><\/p>\n

\u00b7 <\/span><\/span><\/span><\/span>In your derrived class you need to ovreride all the abstract methods.<\/p>\n

<\/span>public<\/span> <\/span>override<\/span> <\/span>void<\/span> OverrideThis()
{
Console.WriteLine(“<\/span>You have to implement an abstract method using the override key<\/span>“);
}<\/span><\/p>\n

<\/o:p><\/span><\/p>\n

\u00b7 <\/span><\/span><\/span><\/span>An abstract method can not be marked as static, compile error.<\/o:p><\/span><\/p>\n

\u00b7 <\/span><\/span><\/span><\/span>You can have static and non-static fields in an abstract class:<\/p>\n

<\/span>public<\/span> <\/span>static<\/span> <\/span>int<\/span> count = <\/span>1<\/span>;
<\/span>public<\/span> <\/span>int<\/span> InstCount = <\/span>1<\/span>;
<\/span>
public<\/span> AbstractClass()
{
count++;
InstCount++;
}<\/span>
but when instanciating two objects of the derived class and verify the value of the fields:<\/p>\n

<\/span>Console.WriteLine(“<\/span>Static field is <\/span>” + AbstractClass.count);
Console.WriteLine(“<\/span>Instance counter is <\/span>” + obj1.InstCount);
Console.WriteLine(“<\/span>Instance counter is <\/span>” + obj2.InstCount);<\/p>\n

output:<\/p>\n

Static field is 3
Instance counter is 2
Instance counter is 2<\/p>\n

<\/span><\/o:p><\/span><\/p>\n

<\/o:p><\/span><\/p>\n

The Differences<\/h3>\n<\/p>\n

\u00b7 <\/span><\/span><\/span><\/span>An inheritted class cannot have multiple base classes: compiler error.<\/o:p><\/span><\/p>\n

\u00b7 <\/span><\/span><\/span><\/span>An abstract class can define a default implementation (using a non-abstract method) and that will not force the derived classes to reimplement it whereas an interface can not have any implementation at all. <\/o:p><\/span><\/p>\n

\u00b7 <\/span><\/span><\/span><\/span>Interfaces can not contain fields; compile error.<\/o:p><\/span><\/p>\n

\u00b7 <\/span><\/span><\/span><\/span>An interface is like a contract. Once the contract changes all the classes implementing it need to change whereas an abstract class is like a common code for all the classeds and you might introduce the new method as a non-abstract method and give a default implementation. This could be seen as a pro or con. In some situations it is required to force all the contract holders to apply on the new method and in other cases you want to have this new feature for some of the types while the rest migh follow later. (a good question would be why is the new method part of the abstract class and not introduced as a new contract)<\/o:p><\/span><\/p>\n

\u00b7 <\/span><\/span><\/span><\/span><\/p>\n

<\/o:p><\/span><\/p>\n<\/div>\n","protected":false},"excerpt":{"rendered":"

An article on the MSDN describes a summary of both the definitions. Although the article is a bit old (2003) and it compares C# with C++ it still provides a good start. On the Code Project I found a nice article written by Rahman Mahmoodi where her has a nice comparisson for these two definitions. … Continue reading “Abstract versus Interface”<\/span><\/a><\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":[],"categories":[89,43,88],"tags":[],"uagb_featured_image_src":{"full":false,"thumbnail":false,"medium":false,"medium_large":false,"large":false,"1536x1536":false,"2048x2048":false,"post-thumbnail":false},"uagb_author_info":{"display_name":"Pouya Panahy","author_link":"http:\/\/panahy.nl\/index.php\/author\/pouya\/"},"uagb_comment_info":1,"uagb_excerpt":"An article on the MSDN describes a summary of both the definitions. Although the article is a bit old (2003) and it compares C# with C++ it still provides a good start. On the Code Project I found a nice article written by Rahman Mahmoodi where her has a nice comparisson for these two definitions.…","_links":{"self":[{"href":"http:\/\/panahy.nl\/index.php\/wp-json\/wp\/v2\/posts\/109"}],"collection":[{"href":"http:\/\/panahy.nl\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"http:\/\/panahy.nl\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"http:\/\/panahy.nl\/index.php\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"http:\/\/panahy.nl\/index.php\/wp-json\/wp\/v2\/comments?post=109"}],"version-history":[{"count":0,"href":"http:\/\/panahy.nl\/index.php\/wp-json\/wp\/v2\/posts\/109\/revisions"}],"wp:attachment":[{"href":"http:\/\/panahy.nl\/index.php\/wp-json\/wp\/v2\/media?parent=109"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"http:\/\/panahy.nl\/index.php\/wp-json\/wp\/v2\/categories?post=109"},{"taxonomy":"post_tag","embeddable":true,"href":"http:\/\/panahy.nl\/index.php\/wp-json\/wp\/v2\/tags?post=109"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}