Introducere în constructor în C #
Constructorul joacă un rol foarte important în programarea orientată pe obiecte. Să înțelegem rolul constructorului în C # cu ajutorul următoarelor puncte:
- Un constructor este o metodă specială prezentă în cadrul unei clase care este responsabilă de inițializarea variabilelor clasei.
- Numele său este același cu numele clasei.
- Se execută automat atunci când creăm o instanță a clasei.
- Un constructor nu returnează nicio valoare.
- Dacă nu definim un constructor, un constructor implicit este întotdeauna furnizat de clasa care se numește constructor implicit.
Sintaxă:
public class Student()
(
//constructor
public Student()
(
//code
)
)
Aici, public Student () este o metodă care nu are niciun tip de returnare, nici măcar nul și numele acesteia este același cu numele clasei, adică „Student”. Astfel, această metodă este constructorul acestei clase.
Când vom crea un obiect al acestei clase folosind:
Student obj = new Student();
Apoi, codul din interiorul constructorului va fi executat.
Lucrări de constructor în C #
1. Constructorul inițializează membrii de date pentru noul obiect. Acesta este invocat de către noul operator imediat după ce memoria este alocată noului obiect.
2. Constructorii explicit (constructori definiți de utilizator) pot fi fără parametri sau parametrizați. Dacă acesta este parametrizat, atunci valorile transmise constructorului pot fi alocate membrilor de clasă.
3. Constructorul implicit inițializează variabile ale clasei cu aceeași valoare, chiar dacă creăm mai multe instanțe ale clasei respective.
Exemplu:
Cod:
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);
)
)
ieşire:
Reprezentarea picturală a programului de mai sus:
4. Constructorul explicit cu parametri ne permite să inițializăm variabile ale clasei cu o valoare diferită de fiecare dată când creăm o instanță a clasei respective.
Exemplu:
Cod:
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);
)
)
ieşire:
Reprezentarea picturală a programului de mai sus:
Top 5 tipuri de constructori din C #
C # oferă cinci tipuri de constructori. Acestea sunt următoarele:
1. Constructor implicit
- Un constructor fără niciun parametru se numește Default Constructor. Dacă nu o definim explicit, atunci acesta va fi implicit furnizat de compilator.
- Într-un astfel de caz, îl putem numi implicit constructor. Constructorul implicit sau implicit inițializează toți membrii de date ai clasei cu valorile lor implicite, cum ar fi toate câmpurile numerice la zero și toate câmpurile șir și obiect la nul.
Exemplu:
Cod:
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);
)
)
ieşire:
2. Constructor parametrizat
Constructorul cu cel puțin un parametru se numește Constructor parametrizat. Parametrii pentru constructor pot fi trecuți la crearea instanței clasei. Ne permite să inițializăm fiecare instanță a unei clase cu valori diferite.
Exemplu:
Cod:
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);
)
)
ieşire:
3. Constructor de copiere
Este un constructor parametrizat care ia același obiect de clasă ca parametru. Copiază valoarea obiectului existent (care este transmis ca parametru) la obiectul nou creat inițiat de constructor. Putem spune că copiază datele unui obiect pe alt obiect.
Exemplu:
Cod:
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);
)
)
ieşire:
4. Constructor static
- Poate fi definit prin prefixarea numelui constructorului cu un cuvânt cheie. Este definit implicit de compilator (dacă nu este definit explicit) dacă clasa conține vreo variabilă statică.
- Este primul bloc executat în clasă și va fi apelat automat. Acesta va fi executat o singură dată indiferent de numărul de instanțe. Nu are parametri și nu acceptă niciun modificator de acces.
Exemplu:
Cod:
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();
)
)
ieşire:
5. Constructor privat
Constructorul creat cu specificatorul privat se numește constructor privat. Nu putem crea o instanță a clasei dacă conține doar un constructor privat și nu permite altor clase să derive din această clasă. Folosit în clasă care conține doar membri statici.
Exemplu:
Cod:
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);
)
)
ieşire:
Concluzie
Dacă definim orice tip de constructor din clasă, atunci nu va exista niciun constructor implicit în clasa furnizată de compilator. La fel ca metodele, constructorii parametrizați pot fi, de asemenea, supraîncărcați cu diferite numere de parametri. Constructorii definiți implicit de compilator sunt întotdeauna publici.
Articol recomandat
Acesta este un ghid pentru constructor în C #. Aici discutăm tipurile de constructor în C # și funcționarea acestuia împreună cu implementarea și ieșirea codului. Puteți parcurge și alte articole sugerate pentru a afla mai multe -
- Constructor în JavaScript și tipuri
- Ce este generatorul de număr aleatoriu în C #?
- Constructor în C ++ și Tipuri
- Copiați constructorul în C # (exemple)
- Constructor static în Java | De lucru | Aplicații