Che cos'è la classe astratta in C #?
La parola astratto significa un pensiero o un'idea che non ha una sua forma fisica ma che funge da base per altre cose. Lo stesso è il concetto alla base della classe astratta. In questo articolo discuteremo delle lezioni astratte in C #. Una classe astratta è una classe speciale in C # che non può essere istanziata, cioè non è possibile creare oggetti di una classe astratta. Lo scopo di una classe astratta è di fornire una struttura scheletrica da cui derivino altre classi. Le classi astratte non hanno implementazioni proprie. Richiedono agli sviluppatori e ai programmatori di derivare dalla classe astratta e basarsi sulla struttura scheletrica, cioè scrivere la loro implementazione. Una classe astratta può contenere anche dichiarazioni di metodi astratti. Ancora una volta, questi metodi non possono avere definizioni.
La sintassi della dichiarazione di classi e metodi astratti comporta l'inserimento dell'abstract della parola chiave prima della dichiarazione. Così semplice.
Sintassi:
abstract class ClassName
(
public abstract void MethodName();
)
Ricorda, i metodi astratti non possono avere definizioni. Pertanto, le dichiarazioni del metodo astratto terminano con un punto e virgola. Possono solo essere dichiarati. Le definizioni devono essere fornite in classi non astratte derivate.
Come funziona la classe astratta in C #?
La parola chiave astratta indica al compilatore che la classe è una struttura scheletrica della classe base da implementare nelle classi derivate. Se il compilatore rileva una classe derivante dalla classe base astratta, verifica se tutti i metodi e le proprietà astratti vengono sovrascritti e implementati nella classe derivata.
Classe astratta vs interfaccia
Ora, ti starai chiedendo cosa sono tutto questo e quale interfaccia fa. Quindi, in che modo una classe astratta è diversa da un'interfaccia?
Cerchiamo di capirlo con un esempio. Diciamo che gestiamo una casa editrice e abbiamo assunto alcuni redattori per scrivere colonne per la nostra rivista. Supponiamo che siano esperti di diversi generi, scrivano articoli da pubblicare in un giorno specifico della settimana e siano tutti assunti allo stesso stipendio.
Definiamo la classe Employee astratta per i nostri redattori.
Codice:
abstract class EmployeeEditors
(
public abstract void Genre();
public abstract string PublishDay();
public int Payment()
(
Console.Write(“Monthly salary is (0)$.”, 1000);
)
)
Potremmo facilmente implementare il metodo di pagamento sapendo che sarebbe lo stesso per tutti. Gli altri due metodi sono stati dichiarati astratti per essere implementati dalla classe derivata. Si potrebbe dichiarare una classe normale per ciascun editor derivante dalla classe astratta e quindi implementare i metodi astratti per definire generi e giorni. Ora, supponiamo che anche lo stipendio di ciascun editore sia diverso. Un modo per modificare il nostro codice è dichiarare astratto il metodo di pagamento. L'altro modo sarebbe dichiarare l'intero EmployeeEditor come un'interfaccia e dare piena libertà all'ereditarietà delle classi.
Public interface EmployeeEditors
(
public abstract void Genre();
public abstract string PublishDay();
public abstract int Payment();
)
Pertanto, una classe astratta è una classe di base su cui costruire altre classi. Considerando che, un'interfaccia è un progetto per altre classi a cui fare riferimento e costruire da zero.
Regole di classe astratta in C #
Ci sono alcune regole da seguire quando si lavora con classi astratte.
- Poiché le classi astratte hanno definizioni di metodo incomplete, non possono quindi essere istanziate. Qualsiasi tentativo di creare un oggetto di una classe astratta comporterebbe un errore di compilazione.
- I metodi astratti non possono essere definiti in classi astratte, ma solo dichiarati. Il corpo del metodo deve essere definito in classi derivate.
- Le classi derivate devono implementare tutti i metodi astratti.
- I metodi astratti non possono essere statici o virtuali.
Esempio di classe astratta in C #
Dichiarazione del problema: prendiamo un altro esempio del mondo reale. Supponiamo che ti venga chiesto di automatizzare il processo di generazione della lettera di offerta per una determinata organizzazione. Il processo attuale è completamente manuale e richiede la modifica di lettere di offerta esistenti, che sono soggette a errori. Ci sono alcune cose che sarebbero comuni per tutte le lettere di offerta, come luogo di lavoro, orari di lavoro, titolo dell'azienda, marchio dell'azienda, ecc. Altre cose come nome del dipendente, posizione, stipendio, data di iscrizione, ecc. Sono specifiche di ciascuna offerta lettera.
Soluzione : progetterai una classe astratta per lo scopo sopra. Vediamo come.
Codice:
ode: using System;
abstract class OfferLetter
(
public abstract string Name(string name);
public abstract string Designation(string designation);
public abstract int Payment(int pay);
public abstract string DOJ(string doj);
public string CompanyName()
(
return "XYZ Corporation Pvt. Ltd.";
)
public string OfficeAddress()
(
return "512, Manhattan, NY";
)
public string CompanyBranding()
(
return this.CompanyName() + " is a privately owned regsitered corporation operating \n under the license provided by the state of New York.";
)
public string Disclaimer()
(
return "This letter and its contents are confidential in nature and are intended only \n for the recipient."+
"\nIf you are not the correct recipient, kindly return it immediately \n to " + this.CompanyName() + " " + this.OfficeAddress() + ".";
)
)
class PrintOfferLetter : OfferLetter
(
public override string Name(string name)
(
return name;
)
public override string Designation(string designation)
(
return designation;
)
public override int Payment(int pay)
(
return pay;
)
public override string DOJ(string doj)
(
return doj;
)
)
public class Program
(
public static void Main()
(
PrintOfferLetter ltr = new PrintOfferLetter();
string empName = "Mr. ABC", designation = "Senior Consultant", doj = "20-02-2020";
int pay = 50000;
Console.WriteLine(ltr.CompanyName() + " is very happy to extend this offer letter to \n" + ltr.Name(empName)
+ " at the designation of " + ltr.Designation(designation) + " with an annual pay of " + ltr.Payment(pay) + "$.");
Console.WriteLine("\nYou are required to report at " + ltr.OfficeAddress() + " from " + ltr.DOJ(doj) + " (dd-mm-yyyy).");
Console.WriteLine("\n\n" + ltr.CompanyBranding());
Console.WriteLine("\n\n" + ltr.Disclaimer());
)
)
Produzione:
Conclusione
In poche parole, una classe astratta è semplicemente una classe incompleta o parzialmente completa che altre classi possono derivare e costruire la loro logica su di essa. In questo articolo, abbiamo visto come viene dichiarata e funziona una classe astratta. Abbiamo visto esempi di vita reale sull'uso di classi astratte e su come siano diverse dalle interfacce. Si consiglia di provare a utilizzare le classi astratte il più possibile nel codice. Questa è una pratica cruciale per una buona programmazione.
Articoli consigliati
Questa è una guida alla classe astratta in C #. Qui discutiamo la definizione e come funziona la classe astratta in C # insieme a regole e un esempio. Puoi anche consultare i nostri altri articoli correlati per saperne di più -
- Quali sono le classi astratte in JavaScript?
- Classe astratta in C ++? (esempi)
- Che cos'è la classe astratta in PHP?
- Panoramica di Abstract Class in Python