Abstraktion ist ein wichtiger Teil der objektorientierten Programmierung. C# unterstützt die Abstraktion, einen Prozess, bei dem Implementierungsdetails ausgeblendet werden und dem Benutzer nur wesentliche Informationen bereitgestellt werden. In C# können wir Abstraktion mithilfe abstrakter Klassen und Methoden erreichen.
Im Folgenden finden Sie einige wichtige Punkte zu abstrakten Klassen:
Syntax mit Erklärung:
Wir können abstrakte Klassen und Methoden mit Hilfe des Schlüsselworts abstract deklarieren, wie in der folgenden Syntax gezeigt:
//abstract class
abstract class class_name
{
//abstract method
public abstract <return_type> method_name();
}In der obigen Syntax können wir sehen, dass die abstrakte Methode niemanden hat. Die abgeleitete Klasse stellt eine Implementierung der abstrakten Methoden einer abstrakten Klasse bereit. Wir können auf die abstrakte Klasse über die von ihr geerbte Klasse zugreifen.
Wir können keine abstrakten Methoden außerhalb der abstrakten Klasse deklarieren, aber eine abstrakte Klasse kann nicht abstrakte Methoden enthalten, wie in der folgenden Syntax gezeigt:
abstract class class_name
{
//abstract method
public abstract <return_type> method_name();
//non-abstract method
public <return_type> method_name()
{
//user code
}
}Manchmal muss der Benutzer eine verallgemeinerte Form von Methoden und Eigenschaften in einer Oberklasse erstellen, die von allen Unterklassen gemeinsam genutzt werden kann, die diese Methoden und Eigenschaften entsprechend ihren Anforderungen verwenden können, indem sie entsprechende Implementierungen für die Methoden bereitstellen.
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);
}
}
}Ausgabe:
Im obigen Beispiel sind beide unter der abstrakten Klasse „Shape“ definierten Methoden abstrakte Methoden. Somit ist Shape eine rein abstrakte Basisklasse und die abgeleitete Klasse muss eine Implementierung für beide Methoden der Shape-Klasse bereitstellen.
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();
}
}Ausgabe:
Eine abstrakte Klasse kann auch nicht abstrakte Methoden enthalten, wie im folgenden Beispiel gezeigt.
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");
}
}
}Ausgabe:
Abgesehen von abstrakten Klassen und Methoden können wir in C# eine Abstraktion mithilfe privater Zugriffsmodifikatoren erreichen, wie im folgenden Beispiel gezeigt.
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();
}
}
}Ausgabe:
Das obige Beispiel zeigt, dass auf öffentliche Methoden von anderen Klassen aus zugegriffen werden kann, wir jedoch keine privaten Methoden von anderen Klassen aufrufen können. Somit trägt es zur Abstraktion bei, indem es nur die notwendigen Informationen bereitstellt und andere Details verbirgt.
Abstraktion in der objektorientierten Programmierung bietet Sicherheit, indem Implementierungsdetails ausgeblendet werden und dem Benutzer nur die notwendigen Informationen bereitgestellt werden. Wir verwenden eine abstrakte Klasse, in der wir mithilfe abstrakter Methoden Implementierungsdetails verbergen können. Abstraktion kann auch über Schnittstellen erreicht werden.
Das obige ist der detaillierte Inhalt vonAbstraktion in C#. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
