Menu

Concetti di C #: Constructor, Destructor, Static Class, Struct ed Enum

  • Principale
  • Altro
  • Concetti di C #: Constructor, Destructor, Static Class, Struct ed Enum

c concepts constructor

Prova Il Nostro Strumento Per Eliminare I Problemi

Questo tutorial spiega alcuni dei concetti importanti nella programmazione C # come costruttore, distruttori, classe statica, strutture ed enumerazioni:

In uno dei nostri tutorial precedenti su Oggetti e classi, abbiamo imparato cosa sono una classe e un oggetto.

Un oggetto è simile a un oggetto del mondo reale e una classe è una raccolta logica di tipi simili di oggetti. È uno dei tipi più fondamentali presenti in C #. In questo tutorial, ci immergeremo in profondità negli altri concetti C # correlati.

=> Esplora la serie completa di formazione C # qui

Costruttore C # e altri concetti

In questo tutorial impareremo alcuni aspetti importanti delle classi e come possiamo usarli nei nostri programmi. Cercheremo di creare semplici programmi C # basati sui concetti che abbiamo appreso nei nostri tutorial precedenti.

Cosa imparerai:

Che cos'è un costruttore in C #?

Il costruttore è un tipo speciale di metodo nel linguaggio di programmazione C # che viene chiamato o richiamato automaticamente quando viene creato un oggetto della classe data.

La sua funzione principale è inizializzare i membri di dati dell'oggetto appena creato. Una delle caratteristiche più distintive del costruttore è il suo nome. Ha lo stesso nome della classe.

I costruttori sono fondamentalmente di due tipi:

  1. Predefinito
  2. Parametrizzato

Costruttore predefinito C #

Come suggerisce il nome, il costruttore predefinito è il costruttore di base di una classe. Non ha alcun argomento e viene richiamato direttamente al momento della creazione dell'oggetto.

public class Program { public Program(){ Console.WriteLine('Constructor has been invoked'); } public static void Main(string() args) { Program p = new Program(); } }

L'output del seguente programma sarà:

Il costruttore è stato invocato

Spiegazione

Abbiamo definito un costruttore “Program” all'interno della classe “Program”. Ora, quando inizializziamo la classe all'interno del metodo principale, il costruttore viene invocato automaticamente.

Quindi, qualsiasi frammento di codice che abbiamo mantenuto all'interno del costruttore verrà richiamato. Qui, abbiamo stampato un messaggio 'Il costruttore è stato invocato' all'interno delle parentesi graffe del costruttore, quindi quando inizializziamo la classe, il costruttore per impostazione predefinita verrà inizializzato e il messaggio verrà stampato come output.

Costruttore parametrizzato

Come suggerisce il nome, i costruttori parametrizzati sono i costruttori con parametri. Questi costruttori vengono utilizzati per passare valori diversi agli oggetti.

public class Details { public Details(int a, int b){ int c = a+b; Console.WriteLine('The sum is: '+ c); } } public class Program { public static void Main(string() args) { Details d = new Details(2, 3); } }

L'output del seguente programma sarà:

5 esempi di linguaggi di programmazione di alto livello

La somma è: 5

Spiegazione

Nel nostro esempio precedente con il costruttore predefinito, abbiamo il nostro metodo principale nella stessa classe. In questo esempio, abbiamo il metodo principale in una classe diversa.

Abbiamo una classe denominata 'Dettagli' che contiene un costruttore parametrizzato che accetta due valori interi. All'interno del costruttore, stiamo stampando la somma degli interi. Abbiamo un'altra classe chiamata 'Program' che contiene il nostro metodo principale. All'interno del metodo principale, abbiamo inizializzato la classe 'Details'.

Come spiegato in precedenza, quando una classe viene inizializzata, i suoi costruttori vengono chiamati automaticamente. Quindi, in questo caso, il nostro metodo di costruzione 'Dettagli' è stato invocato e quando abbiamo passato il parametro durante l'inizializzazione, stampa l'output.

Distruttori in C #

I distruttori sono esattamente l'opposto dei costruttori. È un metodo speciale della classe che viene richiamato quando un oggetto della classe esce dall'ambito. Simile a un costruttore, anche il nome di un distruttore è esattamente uguale a quello del nome della classe ma con un prefisso '~' (tilde).

Il distruttore non accetta alcun parametro né restituisce alcun valore. Il distruttore distrugge gli oggetti della classe, quindi viene utilizzato principalmente per rilasciare memoria dopo che il programma è stato eseguito. Un'altra cosa importante da notare sul distruttore è che non può essere sovraccaricato né ereditato.

Esempio di distruttori:

public class Program { public Program(){ Console.WriteLine('Constructor has been invoked'); } ~Program(){ Console.WriteLine('Destructor has been invoked'); } public static void Main(string() args) { Program p = new Program(); } }

L'output del seguente programma sarà:

Il costruttore è stato invocato
Il distruttore è stato invocato

Spiegazione

Abbiamo usato lo stesso esempio che abbiamo usato per imparare il costruttore. Abbiamo appena aggiunto un distruttore nella classe del programma (~ Program). Quando inizializziamo l'oggetto della classe, viene richiamato il costruttore e viene creato l'oggetto della classe. Stampa la frase 'Il costruttore è stato richiamato' sulla console.

Quando l'esecuzione è stata completata e l'oggetto classe esce dall'ambito, il programma si sposta verso il distruttore. Viene quindi richiamato il distruttore, che a sua volta distrugge l'oggetto. Qui, abbiamo stampato un messaggio all'interno del distruttore, che viene stampato sulla console dopo che il distruttore è stato invocato.

Membri statici in una classe

I membri della classe possono essere dichiarati statici utilizzando la parola chiave statica. Quando un oggetto viene dichiarato statico, indipendentemente dal numero di oggetti creati, ci sarà solo una copia dell'oggetto statico.

Essere statici implica che ci sarà una singola istanza del membro che esisterà per una data classe. Significa che il valore della funzione statica o delle variabili all'interno della classe può essere invocato senza creare un oggetto per esse.

Le variabili statiche vengono utilizzate per dichiarare le costanti poiché i loro valori possono essere ottenuti direttamente invocando la classe invece di crearne un'istanza.

Esempio:

public class Details { public static void stat(){ Console.WriteLine('Static method invoked'); } } public class Program { public static void Main(string() args) { Details.stat(); } }

L'output del seguente programma sarà:

Metodo statico richiamato

Spiegazione

Nell'esempio sopra, abbiamo creato una classe 'Details' che contiene un metodo statico 'stat'. Abbiamo un'altra classe 'Program' che contiene il metodo principale. Nei nostri argomenti precedenti abbiamo visto come inizializzare una classe per accedere ai metodi. Ma come abbiamo discusso, è possibile accedere ai membri statici della classe con l'inizializzazione degli oggetti della classe.

Pertanto, nel metodo principale, abbiamo semplicemente invocato il metodo utilizzando direttamente la classe senza creare alcun oggetto. L'output del programma esegue il codice scritto all'interno del metodo statico. In questo caso, abbiamo stampato un messaggio sulla console.

Classe statica in C #

Una classe statica è simile a una normale classe in C #. La classe statica può avere solo membri statici e non può essere istanziata. Una classe statica viene utilizzata per assicurarsi che la classe non sia istanziata. Una classe statica viene dichiarata utilizzando la parola chiave static prima della classe parola chiave durante la dichiarazione.

Esempio:

public static class Details { public static void multiply(int a, int b){ int c = a*b; Console.WriteLine('Multiplication result is: '+c); } } public class Program { public static void Main(string() args) { Details.multiply(2,8); } }

L'output del seguente programma sarà:

Il risultato della moltiplicazione è: 16

Spiegazione

Nell'esempio sopra, abbiamo creato una classe statica 'Dettagli' e all'interno della classe statica abbiamo creato un altro metodo statico 'moltiplicare'. All'interno del metodo, abbiamo alcuni frammenti di codice che vogliamo eseguire. Abbiamo anche un'altra classe 'Program' con il metodo principale.

All'interno del metodo main abbiamo invocato il metodo multiply presente all'interno della classe statica. Se guardi il nostro metodo principale vedrai che non abbiamo inizializzato o creato un oggetto per la classe statica invece abbiamo invocato direttamente la classe dal metodo principale.

Pertanto, quando invochiamo direttamente il metodo multiply utilizzando il nome della classe e fornendo parametri, esegue il codice e stampa l'output.

Structs in C #

L'entità del tipo di valore in C # è chiamata struttura. Aiuta l'utente a memorizzare i dati correlati di diversi tipi di dati diversi in una singola variabile. Come affermato, una struttura è un'entità di tipo valore che contiene campi, metodi, costruttori, operatori, eventi, ecc. Una struttura viene dichiarata utilizzando la parola chiave 'struct'.

Caratteristiche di Structs:

  • Può includere costanti, metodi, proprietà, indice, operatori, costruttori, ecc.
  • Non può avere alcun costruttore predefinito.
  • Può implementare un'interfaccia ma non può ereditare con altre strutture o classi.
  • Le strutture devono essere inizializzate utilizzando una nuova parola chiave per l'utilizzo.

Differenza tra Struct e Class

Struct e Class possono sembrare simili tra loro in qualche modo, ma presentano diverse differenze.

Le differenze includono:

  • Una struttura è un tipo di valore mentre una classe è un tipo di riferimento.
  • La nuova parola chiave è necessaria per inizializzare le strutture.
  • Le strutture possono avere solo un costruttore parametrizzato e, d'altra parte, una classe può avere costruttori sia predefiniti che parametrizzati.

Struct: definizione

Una struttura può essere definita utilizzando la parola chiave struct. Una struttura può definire un nuovo tipo di dati con diversi membri diversi per il programma.

Una struttura può essere inizializzata in un modo simile a quello di un'inizializzazione di un oggetto, ovvero utilizzando la nuova parola chiave. Poiché una struttura è un'entità di tipo valore, è più veloce da utilizzare rispetto a un oggetto classe. Ovunque sia necessario memorizzare dati, è necessario utilizzare una struttura. D'altra parte, se è necessario trasferire dati, è consigliabile utilizzare class piuttosto che uno struct.

Esempio:

public struct Cuboid { public int length; public int width; public int height; } public class Program { public static void Main(string() args) { Cuboid cb = new Cuboid(); cb.length = 10; cb.width = 20; cb.height = 30; Console.WriteLine('The volume of cuboid is: {0}', (cb.length*cb.width*cb.height)); } }

L'output del seguente programma sarà:

Il volume del parallelepipedo è: 6000

Spiegazione

Nell'esempio precedente, abbiamo definito una struttura cuboide all'interno della quale abbiamo memorizzato i tipi di dati per lunghezza, larghezza e altezza del cuboide. Abbiamo un altro programma di classe in cui abbiamo il nostro metodo principale.

Nel metodo main inizializziamo la struttura 'Cuboid' utilizzando la nuova parola chiave. Quindi abbiamo utilizzato l'oggetto per chiamare e assegnare valori ai tipi di dati memorizzati nella struttura. Quindi abbiamo eseguito un'operazione sulle variabili dalla struttura e stampato il risultato sulla console.

file di output di input c ++

Quindi, se vuoi usare qualsiasi proprietà, evento o metodo, la struttura deve essere inizializzata usando la nuova parola chiave altrimenti ti darà un errore di compilazione.

Enumerazioni in C #

Enum è un insieme di costanti intere e simile a una struttura è anche un'entità di tipo valore. Viene utilizzato principalmente per dichiarare un elenco di interi utilizzando la parola chiave 'enum' all'interno di uno spazio dei nomi, una classe o anche una struttura. In enum, forniamo un nome a ciascuna delle costanti intere, in modo da poterle fare riferimento utilizzando i rispettivi nomi.

Enum può avere un numero fisso di costanti. Aiuta a migliorare la sicurezza e può anche essere attraversato.

Caratteristiche di Enum

  • Enum migliora la leggibilità e la manutenibilità del codice fornendo nomi significativi alle costanti.
  • Enum non può essere utilizzato con le costanti di tipo stringa.
  • Enum può includere costanti come int, long, short, byte, ecc.
  • Per impostazione predefinita, il valore delle costanti enum inizia con zero

Dichiarare un enum

La sintassi per la dichiarazione di enum è fornita di seguito.

enum { list of integer constants };

Tutte le costanti enum hanno valori predefiniti. Il valore inizia da 0 e aumenta di uno alla volta.

Esempio:

public enum Cuboid{ length, width, height } public class Program { public static void Main(string() args) { int l = (int)Cuboid.length; int w = (int)Cuboid.width; int h = (int)Cuboid.height; Console.WriteLine('The length is :{0}”, l); Console.WriteLine('The width is :{0}”, w); Console.WriteLine('The height is :{0}”, h); } }

L'output del seguente programma sarà:

La lunghezza è: 0
La larghezza è: 1
L'altezza è: 2

Spiegazione

Abbiamo lavorato con un esempio simile che abbiamo imparato durante la struttura. In questo esempio, abbiamo creato un enum chiamato Cuboid. Questo enum contiene tre membri, ovvero lunghezza, larghezza e altezza.

Abbiamo un'altra classe Program all'interno della quale abbiamo il nostro metodo principale. È stato utilizzato un cast esplicito per convertire le variabili di tipo enum in un tipo intero, quindi abbiamo memorizzato i loro valori in diverse variabili all'interno del metodo principale e li abbiamo stampati sulla console.

Per impostazione predefinita, il valore della prima enumerazione sarà zero, la seconda avrà 1 e così via. Quindi, quando abbiamo stampato i valori, abbiamo ricevuto l'output di cui sopra.

Modifica del valore di Enum

Enum consente inoltre agli utenti di modificare l'indice iniziale predefinito dei membri. Dopo aver modificato l'indice iniziale della variabile, i membri successivi avranno i loro valori aggiornati nella sequenza incrementale.

Assegniamo un valore al primo membro dell'enumerazione che abbiamo definito nel nostro esempio precedente e vediamo cosa succede:

public enum Cuboid { length = 10, width, height } public class Program { public static void Main(string() args) { int l = (int)Cuboid.length; int w = (int)Cuboid.width; int h = (int)Cuboid.height; Console.WriteLine('The length is :{0}”, l); Console.WriteLine('The width is :{0}”, w); Console.WriteLine('The height is :{0}”, h); } }

L'output del seguente programma sarà:

La lunghezza è: 10
La larghezza è: 11
L'altezza è: 12

Spiegazione

Quando abbiamo assegnato un valore al primo membro dell'enumerazione, tutti i membri successivi dell'enumerazione verranno assegnati con l'incremento di quel valore. Come abbiamo definito, il primo valore è 10, il valore successivo diventa 11 e il successivo diventa 12.

L'utente può assegnare qualsiasi valore secondo la sua scelta e tutti i membri dell'enum verranno assegnati automaticamente con l'incremento dei valori definiti dall'utente.

Proprietà in C #

Le proprietà in C # sono fondamentalmente il membro denominato di interfaccia, classi e struttura. Le proprietà sono un'estensione delle variabili membro / metodo di struct o class. Sono usati per leggere, scrivere o modificare il valore dei campi privati.

Si accede alle proprietà proprio come ai campi. Hanno funzioni di accesso che possono essere utilizzate per ottenere, impostare e calcolare i valori. Possiamo anche inserire logica durante l'impostazione dei valori nelle proprietà. Può anche essere utilizzato con la classe privata che limita l'accesso dall'esterno, ma allo stesso tempo consente all'utente di utilizzare le proprietà per ottenere o impostare i valori.

Cosa sono gli accessori?

Gli accessori di proprietà costituiscono le istruzioni che possono essere utilizzate per leggere, scrivere o calcolare una determinata proprietà. La dichiarazione di proprietà può contenere get, set o entrambi.

Esempio:

public class Cube { private int side; //Declare a Side property of type integer public int Side{ get{ return side; } set{ side = value; } } } public class Program { public static void Main(string() args) { Cube cb = new Cube(); cb.Side = 5; Console.WriteLine('The volume of cube is :{0}', (cb.Side * cb.Side* cb.Side)); } }

Quando lo snippet di codice precedente viene compilato ed eseguito correttamente, viene osservato il seguente output.

Il volume del cubo è: 125

Spiegazione

Nell'esempio sopra, abbiamo una classe “Cube” all'interno della quale abbiamo dichiarato una proprietà “Side” di tipo integer. Dopodiché, abbiamo ottenuto e impostato la proprietà in cui abbiamo restituito e fornito il valore al lato della variabile.

sql query intervista domande e risposte pdf

Abbiamo un'altra classe “Program” con il metodo main all'interno della quale abbiamo inizializzato la classe Cube e fornito il valore per la proprietà Side, quindi abbiamo stampato il risultato calcolato sulla console.

Conclusione

In questo tutorial, abbiamo imparato a conoscere le funzioni membro della classe. Una funzione membro può operare su qualsiasi oggetto della classe in cui è presente. Abbiamo anche imparato a conoscere costruttori e distruttori.

I costruttori vengono inizializzati automaticamente al momento della creazione dell'oggetto di classe, mentre i distruttori distruggono la classe e vengono utilizzati principalmente per rimuovere l'allocazione di memoria dopo il completamento dell'esecuzione. I costruttori possono essere di due tipi, ovvero predefiniti e parametrizzati.

Il distruttore non accetta alcun parametro né restituisce alcun valore. Sia Constructor che Destructors hanno nomi che sono esattamente gli stessi del nome della classe. Abbiamo anche imparato a conoscere le variabili statiche e la classe statica e come è possibile accedervi senza utilizzare istanze di classe. Siamo venuti a sapere che una classe statica può avere solo membri statici.

Abbiamo anche discusso di Struct o strutture. Le strutture sono entità di tipo valore e devono essere inizializzate per l'accesso.

Sono stati discussi anche l'enum e le proprietà di C #. Enum è un insieme di costanti intere denominate. Simile alla struttura, è anche un'entità di tipo valore. L'enumerazione avrà i suoi membri e ogni membro avrà il proprio valore predefinito.

Alla fine, abbiamo discusso le proprietà, che sono un'estensione delle variabili membro / metodo di struct o class. Sono utilizzati per ottenere, impostare o modificare il valore dei campi privati.

=> Guarda la nostra serie completa di formazione C # qui

Lettura consigliata

^