Home > DeveloperSection > Blogs > Abstraction in c# with example

Abstraction in c# with example


C# C# 
Ratings:
3 Comment(s)
 39251  View(s)
Rate this:

Abstraction in c# with example


In object-oriented software, complexity is managed by using abstraction. Abstraction is a process that involves identifying the critical behavior of an object and eliminating irrelevant and complex denials. Abstraction is a process of identifying the relevant qualities and behaviors an object should possess.

Example- A Laptop consists of many things such as processor, motherboard, RAM, keyboard, LCD screen, wireless antenna, web camera, USB ports, battery, speakers etc. To use it, you don't need to know how internally LCD screens, keyboard, web camera, battery, wireless antenna, speaker’s works.  You just need to know how to operate the laptop by switching it on.

Note- When derived class inherited with abstract class; derived class must be override abstract class methods.

Example of Abstraction:

using System;

using System.Collections.Generic;

using System.Linq;

namespace abstarction

{

    public abstract class university

    {

        public abstract void BTech();

        public abstract void MBA();

    }

    public class GBTU : university

    {

        public override void BTech()

        {

            Console.WriteLine("GBTU BTech Fee 50000/-");

        }

        public override void MBA()

        {

            Console.WriteLine("GBTU MBA Fee 100000/-");

        }

    }

    public class MTU : university

    {

        public override void BTech()

        {

            Console.WriteLine("MTU BTech Fee 40000/-");

        }

      public override void MBA()

        {

            Console.WriteLine("MTU MBA Fee 800000/-");

        }

    }

    class Program

    {

        static void Main(string[] args)

        {

            GBTU g = new GBTU();

            g.BTech();

            g.MBA();

            MTU m = new MTU();

            m.BTech();

            m.MBA();

            Console.ReadLine();

        }

    }

}

Output-

GBTU BTech Fee 50000/-

GBTU MBA Fee 100000/-

MTU BTech Fee 40000/-

MTU MBA Fee 800000/-

Explanation :-

Ø  From above example we have make one abstract class university and two abstract methods Btech and MBA. GBTU and MTU both are override university course fee.

Ø  University course common for both GBTU and MTU so university method BTech and MBA is abstract.

Ø  GBTU and MTU inherited abstract method so university method must be override here.


why used abstract class in above code?

By Rajendra thakur on   one year ago
Suppose we remove abstract class from above code and remove virtual keyword from functions then result will be same.

So why we use abstract class?
What exactly we are hiding?

Abstract Class

By John Smith on   one year ago

Abstract classes are closely related to interfaces. They are classes that cannot be instantiated, and are frequently either partially implemented, or not at all implemented. One key difference between abstract classes and interfaces is that a class may implement an unlimited number of interfaces, but may inherit from only one abstract (or any other kind of) class. A class that is derived from an abstract class may still implement interfaces. Abstract classes are useful when creating components because they allow you specify an invariant level of functionality in some methods, but leave the implementation of other methods until a specific implementation of that class is needed. They also version well, because if additional functionality is needed in derived classes, it can be added to the base class without breaking code.

An abstract class is denoted in Visual Basic by the keyword MustInherit. In C#, the abstract modifier is used. Any methods that are meant to be invariant may be coded into the base class, but any methods that are to be implemented are marked in Visual Basic with the MustOverride modifier. In C#, the methods are marked abstract.

http://www.mindstick.com/Blog/361/Abstraction#.VTYwIZMSwX8
http://www.mindstick.com/Blog/551/Encapsulation%20in%20C%20and%20OOPs#.VTYwJZMSwX8
http://www.mindstick.com/Forum/1050/Abstraction#.VTYxZJMSwX8


All about abstract classes

By Santosh Kumar Singh on   6 months ago

Introduction:-

 Abstract classes are one of the essential behaviors provided by .NET. Commonly, you would like to make classes that only represent base classes, and don’t want anyone to create objects of these class types. You can make use of abstract classes to implement such functionality in C# using the modifier 'abstract'.

An abstract class means that, no object of this class can be instantiated, but can make derivations of this.

An example of an abstract class declaration is:

 

abstract class absClass

{

}

An abstract class can contain either abstract methods or non abstract methods. Abstract members do not have any implementation in the abstract class, but the same has to be provided in its derived class.

An example of an abstract method:

abstract class absClass

{

  public abstract void abstractMethod();

}

Also, note that an abstract class does not mean that it should contain abstract members. Even we can have an abstract class only with non abstract members.

For example:

abstract class absClass

{

    public void NonAbstractMethod()

    {

        Console.WriteLine("NonAbstract Method");

    }

}

A sample program that explains abstract classes:

using System;

 

namespace abstractSample

{

      //Creating an Abstract Class

      abstract class absClass

      {

            //A Non abstract method

            public int AddTwoNumbers(int Num1, int Num2)

            {

                return Num1 + Num2;

            }

 

            //An abstract method, to be

            //overridden in derived class

            public abstract int MultiplyTwoNumbers(int Num1, int Num2);

      }

 

      //A Child Class of absClass

      class absDerived:absClass

      {

            [STAThread]

            static void Main(string[] args)

            {

               //You can create an

               //instance of the derived class

 

               absDerived calculate = new absDerived();

               int added = calculate.AddTwoNumbers(10,20);

               int multiplied = calculate.MultiplyTwoNumbers(10,20);

               Console.WriteLine("Added : {0},

                       Multiplied : {1}", added, multiplied);

            }

 

            //using override keyword,

            //implementing the abstract method

            //MultiplyTwoNumbers

            public override int MultiplyTwoNumbers(int Num1, int Num2)

            {

                return Num1 * Num2;

            }

      }

}

In the above sample, you can see that the abstract class absClass contains two methods AddTwoNumbers and MultiplyTwoNumbers.

AddTwoNumbers is a non-abstract method which contains implementation and MultiplyTwoNumbers is an abstract method that does not contain implementation.The class absDerived is derived from absClass and the MultiplyTwoNumbers is implemented on absDerived.

Within the Main, an instance (calculate) of the absDerived is created, and calls AddTwoNumbers and MultiplyTwoNumbers.

You can derive an abstract class from another abstract class. In that case, in the child class it is optional to make the implementation of the abstract methods of the parent class.

Example

//Abstract Class1

abstract class absClass1

{

    public abstract int AddTwoNumbers(int Num1, int Num2);

    public abstract int MultiplyTwoNumbers(int Num1, int Num2);

}

 

//Abstract Class2

abstract class absClass2:absClass1

{

    //Implementing AddTwoNumbers

    public override int AddTwoNumbers(int Num1, int Num2)

    {

        return Num1+Num2;

    }

}

 

//Derived class from absClass2

class absDerived:absClass2

{

    //Implementing MultiplyTwoNumbers

    public override int MultiplyTwoNumbers(int Num1, int Num2)

    {

        return Num1*Num2;

    }

}

In the above example, absClass1 contains two abstract methods AddTwoNumbers and MultiplyTwoNumbers. The AddTwoNumbers is implemented in the derived class absClass2. The class absDerived is derived from absClass2 and the MultiplyTwoNumbers is implemented there.

 

Abstract properties:-

Following is an example of implementing abstract properties in a class.

//Abstract Class with abstract properties

abstract class absClass

{

    protected int myNumber;

    public abstract int numbers

    {

        get;

        set;

    }

}

 

class absDerived:absClass

{

    //Implementing abstract properties

    public override int numbers

    {

        get

        {

            return myNumber;

         }

        set

        {

            myNumber = value;

        }

    }

}

 

In the above example, there is a protected member declared in the abstract class. The get/set properties for the member variable myNumber is defined in the derived class absDerived.

 

Important rules applied to abstract classes:-

An abstract class cannot be a sealed class. I.e. the following declaration is incorrect.

//Incorrect

 

abstract sealed class absClass

{

}

Declaration of abstract methods are only allowed in abstract classes.

An abstract method cannot be private.

//Incorrect

private abstract int MultiplyTwoNumbers()

The access modifier of the abstract method should be same in both the abstract class and its derived class. If you declare an abstract method as protected, it should be protected in its derived class. Otherwise, the compiler will raise an error.

An abstract method cannot have the modifier virtual. Because an abstract method is implicitly virtual.

//Incorrect

public abstract virtual int MultiplyTwoNumbers();

An abstract member cannot be static.

//Incorrect

publpublic abstract static int MultiplyTwoNumbers();

 

Abstract class vs. Interface:-

An abstract class can have abstract members as well non abstract members. But in an interface all the members are implicitly abstract and all the members of the interface must override to its derived class.

An example of interface:

interface iSampleInterface

{

  //All methods are automaticall abstract

  int AddNumbers(int Num1, int Num2);

  int MultiplyNumbers(int Num1, int Num2);

}

  • Defining an abstract class with abstract members has the same effect to defining an interface. The members of the interface are public with no implementation. Abstract classes can have protected parts, static methods, etc.
  • A class can inherit one or more interfaces, but only one abstract class.
  • Abstract classes can add more functionality without destroying the child classes that were using the old version. In an interface, creation of additional functions will have an effect on its child classes, due to the necessary implementation of interface methods to classes.
  • The selection of interface or abstract class depends on the need and design of your project. You can make an abstract class, interface or combination of both depending on your needs.

Don't want to miss updates? Please click the below button!

Follow MindStick