C# Classe astratta

Una classe astratta si occupa del processo di astrazione. È un fenomeno in cui i dettagli di qualsiasi metodo sono nascosti e viene mostrata solo la funzionalità. Non è un'implementazione completa. Non possiamo istanziare direttamente una classe astratta; Può essere creato senza usare un metodo astratto. Lo scopo elementare di una classe astratta è offrire una guida per tutte le classi derivate ereditate da essa.

La sintassi per la classe astratta:

Esempio di classe astratta

Una parola chiave "astratta" viene utilizzata per generare una classe astratta. Mentre nel caso di una funzione astratta, non contiene nessuno dichiarato solo all'interno della classe. Un metodo astratto viene utilizzato all'interno del derivato, oppure puoi dire in tutte le classi di non abstract utilizzando una parola chiave "override". Utilizzando questa parola chiave, un metodo astratto non è nello stato di astrazione; Può essere usato come funzione normale. Una classe derivata che è il figlio della classe astratta può scavalcare gli stessi metodi astratti.

La sintassi per un metodo astratto:

Public Abstract void SMP ();

Struttura di una classe astratta

Una classe astratta viene utilizzata principalmente nel processo di eredità. Le strutture non possono scavalcare alcuna classe astratta. Una classe astratta non è a favore di eredità multiple. Allo stesso modo, una classe astratta non può essere dichiarata come classe statica, poiché non è possibile derivare una classe statica.

Esempio 1

Per implementare il concetto di una classe astratta, abbiamo creato un programma di esempio. In cui abbiamo usato un campione di classe con la parola chiave astratta. All'interno della classe, si afferma un metodo astratto. La classe astratta ha sempre un metodo astratto.

Public Abstract Class Sample ()
Public Abstract void SMP] ();

Come definiamo solo la funzionalità dei metodi astratti all'interno della classe astratta, invece di spiegare il funzionamento delle funzioni, quindi solo l'intestazione della funzione è dichiarata qui.

Non è possibile accedere a una classe astratta direttamente perché non ne creiamo un oggetto; Si dice che sia una classe fittizia o una classe non attiva fino a quando non diventa attiva creando un oggetto della classe derivato da esso. Quindi guideremo il campione di classe1 dal campione di classe astratto di base. Questa classe non è astratta. La classe di esempio è ereditata nella classe figlio campione1. Il modo di rappresentare una classe intrinseca dalla classe base è usare il nome della classe genitore con un segno di colon di fronte alla classe derivata. Ecco campione1 è una classe derivata.

# Campione di classe pubblica1: campione

Quando ereditiamo una classe dalla classe astratta, può utilizzare le funzionalità e i metodi presenti all'interno della classe astratta. Ad esempio, il metodo SMP () può essere dichiarato nella classe Sample1, ma non con il nome di Abstract perché non è più una classe astratta. È scritto con la parola chiave "override" per descrivere che è ereditata da una classe astratta. Un'istruzione semplice viene visualizzata all'interno del programma.

# Public Override void SMP ()

Allo stesso modo, un altro campione di classe2 viene ereditato dal campione di classe. E utilizza anche il metodo di override SMP (). Per inizializzare la classe astratta, non creeremo un oggetto per questo. Ma l'istanza della classe derivata o della bambina sarà istanziata. La classe astratta diventerà automaticamente attiva e sarà possibile accedere facilmente creando l'oggetto.

# Campioni;

's' è l'oggetto della classe di esempio; è creato, ma non è istanziato.

# S = new Sample1 ()

Questa creazione dinamica istanzierà la classe Sample1 utilizzando un "nuovo" operatore. Ora accederemo alla funzione dichiarata all'interno della classe astratta attraverso questo oggetto.

Allo stesso modo, verrà creato lo stesso oggetto per la classe Sample2. E poi, chiameremo la funzione dalla classe genitore. Quando istanziamo l'oggetto per la classe, lo useremo per la chiamata della funzione nel passaggio successivo, rendendola immediatamente specificata per la funzione utilizzata all'interno della classe.

Salva il codice; Lo eseguiremo nel terminale Ubuntu, useremo il compilatore MCS per compilare il codice e mono per eseguirlo.

File $ MCS.cs
File $ mono.exe

Durante l'esecuzione, è possibile vedere che vengono visualizzati entrambi i valori all'interno delle funzioni.

Esempio 2

Usando una classe astratta, ora calcoleremo l'area. Quindi viene creata una classe astratta per l'area, in cui verrà definito un metodo astratto per l'area.

Classe di classe astratta
Abstract Public int Area ();

Un quadrato di classe derivato sarà ereditato dalla classe base. Questo calcolerà l'area usando il metodo astratto al suo interno. Innanzitutto, viene dichiarata una variabile per ottenere il numero dal programma principale.

# Class Square: Area Class

Viene creato un costruttore per assegnare il valore inviato dal programma principale. Quindi la funzione verrà sovrascritta dalla classe astratta. Questo metodo calcolerà l'area del quadrato moltiplicando entrambi i lati.

Crea un'altra classe per dichiarare il programma principale. Qui, l'oggetto per la classe figlio viene creato e verrà istanziato in quanto dobbiamo inviare il numero al costruttore della classe quadrata per creare l'oggetto.

# Square S = new Square (15);

Usando lo stesso oggetto, la funzione verrà chiamata.

S.La zona ();

La console stamperà l'area calcolata dalla funzione.

Esempio 3

La classe astratta non ha bisogno di contenere tutti i metodi astratti. Ma inoltre, i metodi non di astratto possono essere dichiarati in una classe astratta. Abbiamo usato l'esempio seguente per elaborare questo concetto. Crea una classe astratta. Viene creata una semplice funzione ed è in uno stato completamente funzionato, in quanto accetta i parametri inviati dalla chiamata della funzione e restituisce la somma di entrambi i numeri.

# Public int Sum (int num1, int num2)

Dopo la dichiarazione della funzione regolare, viene definito un metodo astratto, ma il suo corpo non è dichiarato qui in quanto è una funzione astratta.

# Public Abstract int multiply (int num1, int num2)

Dopo la classe astratta, creeremo una classe derivata che erediterà la funzione astratta della moltiplicazione.

Classe derivata: AbstractClass
PUBBLICO OVERRID INT MULTIPLY (int NUM1, int NUM2)

Questa funzione moltiplicherà entrambi i valori e quindi restituirà la risposta.

Ora creeremo un programma principale per creare l'oggetto.

Derivato d = new derited ();
D.somma (20, 8);
D.moltiplicare (20, 8);

Conclusione

Una classe astratta in C Sharp viene creata per nascondere le informazioni solo definendo l'intestazione della funzione. Questa classe astratta non è funzionale fino a quando non viene derivata un'altra classe per bambini. Una classe astratta viene utilizzata nell'eredità; Altrimenti, la dichiarazione di una classe astratta è inutile. A causa dell'eredità, lo accessiamo creando e istanziando l'oggetto per la classe figlio. Non è obbligatorio che una classe astratta debba avere tutti i metodi astratti al suo interno. Abbiamo spiegato il lavoro e la dichiarazione di una classe astratta usando alcuni esempi e implementandoli in Ubuntu.