This
table is for showing relationship between a base class and child class
In
this table I want to show the accessibility among the various types of classes
and interface. From this table you also can know what type of class can be
initiated. This is one example that helps you to understand the table.
If
you use Abstract class as base class and take a general class as child and want
to inherit, this will possible …here you can see..
Base:
Abstract (ASadi)
Child:
Interface (Sadi)
Accessibility:
Yes
abstract class Sadi : ASadi
{
#region ASadi Members
public int getint() {
throw new Exception(“The method or operation is not implemented.”); }
#endregion
}
If
you execute this code, it executes properly
From
the first column of the table we can say that general class inherites both
general and abstract class and also implements an interface. These classes
cannot inherites sealed as well as static class. Only General and Sealed
classes can be initiated.
From
the table and above discussion we can conclude that,
Abstract Class
A
class defined as abstract is used as a base class. Such a class is used for the
purpose of inheritance only i.e. other classes are derived from this class. We
cannot create an object of an abstract class. An abstract class may contain
methods and properties. The classes derived from the abstract class inherit
these methods and properties. The abstract class may also contain abstract
methods and properties. Abstract method and properties do not have any
functionality. The derived class defines their full functionality.
Here
is an example of an abstract class:
abstract
class MyAbstract { public abstract void AbMethod(); }
Sealed Class
Classes
can be declared as sealed. This is accomplished by putting the sealed keyword
before the keyword class in the class definition. For example:
public sealed class classSealed { // Class members here. public string ID; public double Price; }
A
sealed class cannot be used as a base class. For this reason, it cannot also be
an abstract class. Sealed classes are primarily used to prevent derivation.
Because they can never be used as a base class, some run-time optimizations can
make calling sealed class members slightly faster. Sealing a class means one
cannot derive from it. Sealing a method means one cannot override it. In C#
structs are implicitly sealed; therefore, they cannot be inherited. If we try
to inherit from a sealed class in another class we will get compile time error
about Inconsistent accessibility (code is shown in following code listing). In
C# a method cannot be declared as sealed. However when we override a method in
a derived class, we can declare the overridden method as sealed as shown below.
By declaring it as sealed, we can avoid further overriding of this method.
Static Class
Static
classes are classes that contain only static members. Following is an example
of static class. public static MyClass { …..}
A
class can be declared static,
which indicates that it contains only static members. It is not possible to use
the new keyword
to create instances of a static class. Static classes are loaded automatically
by the .NET Framework common language runtime (CLR) when the program or
namespace that contains the class is loaded.
Use
a static class to contain methods that are not associated with a particular
object. For example, it is a common requirement to create a set of methods that
do not act on instance data and are not associated to a specific object in your
code. You could use a static class to hold those methods.
Following
are the main features of a static class:
· They only contain static members.
· They cannot be instantiated.
· They are sealed.
Creating
a static class is therefore basically the same as creating a class that
contains only static members and a private constructor. A private constructor
prevents the class from being instantiated.
The
advantage of using a static class is that the compiler can check to make sure
that no instance members are accidentally added. The compiler will guarantee
that instances of this class cannot be created.
Static
classes are sealed and therefore cannot be inherited. They cannot inherit from
any class exceptObject.
Static classes cannot contain an instance constructor; however, they can have a
static constructor. For more information, see Static Constructors (C# Programming Guide).
