Abstraction in C#
Abstraction is a principle of object-oriented
programming language (OOP) that is used to hide the implementation details and
display only essential features of the object.
In Abstraction, by using access modifiers we
can hide the required details of the object and expose only necessary methods and properties through
the reference of an object.
Abstraction can be achieved using abstract classes in C#. C#
allows you to create abstract classes that are used to provide a partial class
implementation of an interface. Implementation is completed when a derived
class inherits from it. Abstract classes contain abstract methods, which are
implemented by the derived class. The derived classes have more specialized
functionality.
The following are some of the key points −
- You cannot create an instance
of an abstract class
- You cannot declare an abstract
method outside an abstract class
- When a class is declared
sealed, it cannot be inherited, abstract classes cannot be declared
sealed.
In real-time, the mobile phone is a
perfect example of abstraction in c#. A mobile phone consists of many things
such as processor, storage, motherboard, screen, camera, battery, speakers,
etc. To use it, we just need to know how to operate the phone by switching it
on, we don’t need to know how internally all the parts are working. Here, the phone
is an object which is designed to expose only required features by hiding its
implementation details.
In object-oriented programming, a class is
the perfect example of abstraction. In C#, we can create a class with required methods, properties and
we can expose only necessary methods and properties using access modifiers based
on our requirements.
Following is the example of defining a class with required methods, properties and
exposing it by using access modifiers to
achieve abstraction functionality.
public class Phone
{
private string brand;
private string model;
public string Brand
{
get { return brand;
}
set { brand = value; }
}
public string Model
{
get { return model;
}
set { model = value; }
}
public void
PhoneDetails()
{
Console.WriteLine("Brand: " + Brand);
Console.WriteLine("Model: " + Model);
}
public void
PhoneKeyboard()
{
Console.WriteLine("Type using Keyword");
}
private void
MotherBoardInfo()
{
Console.WriteLine("MotheBoard Information");
}
private void
InternalProcessor()
{
Console.WriteLine("Processor Information");
}
}
From the above code snippets, we defined
a Phone class with required fields,
properties
and methods with the public, private access modifiers to achieve an abstraction functionality by
hiding and exposing some of the methods and properties based on our requirements.
Here, the public modifier is used to allow defined fields, properties and methods to access outside of the class
and the private modifier is used to hide or
restrict access of required fields,
properties
and methods from the outside of class.
By creating an instance of Phone class we can access defined fields, properties, and methods. Following is the pictorial
representation of creating an instance of a class and accessing fields, properties and methods.
If we observe the above
image, we will notice that we are exposing only the necessary properties and methods outside of the class by using public and private access modifiers.
Abstraction Example in C#
The following code
snippets form the example of implementing an abstraction functionality by
allowing only a few properties and methods to
access outside of the class.
using System;
using System.Text;
namespace CsharpnaijaTutorial
{
public class Phone
{
private string brand;
private string model;
public string Brand
{
get { return brand;
}
set { brand = value; }
}
public string Model
{
get { return model;
}
set { model = value; }
}
public void
PhoneDetails()
{
Console.WriteLine("Brand: " + Brand);
Console.WriteLine("Model: " + Model);
}
public void
PhoneTouchPad()
{
Console.WriteLine("Type using Keyword");
}
private void
MotherBoardInfo()
{
Console.WriteLine("MotheBoard Information");
}
private void
InternalProcessor()
{
Console.WriteLine("Processor Information");
}
}
class Program
{
static void Main(string[] args)
{
Phone phone = new Phone();
phone.Brand = "Tecno";
phone.Model = "Camon 11 Pro";
phone.PhoneDetails();
Console.WriteLine("\nPress Enter Key to Exit..");
Console.ReadLine();
}
}
}
Based on the example above,
we defined fields, properties and methods with public, private access modifiers to allow or disallow properties, methods access based on requirements.
Difference between Abstraction and Encapsulation
The differences between abstraction and encapsulation
is that abstraction is used to hide
unwanted data and shows only the required properties and methods while encapsulation is used to bind data
members and member functions into a single unit to prevent outsiders to access
it directly.
Thank you
References
1.
Tutlane
Comments
Post a Comment