Introduzione al costruttore in C #
Il costruttore svolge un ruolo molto importante nella programmazione orientata agli oggetti. Cerchiamo di capire il ruolo di costruttore in C # con l'aiuto dei seguenti punti:
- Un costruttore è un metodo speciale presente all'interno di una classe che è responsabile dell'inizializzazione delle variabili della classe.
- Il suo nome è uguale al nome della classe.
- Viene eseguito automaticamente quando creiamo un'istanza della classe.
- Un costruttore non restituisce alcun valore.
- Se non definiamo un costruttore, un costruttore implicito viene sempre fornito dalla classe che si chiama costruttore predefinito.
Sintassi:
public class Student()
(
//constructor
public Student()
(
//code
)
)
Qui, Public Student () è un metodo che non ha alcun tipo di ritorno, nemmeno nullo e il suo nome è lo stesso del nome della classe, cioè "Studente". Pertanto, questo metodo è il costruttore di questa classe.
Quando creeremo un oggetto di questa classe usando:
Student obj = new Student();
Quindi verrà eseguito il codice all'interno del costruttore.
Funzionamento del costruttore in C #
1. Il costruttore inizializza i membri dei dati per il nuovo oggetto. Viene richiamato dall'operatore "nuovo" immediatamente dopo che la memoria viene allocata nel nuovo oggetto.
2. I costruttori espliciti (costruttori definiti dall'utente) possono essere senza parametri o parametrizzati. Se è parametrizzato, i valori, passati al costruttore possono essere assegnati ai membri di dati della classe.
3. Il costruttore implicito inizializza le variabili della classe con lo stesso valore anche se creiamo più istanze di quella classe.
Esempio:
Codice:
using System;
public class ConstructorDemo
(
public int num = 10;
public static void Main()
(
ConstructorDemo obj1 = new ConstructorDemo();
ConstructorDemo obj2 = new ConstructorDemo();
ConstructorDemo obj3 = new ConstructorDemo();
Console.WriteLine("obj1.num = "+obj1.num+"\nobj2.num = "+obj2.num
+"\nobj3.num = "+obj3.num);
)
)
Produzione:
Rappresentazione pittorica del suddetto programma:
4. Il costruttore esplicito con parametri ci consente di inizializzare le variabili della classe con un valore diverso ogni volta che creiamo un'istanza di quella classe.
Esempio:
Codice:
using System;
public class ConstructorDemo
(
public int num;
//explicit constructor
public ConstructorDemo(int num)
(
this.num = num;
)
public static void Main()
(
ConstructorDemo obj1 = new ConstructorDemo(10);
ConstructorDemo obj2 = new ConstructorDemo(20);
ConstructorDemo obj3 = new ConstructorDemo(30);
Console.WriteLine("obj1.num = "+obj1.num+"\nobj2.num = "+obj2.num
+"\nobj3.num = "+obj3.num);
)
)
Produzione:
Rappresentazione pittorica del suddetto programma:
I 5 migliori tipi di costruttore in C #
C # fornisce cinque tipi di costruttori. Sono i seguenti:
1. Costruttore predefinito
- Un costruttore senza alcun parametro si chiama Costruttore predefinito. Se non lo definiamo in modo esplicito, verrà fornito implicitamente dal compilatore.
- In tal caso, possiamo chiamarlo costruttore implicito. Il costruttore predefinito o implicito inizializza tutti i membri dei dati della classe con i loro valori predefiniti come tutti i campi numerici su zero e tutti i campi stringa e oggetto su null.
Esempio:
Codice:
using System;
public class DefaultConstructor
(
public int num;
public string str;
)
public class Demo
(
public static void Main()
(
DefaultConstructor obj = new DefaultConstructor();
Console.WriteLine("obj.num = "+obj.num+"\nobj.str = "+obj.str);
)
)
Produzione:
2. Costruttore parametrizzato
Il costruttore con almeno un parametro è chiamato Costruttore parametrizzato. I parametri al costruttore possono essere passati durante la creazione dell'istanza della classe. Ci consente di inizializzare ogni istanza di una classe con valori diversi.
Esempio:
Codice:
using System;
public class ParameterizedConstructor
(
public int num;
public string str;
//parameterized constructor
public ParameterizedConstructor(int num, string str)
(
this.num = num;
this.str = str;
)
)
public class Demo
(
public static void Main()
(
//passing values to constructor while creating instance
ParameterizedConstructor obj = new ParameterizedConstructor(50, "constructor");
Console.WriteLine("obj.num = "+obj.num+"\nobj.str = "+obj.str);
)
)
Produzione:
3. Copia costruttore
È un costruttore parametrizzato che accetta l'oggetto della stessa classe come parametro. Copia il valore dell'oggetto esistente (che viene passato come parametro) all'oggetto appena creato istanziato dal costruttore. Possiamo dire che copia i dati di un oggetto su un altro oggetto.
Esempio:
Codice:
using System;
public class CopyConstructor
(
public int num;
public CopyConstructor(int num)
(
this.num = num;
)
//copy constructor
public CopyConstructor(CopyConstructor obj)
(
num = obj.num;
)
)
public class Demo
(
public static void Main()
(
CopyConstructor obj1 = new CopyConstructor(50);
//passing same class's object as parameter
CopyConstructor obj2 = new CopyConstructor(obj1);
Console.WriteLine("Original object:");
Console.WriteLine("obj1.num = "+obj1.num);
Console.WriteLine("\nCopied object:");
Console.WriteLine("obj2.num = "+obj2.num);
)
)
Produzione:
4. Costruttore statico
- Può essere definito prefissando il nome del costruttore con una parola chiave. È implicitamente definito dal compilatore (se non definito in modo esplicito) se la classe contiene variabili statiche.
- È il primo blocco da eseguire nella classe e verrà chiamato automaticamente. Verrà eseguito solo una volta indipendentemente dal numero di istanze di classe. È senza parametri e non accetta alcun modificatore di accesso.
Esempio:
Codice:
using System;
public class StaticConstructor
(
//static constructor
static StaticConstructor()
(
Console.WriteLine("Static constructor executed");
)
public static void Display()
(
Console.WriteLine("\nDisplay method executed");
)
)
public class Demo
(
public static void Main()
(
StaticConstructor.Display();
)
)
Produzione:
5. Costruttore privato
Il costruttore creato con l'identificatore privato è chiamato costruttore privato. Non è possibile creare un'istanza della classe se contiene solo un costruttore privato e non consente ad altre classi di derivare da questa classe. Utilizzato nella classe che contiene solo membri statici.
Esempio:
Codice:
using System;
public class PrivateConstructor
(
public static int num = 100;
//private constructor
private PrivateConstructor()
(
)
)
public class Demo
(
public static void Main()
(
//PrivateConstructor obj = new PrivateConstructor(); //Error
Console.WriteLine("num = "+PrivateConstructor.num);
)
)
Produzione:
Conclusione
Se definiamo qualsiasi tipo di costruttore nella classe, allora non ci sarà alcun costruttore implicito nella classe fornita dal compilatore. Come i metodi, anche i costruttori con parametri possono essere sovraccaricati con diversi numeri di parametri. I costruttori definiti implicitamente dal compilatore sono sempre pubblici.
Articolo raccomandato
Questa è una guida per Costruttore in C #. Qui discutiamo i tipi di costruttore in C # e il suo funzionamento insieme all'implementazione e all'output del codice. Puoi anche consultare i nostri altri articoli suggeriti per saperne di più -
- Costruttore in JavaScript e tipi
- Cos'è il generatore di numeri casuali in C #?
- Costruttore in C ++ e tipi
- Copia costruttore in C # (esempi)
- Costruttore statico in Java | Funzionando | applicazioni