Abstraction en C#

L'abstraction est une partie importante de la programmation orientée objet. C# prend en charge l'abstraction, un processus consistant à masquer les détails d'implémentation et à fournir uniquement les informations essentielles à l'utilisateur. En C#, nous pouvons réaliser l'abstraction à l'aide de classes et de méthodes abstraites.

Voici quelques points importants concernant les classes abstraites :

• Nous pouvons définir des classes et des méthodes abstraites en préfixant le nom de la classe et le nom de la méthode avec le mot-clé abstract.
• Nous ne pouvons pas créer un objet d'une classe abstraite.
• Une classe abstraite peut contenir des méthodes abstraites et non abstraites.
• Une classe abstraite ne peut pas être déclarée comme classe scellée.

Syntaxe avec explication :

Nous pouvons déclarer une classe et une méthode abstraites à l'aide du mot-clé abstract, comme indiqué dans la syntaxe ci-dessous :

//abstract class
abstract class class_name
{
//abstract method
public abstract <return_type> method_name();
}

Dans la syntaxe ci-dessus, on peut voir que la méthode abstraite n'a personne. La classe dérivée fournit une implémentation des méthodes abstraites d'une classe abstraite. On peut accéder à la classe abstraite par la classe qui en hérite.

Nous ne pouvons pas déclarer de méthodes abstraites en dehors de la classe abstraite, mais une classe abstraite peut contenir des méthodes non abstraites, comme le montre la syntaxe ci-dessous :

abstract class class_name
{
//abstract method
public abstract <return_type> method_name();
//non-abstract method
public <return_type> method_name()
{
//user code
}
}

Exemples d'abstraction en C#

Parfois, l'utilisateur doit créer une forme généralisée de méthodes et de propriétés dans une superclasse qui peut être partagée par l'ensemble de ses sous-classes, qui peuvent utiliser ces méthodes et propriétés selon leurs besoins en fournissant des implémentations aux méthodes en conséquence.

Exemple n°1

Code :

using System;
namespace abstraction
{
//abstract class
abstract class Shape
{
//abstract methods
public abstract double calculateArea();
public abstract void displayDetails(double area);
}
//Rectangle class inheriting Shape class
class Rectangle : Shape
{
//private data members
private double length;
private double breadth;
public Rectangle(double length, double breadth)
{
this.length = length;
this.breadth = breadth;
}
//overriding abstract methods of Shape class using 'override' keyword
public override double calculateArea()
{
return (length * breadth);
}
public override void displayDetails(double area)
{
Console.Write("Length of rectangle: "+length);
Console.Write("\nBreadth of rectangle: "+breadth);
Console.Write("\nArea of rectangle: "+area);
}
}
//Square class inheriting Shape class
class Square : Shape{
//private data members
private double side;
public Square(double side)
{
this.side = side;
}
//overriding abstract methods of Shape class using 'override' keyword
public override double calculateArea()
{
return (side * side);
}
public override void displayDetails(double area)
{
Console.Write("Length of a side of square: "+side);
Console.Write("\nArea of square: "+area);
}
}
public class AbstractionDemo
{
public static void Main(string[] args)
{
double area;
//creating reference of Shape class using Rectangle class
Shape shapeRec = new Rectangle(5,6);
area = shapeRec.calculateArea();
shapeRec.displayDetails(area);
Console.WriteLine("\n");
//creating reference of Shape class using Square class
Shape shapeSquare = new Square(4);
area = shapeSquare.calculateArea();
shapeSquare.displayDetails(area);
}
}
}

Sortie :

Dans l'exemple ci-dessus, les deux méthodes définies sous la classe abstraite « Shape » sont des méthodes abstraites. Ainsi, Shape est une classe de base purement abstraite et la classe dérivée doit fournir une implémentation pour les deux méthodes de la classe Shape.

Exemple n°2

Code :

using System;
abstract class Mobile
{
public abstract void mobileDetails();
}
class Apple : Mobile
{
public override void mobileDetails()
{
Console.WriteLine("Model: IphoneX");
Console.WriteLine("Screen size: 5.8 inch");
Console.WriteLine("Processor: A11 Bionic Processor");
}
}
class Motorola : Mobile
{
public override void mobileDetails()
{
Console.WriteLine("Model: G5 plus");
Console.WriteLine("Screen size: 5.2 inch");
Console.WriteLine("Processor: octa-core Snapdragon");
}
}
public class AbstractionDemo
{
public static void Main(string[] args)
{
Mobile mobileApple = new Apple();
mobileApple.mobileDetails();
Console.WriteLine("");
Mobile mobileMoto = new Motorola();
mobileMoto.mobileDetails();
}
}

Sortie :

Exemple #3

Une classe abstraite peut également contenir des méthodes non abstraites, comme le montre l'exemple ci-dessous.

Code :

using System;
namespace abstraction
{
abstract class Birds
{
//abstract method
public abstract void birdDetails();
//non-abstract method
public void canFly(bool canFly, string name)
{
if(canFly)
Console.WriteLine(name+" can fly");
else
Console.WriteLine(name+" cannot fly");
}
}
class Parrot : Birds
{
public override void birdDetails()
{
Console.WriteLine("Parrots have different colours and size");
}
}
class Ostrich : Birds
{
public override void birdDetails()
{
Console.WriteLine("Ostrich is the largest living bird");
}
}
public class AbstractionDemo
{
public static void Main(string[] args)
{
Birds birdParrot = new Parrot();
birdParrot.birdDetails();
birdParrot.canFly(true, "Parrot");
Console.WriteLine("");
Birds birdOstrich = new Ostrich();
birdOstrich.birdDetails();
birdOstrich.canFly(false, "Ostrich");
}
}
}

Sortie :

Exemple n°4

Outre les classes et méthodes abstraites, nous pouvons réaliser l'abstraction en C# en utilisant des modificateurs d'accès privés, comme indiqué dans l'exemple ci-dessous.

Code :

using System;
namespace abstraction
{
public class Bank
{
private string name;
private string branch;
private string ifscCode;
public string Name
{
get { return name; }
set { name = value; }
}
public string Branch
{
get { return branch; }
set { branch = value; }
}
public string IfscCode
{
get { return ifscCode; }
set { ifscCode = value; }
}
public void bankDetails()
{
Console.WriteLine("Bank name: " + Name);
Console.WriteLine("Branch name: " + Branch);
Console.WriteLine("IFSC code: " + IfscCode);
}
public void bankAddress()
{
Console.WriteLine("Address: Andheri, Mumbai");
}
private void numberOfAccounts()
{
Console.WriteLine("Account Information");
}
private void numberOfLockers()
{
Console.WriteLine("Locker Information");
}
}
public class AbstractionDemo
{
public static void Main(string[] args)
{
Bank bank = new Bank();
bank.Name = "ABC";
bank.Branch = "XYZ";
bank.IfscCode = "ABC123";
bank.bankDetails();
bank.bankAddress();
//Error -'Bank.numberOfAccounts()' is inaccessible due to its protection level
//bank.numberOfAccounts();
//Error - 'Bank.numberOfLockers()' is inaccessible due to its protection level
//bank.numberOfLockers();
}
}
}

Sortie :

L'exemple ci-dessus montre que les méthodes publiques sont accessibles depuis d'autres classes, mais nous ne pouvons pas appeler de méthodes privées depuis d'autres classes. Ainsi, cela contribue à réaliser l'abstraction en fournissant les seules informations nécessaires et en masquant d'autres détails.

Conclusion – Abstraction en C#

L'abstraction dans la programmation orientée objet assure la sécurité en masquant les détails d'implémentation et en fournissant uniquement les informations nécessaires à l'utilisateur. Nous utilisons une classe abstraite dans laquelle, à l'aide de méthodes abstraites, nous pouvons masquer les détails d'implémentation. L'abstraction peut également être réalisée à l'aide d'interfaces.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!