Bevezetés a C # konstruktorhoz
A konstruktor nagyon fontos szerepet játszik az objektum-orientált programozásban. Megértjük a konstruktor szerepét a C # -ben a következő pontok segítségével:
- A kivitelező egy speciális módszer, amely jelen van az osztályon belül és feladata az osztály változóinak inicializálása.
- A neve megegyezik az osztály nevével.
- Az osztálypéldány létrehozásakor automatikusan végrehajtásra kerül.
- A kivitelező nem ad vissza értéket.
- Ha nem definiálunk konstruktort, akkor az implicit konstruktort mindig az alapértelmezett konstruktornak nevezett osztály biztosítja.
Szintaxis:
public class Student()
(
//constructor
public Student()
(
//code
)
)
Itt a public Student () olyan módszer, amelynek nincs visszatérési típusa, sőt sem érvénytelen, és neve megegyezik az osztály nevével, azaz a „Student”. Tehát ez a módszer ennek az osztálynak a konstruktora.
Mikor hozunk létre egy osztály egy tárgyát a következő felhasználásával:
Student obj = new Student();
Ezután a kivitelező belsejében levő kód kerül végrehajtásra.
Konstruktor munka C # -ben
1. A kivitelező inicializálja az új objektum adatait. Az 'új' operátor azonnal meghívja, miután a memória hozzárendelésre került az új objektumhoz.
2. Az explicit konstruktorok (a felhasználó által meghatározott konstruktorok) paraméterek nélkül vagy paraméterezhetők lehetnek. Ha paraméterezik, akkor a konstruktornak átadott értékeket hozzá lehet rendelni az osztály adatainak.
3. Az implicit konstruktor ugyanazzal az értékkel inicializálja az osztály változóit, még akkor is, ha az osztály több példányát készítjük.
Példa:
Kód:
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);
)
)
Kimenet:
A fenti program képi ábrázolása:
4. Az explicit konstruktor paraméterekkel lehetővé teszi, hogy az osztály változóit más értékkel inicializáljuk minden alkalommal, amikor az osztály példányát létrehozjuk.
Példa:
Kód:
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);
)
)
Kimenet:
A fenti program képi ábrázolása:
A C # kivitelező top 5 típusa
A C # ötféle konstruktort kínál. Ezek a következők:
1. Alapértelmezett kivitelező
- A paraméterek nélküli konstruktort alapértelmezett konstruktornak nevezzük. Ha nem határozza meg kifejezetten, akkor azt a fordító biztosítja.
- Ilyen esetben implicit konstruktornak nevezhetjük. Az alapértelmezett vagy implicit konstruktor az osztály összes adattagját alapértelmezett értékükkel inicializálja, például az összes numerikus mezőt nullára, és az összes string és objektummezőt nullára.
Példa:
Kód:
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);
)
)
Kimenet:
2. Paraméterezett konstruktor
Legalább egy paraméterrel rendelkező konstruktort Parameterized Constructornak hívnak. A paraméterek a konstruktornak átadhatók az osztály példányának létrehozásakor. Ez lehetővé teszi számunkra, hogy az osztály minden egyes példányát különböző értékekkel inicializáljuk.
Példa:
Kód:
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);
)
)
Kimenet:
3. Másoló kivitelező
Ez egy paraméteres konstruktor, amely ugyanazon osztály objektumát veszi paraméterként. Másolja a meglévő objektum értékét (amelyet paraméterként adunk át) az újonnan létrehozott objektumhoz, amelyet a konstruktor megtestesít. Azt mondhatjuk, hogy az egyik objektum adatait másolja egy másik objektumra.
Példa:
Kód:
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);
)
)
Kimenet:
4. Statikus kivitelező
- Ez úgy határozható meg, hogy a kivitelező nevét egy kulcsszóval előtagoljuk. A fordító implicit módon határozza meg (ha nem határozza meg kifejezetten), ha az osztály tartalmaz statikus változókat.
- Ez az első blokk, amelyet az osztályban hajtanak végre, és automatikusan meghívásra kerül. Csak egyszer hajtják végre, függetlenül az osztálypéldányok számától. Ez paraméter nélküli, és semmilyen hozzáférés-módosítót nem fogad el.
Példa:
Kód:
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();
)
)
Kimenet:
5. Magánszereplő
A magán specifikátorral létrehozott konstruktort privát konstruktornak nevezzük. Nem hozhatunk létre egy osztálypéldányt, ha csak privát konstruktort tartalmaz, és nem engedi, hogy más osztályok származtassák ezt az osztályt. Olyan osztályban használják, amely csak statikus tagokat tartalmaz.
Példa:
Kód:
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);
)
)
Kimenet:
Következtetés
Ha bármilyen típusú konstruktort definiálunk az osztályban, akkor a fordító által megadott osztályban nincs implicit konstruktor. A módszerekhez hasonlóan a paraméterezett konstruktorok is túlterhelhetők különböző számú paraméterrel. A fordító által implicit módon meghatározott konstruktorok mindig nyilvánosak.
Ajánlott cikk
Ez egy útmutató a Constructor számára a C # -ben. Itt a C # konstruktor típusait és annak működését, valamint a kód implementációját és kimenetet tárgyaljuk. A további javasolt cikkeken keresztül további információkat is megtudhat -
- Konstruktor JavaScript-ben és típusokban
- Mi a véletlenszám-generátor a C # -ben?
- Konstruktor C ++ és típusoknál
- Másoló konstruktor a C # -ben (példák)
- Statikus kivitelező Java-ban Munka | Alkalmazások