OOPS Concepts in C#

What is an Abstract class?

An abstract class only allows other classes to inherit from it and cannot be instantiated. When we create an abstract class, it should have one or more completed methods but at least one or more uncompleted methods and these must be preceded by the key word abstract. If all the methods of an abstract class are uncompleted then it is the same as an interface, but there is a restriction that it cannot make a class inherit from it, which means it can not work as a base class.

What is an Interface?

An interface is defined by the key word interface. An interface has no implementation; it only has the definition of the methods without the body. When we create an interface, we are basically creating a set of methods without any implementation. A class implementing an interface must provide the implementation of the interface members. All the methods and properties defined in an interface are by default public and abstract. Define an Abstract Class In the following code listing an abstract class named Product has been defined. Listing 1 public abstract class Product { //fields protected string id; protected double price; //properties public abstract string ID { get; set; } public abstract double Price { get; set; } public abstract double CalculatePrice(); } Define an Interface In the following code listing an interface named Iproduct has been defined. Listing 2 public interface Iproduct { string ID { get; set; } double Price { get; set; } double CalculatePrice(); } Implementation In the following code listing the Iproduct interface has been implemented by the class implementInterface. Listing 3 public class implementInterface: Iproduct { protected string id; protected double price; public string ID { get { return id; } set { id = value; } } public double price { get { return price; } set { price = value; } } public double CalculatePrice() { return Price * 1.25; } In the following code listing the abstract Class named Product has been implemented by the class implementAbstract. Listing 4 public class implementAbstract: Product { public override string ID { get { return id; } set { id = value; } } public override double Price { get { return price; } set { price = value; } } public override double CalculatePrice { return Price * 1.25; } } How to Test In the following code listing abstract class implementation is being tested. Listing 5 ImplementAbstract testAbstract=new implementAbstract(); testAbstract.ID=”A1”; testAbstract.Price=1000.00; double amt=testAbstract.CalculatePrice(); Response.Write(“Total Net Price of Product : “ +” “+testAbstract.ID +” “+ “is”+” “+amt); Response.Write(“ ”); In the following code listing the implementation of our interface is being tested. Listing 6 ImplementInterface testInterface=new implementInterface(); testInterface.ID=”B1”; testInterface.Price=900.00; double Iamt= testInterface.CalculatePrice(); Response.Write(“Total Net Price of Product : “ +” “+testInterface.ID +” “+ “is”+” “+Iamt); Response.Write(“ ”); It should be noted that static members are not inherited under any circumstances. Hence we can not declare a static method in an interface because interfaces have no implementation. We can, however, declare a method as static in an abstract class, because abstract classes can have implementations of static methods. This has been described in the following code listing: Listing 7 In an abstract class: public static void test() { } But we can not write the following in an interface. Listing 8 static void test();

Abstract Class vs. Interface

An abstract class may contain complete or incomplete methods. Interfaces can contain only the signature of a method but no body. Thus an abstract class can implement methods but an interface can not implement methods. An abstract class can contain fields, constructors, or destructors and implement properties. An interface can not contain fields, constructors, or destructors and it has only the property's signature but no implementation. An abstract class cannot support multiple inheritance, but an interface can support multiple inheritance. Thus a class may inherit several interfaces but only one abstract class. A class implementing an interface has to implement all the methods of the interface, but the same is not required in the case of an abstract Class. Various access modifiers such as abstract, protected, internal, public, virtual, etc. are useful in abstract Classes but not in interfaces. Abstract classes are faster than interfaces.

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: Listing 9 public sealed class classSealed { // Class members here. public string ID; public double Price; } In the following code listing the implementation of a sealed class has been tested. Listing 10 classSealed sc=new classSealed(); sc.ID=”C1”; sc.Price=500.00; double Samt=sc. CalculatePrice(); Response.Write(“Total Net Price of Product : “ +” “+sc.ID +” “+ “is”+” “+Samt); Response.Write(“ ”); 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 can not derive from it. Sealing a method means one can not 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). Listing 11 public class TestClass : classSealed { } In C# a method can not 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. Listing 12 public class testClass { public int x; public int y; public virtual void testMethod(){ } } public class TestClass: testClass { public override sealed void testMethod(){ } }