This question already has answers here:
Interface vs Base class
(38 answers)
Interface or abstract class?
(15 answers)
Closed 7 years ago.
this article says
Codeproject
Abstract Class -can have method Declaration and method definition.
But this article says
programcall
Abstract - can have only method Declaration.
I got confused. Can anybody clear me what is the exact difference of both ?
See this article:
Multiple inheritance
A class may inherit several interfaces.
A class may inherit only one abstract class.
Default implementation
An interface cannot provide any code, just the signature.
An abstract class can provide complete, default code and/or just the details that have to be overridden.
Access Modfiers
An interface cannot have access modifiers for the subs, functions, properties etc everything is assumed as public An abstract class can contain access modifiers for the subs, functions, properties
Core VS Peripheral
Interfaces are used to define the peripheral abilities of a class. In other words both Human and Vehicle can inherit from a IMovable interface.
An abstract class defines the core identity of a class and there it is used for objects of the same type.
Homogeneity
If various implementations only share method signatures then it is better to use Interfaces.
If various implementations are of the same kind and use common behaviour or status then abstract class is better to use.
Adding functionality (Versioning)
If we add a new method to an Interface then we have to track down all the implementations of the interface and define implementation for the new method.
If we add a new method to an abstract class then we have the option of providing default implementation and therefore all the existing code might work properly.
Fields and Constants No fields can be defined in interfaces An abstract class can have fields and constrants defined
As far as I know, abstract classes can already implement some methods or variable's values, as long as it does not implement them all (which would make it a normal class).
An interface cannot do this; it can only provide method and variable stubs.
An interface is more of a contract - it details what methods or properties will be found on an object that implements it.
An abstract class is a base object - it can contain methods, variables and behaviour - however you cannot create a concrete implementation of it - you must inherit from it and extend its behaviour.
Related
This question already has answers here:
Default Interface Methods. What is deep meaningful difference now, between abstract class and interface?
(6 answers)
The difference between abstract classes and interfaces in C# 8 release? [closed]
(3 answers)
What is the difference between an interface with default implementation and abstract class? [duplicate]
(1 answer)
Closed 2 years ago.
With the recent release of C# 8.0 (new feature mentioned here), it allows for providing default method implementation.
While I understand the reason why it's done, I wonder if there is any difference between these 2 concepts?
Thoughts?
To call default interface method You need to cast instance to the interface containing default implementation
You can implement multiple interfaces and cannot inherit multiple abstract classes
It is better to use abstract class for base functionality (provides better inheritance tree logic). And use interfaces with default method implementations to provide small side changes only when this default logic suits for most of implementations (like Microsoft did with their Collection methods).
Also try to not overuse default interface implementations, because this complicates behavior inheritance (you need to search interfaces too, not only classes) from linear to tree.
C++ allows multiple inheritance and without control this aspect can easily make the code unmaintainable.
These are the main differences I see:
Multiple Inheritance
Unlike other languages (like C++), C# does not allow a class to inherit directly from more that one class. On the other hand, a class can implement any number of interfaces, so the new default implementation feature allows you to do something similar to multi-inheritance.
Calling the Default Implementation
If you derive from a class and override a virtual method, you may use the base keyword to call the original implementation. Example:
public abstract class Base
{
public virtual void DoSomething()
{
...
}
}
public class Derived : Base
{
public override void DoSomething()
{
base.DoSomething(); //Here
...
}
}
Constructors and Non-Virtual Members
Abstract classes can declare constructors that the derived class will call. Also, an abstract class can contain non-virtual methods, while an interface can only have overridable (virtual) methods.
The compiler doesn't seem to mind it so far but I just wanted to double check whether I'm setting myself up for failure in any way by implementing certain methods in my abstract class.
An abstract class usually has one or more abstract method. So yes it can have some method implemented. The goal is to force the user to implement these methods to have an object working. Sometimes abstract classes are used to provide a 'base' implementation of some interfaces, leaving the final user to specify just the key methods. You can also have an abstract class without any abstract method: in this case you are asserting you must derive from that class in order to use it.
It's common to have some implementation in abstract classes.
If there is no implementation at all, consider using an interface instead of an abstract class.
Perfectly fine to implement some methods and leave others abstract.
If all methods had to be abstract, you might as well use an interface for it.
Yes. abstract class cannot be instantiated (you have to instantiate a class that inherits from your abstract class), but it can contains implementations.
it's fine and allowed, an abstract class has at least a member (method/property) not implemented so it cannot be instantiated.
an interface is also called pure abstract class which means it's 100% abstract, so does not allow you to specify any implementation.
keep in mind that there are lots of articles and opinions about never deriving a concrete class from another concrete class but only from abstract ones... at least this was the trend in C++ up to some years ago, then I moved to the C# side, started working more and had no time to keep reading those nice articles... :)
This question already has answers here:
Closed 11 years ago.
Possible Duplicate:
When to use an interface instead of an abstract class and vice versa?
Difference between Interface, abstract class, sealed class, static class and partial class in C#?
public class Guru{
public Enemy(int x, int y, int health, int attack, ...) {
...
}
...
}
public class UserDefinedClass extends Enemy {
...
}
If you anticipate creating multiple versions of your component, create an abstract class. Abstract classes provide a simple and easy way to version your components. By updating the base class, all inheriting classes are automatically updated with the change. Interfaces, on the other hand, cannot be changed once created. If a new version of an interface is required, you must create a whole new interface.
An Interface cannot implement methods.
An abstract class can implement methods.
An Interface can only inherit from another Interface.
An abstract class can inherit from a class and one or more interfaces.
An Interface cannot contain fields.
An abstract class can contain fields.
An abstract class can not be instantiated but that can contain code whereas interface only contains method definitions but does not contain any code. you need to implement all the methods defined in the interface.
If your logic will be the same for all the derived classes, it is best to go for a abstract class in stead of an interface.
You can implement multiple interfaces but only inherit from one class.
oAn interface implies the minimal coupling possible between the object and the code that wants to consume it. An abstract class implies some stronger relationship between the classes, and probably some commonality of implementation.
An interface should be used when we want to separate concerns as much as possible (eg Dependency Injection)
An abstract class should be used to model a common family of objects where a strong relationship exists in the domain
What is different between an abstract and an Interface class in C#?
An interface is not a class, it is just a contract that defines the public members that a class must implement.
An abstract class is just a class from which you cannot create an instance. Normally you would use it to define a base class that defines some virtual methods for derived classes to implement.
Rather than writing whole thing here..
try http://www.codeproject.com/KB/cs/abstractsvsinterfaces.aspx
A class can implement multiple interfaces but can only inherit from one abstract class.
An abstract class can provide implementation for it's methods. An interface cannot provide implementations.
the level of interface is higher than abstract.
when u're design the strcuture, draw the uml, u should use interface.
when u're implement, then u should use abstract to extract repeat things.
anyway, the different is not only a syntax problem..
hope it helps.
Google "abstract class vs interface" and you'll get lots of explanatory articles...
A class can implement multiple
interfaces but can only inherit from
one abstract class.
Also, abstract classes may have some functions defined but interfaces will not have any function definition and the deriving class must define all of them.
I would explain this through the usage. Abstract class can be used when there is only one hierarchy, additionally without default implementation; while interface can be used across hierarchies (horizontally), often referred to as a behavior.
Interface is also an abstraction and in c# substitutes multiple class inheritance, so this may be confusing, but you have to distinguish when to use what.
Hope this helps,
Robert
The purpose of an abstract class is to provide a base class definition for how a set of derived classes will work and then allow the programmers to fill the implementation in the derived classes.
When we create an interface, we are basically creating a set of methods without any implementation that must be overridden by the implemented classes. The advantage is that it provides a way for a class to be a part of two classes: one from inheritance hierarchy and one from the interface.
As it currently stands, this question is not a good fit for our Q&A format. We expect answers to be supported by facts, references, or expertise, but this question will likely solicit debate, arguments, polling, or extended discussion. If you feel that this question can be improved and possibly reopened, visit the help center for guidance.
Closed 10 years ago.
Difference between Interface, abstract class, sealed class, static class and partial class in c#? If all classes available in vb.net?
abstract class
Should be used when there is a IS-A relationship and no instances should be allowed to be created from that abstract class.
Example: An Animal is an abstract base class where specific animals can be derived from, i.e. Horse, Pig etc.
By making Animal abstract it is not allowed to create an Animal instance.
interface
An interface should be used to implement functionality in a class. Suppose we want a horse to be able to Jump, an interface IJumping can be created. By adding this interface to Horse, all methods in IJumping should be implemented. In IJumping itself only the declarations (e.g. StartJump and EndJump are defined), in Horse the implementations of these two methods should be added.
sealed class
By making Horse sealed, it is not possible to inherit from it, e.g. making classes like Pony or WorkHorse which you like to be inheriting from Horse.
static class
Mostly used for 'utility' functions. Suppose you need some method to calculate the average of some numbers to be used in the Horse class, but you don't want to put that in Horse since it is unrelated and it also is not related to animals, you can create a class to have this kind of methods. You don't need an instance of such a utility class.
partial class
A partial class is nothing more than splitting the file of a class into multiple smaller files. A reason to do this might be to share only part of the source code to others. If the reason is that the file gets too big, think about splitting the class in smaller classes first.
Interface: method definitions only
Abstract class: some method implementations, some methods abstract (method definition only)
Sealed class: A class from which you
may not inherit
Static class: a class with only
static methods (no instances
exist, all methods may be called
without an instance)
Partial class: A class that is
defined in 2 or more separate
class definitions in different
modules.
Yes, they are all available in both C# and VB, although VB uses different keywords in some cases.
I guess following link will be useful for you.
http://letschattechnology.com/interface-vs-abstract-classes/
the basic logical difference is you create abstract class when there is a relation between two classes that will inherit the abstract class and you create interface for the classes which are not related to each other but do have some common functionality.
A normal class can be instantiated at runtime to form an Object with fields (fields are properties, functions, events, etc). A normal class can also be inherited/sub-classed.
Adding one of the extra keywords change the way the class works.
Adding public, private, protected changes the way other code can see and use this class.
Adding static to a class means you can't create an instance with the new keyword but you can only access it through static function. Example: String.IsNullOrEmpty().
Adding sealed to a class means no other class can inherit the 'sealed' class.
Interfaces are contracts that say an implementing class will supply some functionality. The IDisposable interface says that all classes implementing it will have a Dispose function.
Following are the differences between abstract and interface:
Abstract classes have method declaration as well as method definition whereas interfaces have method declaration only.
Abstract classes are known as partial abstract classes whereas interfaces are known as fully abstract classes.
Abstract class features are inherited by child classes whereas interface features have to be implemented in implementing classes.
Abstract classes support access specifiers whereas interfaces don't support access specifiers.
Abstract classes have normal variables as well as constant variables whereas interfaces do not have variables.
We can write constructors in abstract classes whereas we can't write constructors in interfaces.
In abstract class can provide more functionality without affecting child class.
In interface,if we add any method to interface ,then it will affect all the child class.