Konstruktor Java

java constructor class

Vyzkoušejte Náš Nástroj Pro Odstranění Problémů

Vyberte Operační Systém Vyberte Program Projekce (Volitelně)

Popište Svůj Problém

Tento kurz bude diskutovat o Java Constructor, jeho typech a konceptech, jako je přetížení konstruktoru a řetězení konstruktorů, s příklady kódu:

Z našich dřívějších tutoriálů víme, že instance třídy se nazývá objekt. Objekt třídy je vytvořen pomocí klíčového slova „new“. Speciální metoda zvaná „konstruktor“ se nazývá, když vytváříme objekt s novým klíčovým slovem nebo když je objekt instancován.

Konstruktor je definován jako blok kódu pro inicializaci objektu třídy. Je to identické s metodou, ale nejde o metodu. Lze jej však v Javě nazvat „speciální metodou“.

=> Chcete-li vidět A-Z výukových kurzů Java zde, podívejte se sem.

Konstruktory v Javě

Co se naučíte:

Konstruktor Java
Závěr
- Doporučené čtení

Konstruktor Java se používá k inicializaci právě vytvořeného objektu. Před použitím v programu musí mít objekt nějaká data. Proto používáme konstruktor, abychom mohli objektu přiřadit některá počáteční data.

Jako jednoduchý příklad zvažte třídu ABC, pro kterou musíme vytvořit objekt. Vytvořme objekt „myObj“ pro třídu ABC pomocí nového klíčového slova.

ABC myObj = new ABC ();

Výše uvedený příkaz vytvoří objekt myObj. Při vytváření tohoto objektu se volá konstruktor pro třídu ABC bez argumentu (ABC () ukazuje, že pro konstruktor neexistují žádné argumenty). Protože pro výše uvedený konstruktor nejsou k dispozici žádné argumenty, pole člena myObj budou inicializována na své výchozí počáteční hodnoty.

Například,

Číselné datové typy jako int jsou nastaveny na 0.
Hodnota proměnné datového typu Char je nastavena na null („ 0“) znak.
Odkazy jsou nastaveny na null.

V tomto kurzu se budeme podrobně zabývat konstruktory spolu s různými konstruktory používanými v Javě.

Jak vytvořit konstruktor v Javě

Chcete-li vytvořit konstruktor v Javě, musíme dodržovat určitá pravidla, jak je uvedeno níže.

Konstruktor třídy má stejný název jako třída.
Nemůže existovat konstruktor, který je konečný, abstraktní, synchronizovaný nebo statický. Je to proto, že finále funguje jako konstanta, abstrakt nelze konkretizovat. Zatímco synchronizované se používá v případě více vláken a statické klíčové slovo se používá na úrovni třídy.
S konstruktory můžeme použít modifikátory přístupu.
Konstruktor nemůže mít návratový typ.

Například,Pojďme definovat třídu Student takto:

class Student{ String name; int roll_no; }

Můžeme vytvořit objekty výše uvedené třídy pomocí nového klíčového slova. Během vytváření objektu můžeme inicializovat dvoučlenné proměnné této třídy poskytnutím konstruktoru. Všimněte si, že i když neposkytujeme konstruktor a pouze provedeme níže uvedené prohlášení,

Student student = new Student ();

Java přesto provede výchozí konstruktor, který inicializuje dvoučlenné proměnné na výchozí nastavení systému. Nyní, pokud chceme, aby počáteční hodnota Student.name byla „Keith“ a roll_no 27, pak k tomu můžeme vytvořit následující metodu konstruktoru.

Student () { name = 'Keith'; roll_no = 27; }

Když vytvoříme objekt třídy studenta s níže uvedeným příkazem

Student student = new Student ();

Počáteční hodnoty členů proměnných name a roll_no pak budou Keith a 27.

Nyní, když je vytvořen konstruktor, kdy bude volán?

Konstruktor je volán pokaždé, když je objekt vytvořen pomocí nového klíčového slova jako ve výše uvedeném případě. Jak již bylo zmíněno, pokud není poskytnut žádný konstruktor, Java poskytuje výchozí konstruktor, který se volá, když je objekt vytvořen pomocí nového klíčového slova.

Příklad konstruktoru

Následující program ukazuje příklad konstruktoru, ve kterém máme jednoduchý konstruktor bez jakýchkoli argumentů. Tento konstruktor jednoduše přiřadí počáteční hodnoty svým členským proměnným.

//class definition class classDemo{ int num1; int num2; //constructor classDemo(){ num1 = 100; num2 = 250; System.out.println('Inside ClassDemo::Constructor'); } public void display(){ System.out.println('num1 = '+ num1); System.out.println('num2 = '+ num2); } } class Main{ public static void main(String args()){ classDemo cd1 = new classDemo(); //create object of ClassDemo cd1.display(); } }

Výstup:

Ukázkový výstup třídy

Výchozí konstruktor v Javě

Výchozí konstruktor se také nazývá Prázdný konstruktor . Tento konstruktor je vložen kompilátorem Java do kódu třídy, kde programátor neimplementuje žádný konstruktor. Výchozí konstruktor je vložen během kompilace, a proto se zobrazí pouze v souboru „.class“, nikoli ve zdrojovém kódu.

Zvažte následující třídu Java.

zdrojový soubor (.java) soubor třídy (.class)

Třída Java

Na obrázku výše ukazuje první obrázek zdrojový kód, ve kterém jsme nezadali žádný konstruktor. Když tedy kompilujeme tento kód a vygeneruje se soubor .class, můžeme vidět, že kompilátor Java vložil výchozí konstruktor, jak je znázorněno na sousedním obrázku (v modré barvě).

Poznámka:

Někdy se k popisu konstruktoru no-arg v Javě používá výchozí konstruktor. Ale tyto dva pojmy se ve skutečnosti liší. Konstruktor No-arg je typ konstruktoru v Javě, který je určen programátorem. Výchozí konstruktor je konstruktor, který je vložen kompilátorem Java.

nastavit zatmění pro c ++

Proto i když většina těchto programátorů používá tyto dva pojmy zaměnitelně, je vhodné tyto dva pojmy nezaměňovat.

Když Java vloží výchozí konstruktor, má-li program nějaké proměnné, jsou jim přiřazeny výchozí hodnoty.

Níže uvedená tabulka zobrazuje výchozí hodnoty každého datového typu.

Typ	Výchozí hodnota
char	u0000
Objekt	Referenční null
booleovský	Nepravdivé
byte	0
krátký	0
int	0
dlouho	0L
plovák	0,0f
dvojnásobek	0,0 d

Následující program uvádí příklad výchozího konstruktoru v Javě.

class Main { int num; boolean flag; public static void main(String() args) { // A default constructor is called Main obj = new Main(); System.out.println('num:default value = ' + obj.num); System.out.println('flag:default value = ' + obj.flag); } }

Výstup:

výchozí konstruktor - výstup

Typy konstruktorů v Javě

V Javě existují dva typy konstruktorů, jak je znázorněno níže.

Typy konstruktorů v Javě

# 1) Konstruktor No-arg

Konstruktor bez argumentů se nazývá konstruktor bez argumentů nebo bez argumentů. Pokud nemáme konstruktor bez jakýchkoli argumentů, pak kompilátor Java nevytvoří výchozí konstruktor pro třídu.

Obecně platí, že pokud v naší třídě definujeme konstruktor, kompilátor Java nevloží výchozí konstruktor.

Níže je uveden příklad konstruktoru No-arg

import java.io.*; class DemoClass { int num; String name; // no-args Constructor called when object is created DemoClass() { System.out.println('DemoClass::Constructor called'); System.out.println('Initial member variable values:'); System.out.println('num = ' + num + ' name = ' + name); } } class Main{ public static void main (String() args) { // this will invoke no-args Constructor DemoClass dc1 = new DemoClass(); } }

Výstup:

Konstruktor bez argonu

V tomto programu jsme poskytli konstruktor no-args. Zde vytiskneme některé zprávy včetně členských proměnných. Ve výstupu vidíme, že se zobrazují zprávy z konstruktoru, což naznačuje, že je spuštěn konstruktor bez args.

# 2) Parametrizovaný konstruktor

Parametrizovaný konstruktor má jeden nebo více parametrů. Můžeme použít parametrizovaný konstruktor v případě, že potřebujeme předat některé počáteční hodnoty členské proměnné třídy.

import java.io.*; class DemoClass { // data members of the class. String name; int id; // parameterized constructor called when object is created DemoClass(String name, int id) { this.name = name; this.id = id; } } class Main { public static void main (String() args) { // this will invoke the parameterized constructor. DemoClass dc1 = new DemoClass('Java', 1); System.out.println('Tutorial Name :' + dc1.name + ', Id :' + dc1.id); } }

Výstup:

Parametrizovaný konstruktor v Javě

Zde jsme poskytli parametrizovaný konstruktor, který přijímá dva argumenty, tj. Jméno a id.

Uvnitř těla konstruktoru jsou argumenty přiřazeny jako hodnoty názvu členské proměnné a ID.

Potom v hlavní metodě, když vytvoříme nový objekt pomocí nového klíčového slova, předáme dvě hodnoty názvu třídy následující za novým klíčovým slovem. To naznačuje, že voláme parametrizovaný konstruktor. Když zobrazíme členské proměnné, vidíme, že mají hodnoty, které jsme předali při vytváření objektu.

Přetížené konstruktory v Javě

Nyní vyvstává otázka, zda třída může mít více než jeden konstruktor, nebo je možné, že třída může mít pouze jeden konstruktor?

Ve třídě můžeme mít několik konstruktorů. Třída může mít tolik konstruktorů, pokud jsou správně přetížené.

Co tedy přesně znamená Přetížení konstruktérů?

Přetížení konstruktoru je mechanismus, který umožňuje třídě mít tolik konstruktorů, takže všechny tyto konstruktory mají různé seznamy parametrů, ať už v závislosti na typech parametrů nebo pořadí parametrů.

Níže uvedený program demonstruje přetížení konstruktoru.

//class with multiple constructors class DemoClass{ int val1; int val2; //no args Constructor DemoClass(){ val1 = 10; val2 = 20; System.out.println('DemoClass:: No argument Constructor'); } //Overloaded Constructor DemoClass(int num1){ val1 = num1; val2 = num1; System.out.println('DemoClass:: Overloaded Constructor with one argument'); } //Overloaded DemoClass(int num1,int num2){ val1 = num1; val2 = num2; System.out.println('DemoClass:: Overloaded Constructor with two arguments'); } public void display(){ System.out.println('val1 === '+val1 + ' ; val2 === '+val2 ); } } class Main{ public static void main(String args()){ DemoClass d1 = new DemoClass(); //object with no-args Constructor d1.display(); DemoClass d2 = new DemoClass(10); //object with 1 arg Constructor d2.display(); DemoClass d3 = new DemoClass(20,40); //object with 2 arg Constructor d3.display(); } }

Výstup:

Přetíženo - výstup

Ve výše uvedeném programu máme třídu obsahující tři konstruktory. První konstruktor je konstruktor no-arg a pak máme jeden každý s jedním argumentem a dvěma argumenty. Protože konstruktor má jedinečný seznam parametrů, můžeme říci, že jsou konstruktory přetížené.

„This ()“ konstruktor v Javě

Ve třídě obsahující více konstruktorů, co když chceme volat jeden konstruktor z jiného konstruktoru v této třídě?

Pro tento účel používáme uvnitř konstruktoru klíčové slovo „this“, ze kterého chceme zavolat jiného konstruktora.

Takže když má třída více konstruktorů, konstruktor no-arg a parametrizovaný konstruktor, použijeme klíčové slovo „this“ k volání parametrizovaného konstruktoru z konstruktoru no-args. Tomu se také říká „Explicitní vyvolání konstruktoru“.

Proč potřebujeme toto klíčové slovo?

Potřebujeme to, protože explicitní vyvolání konstruktorů není možné přímo pomocí pouze názvu konstruktoru.

Body k poznámce:

Klíčové slovo „this“ by mělo být prvním příkazem ve volajícím konstruktoru.
Pokud má konstruktor klíčové slovo „toto“, pak nemůže mít „super“. To znamená, že konstruktor může mít buď super, nebo toto.

class TestClass { TestClass() { //calling Parameterized Constructor this('SoftwareTestingHelp'); System.out.println('TestClass::No-args Constructor'); } TestClass(String str) { System.out.println('TestClass:: Parameterized Constructor(String):' + str); } } class Main{ public static void main(String() args) { TestClass obj = new TestClass(); } }

Výstup:

Konstruktor „this ()“ v Javě

Ve výše uvedeném programu máme ‚TestClass 'se dvěma konstruktory. Říkáme tomu („SoftwareTestingHelp“) z konstruktoru no-args. Toto je explicitní vyvolání parametrizovaného konstruktoru.

Kopírovat konstruktor v Javě

Jsme si vědomi konstruktoru kopie v C ++. Konstruktor kopírování je konstruktor, který má jako argument odkaz na objekt a nový objekt je vytvořen pomocí dat referenčního objektu.

C ++ poskytuje výchozí konstruktor kopírování, pokud není v programu poskytnut.

Java také poskytuje podporu pro konstruktor kopírování, ale neposkytuje výchozí konstruktor kopírování.

Následující program Java demonstruje konstruktor kopírování pomocí klasického příkladu komplexních čísel, která mají skutečné a imaginární komponenty.

class Complex { private double real, imaginary; // parametrized constructor public Complex(double real, double imaginary) { System.out.println('Complex:: parametrized constructor'); this.real = real; this.imaginary = imaginary; } // copy constructor Complex(Complex c) { System.out.println('Complex::Copy constructor called'); real = c.real; imaginary = c.imaginary; } // Overriding the toString of Object class @Override public String toString() { return '(' + real + ' + ' + imaginary + 'i)'; } } public class Main { public static void main(String() args) { Complex c1 = new Complex(1, 5); //calls parametrized constructor System.out.println('C1 = ' + c1); // copy constructor called Complex c2 = new Complex(c1); System.out.println('C2 = ' + c2); // this is a simple assignment operator Complex c3 = c2; } }

Výstup:

Zkopírujte konstruktor v Javě 7

Výše uvedený program má třídu „Complex“, která má parametrizovaný konstruktor a konstruktor kopírování. V hlavní metodě nejprve vytvoříme objekt c1 pomocí parametrizovaného konstruktoru. Pak pomocí níže uvedeného prohlášení

Complex c2 = new Complex (c1);

Výše uvedený příkaz volá konstruktor kopírování, když je odkaz c1 předán konstruktoru při vytváření nového objektu c2.

Řetězce konstruktérů v Javě

Řetězení konstruktorů je proces jednoho konstruktoru, který volá jiný konstruktor stejné třídy.

I když jsme zdědili od základní třídy, konstruktor základní třídy je vyvolán jako první, když je vytvořen objekt podřízené třídy. Toto je také příklad řetězení konstruktorů.

V Javě lze řetězení konstruktoru dosáhnout pomocí dvou přístupů:

Ve stejné třídě : Když voláme jeden konstruktor z jiného konstruktoru stejné třídy, můžeme použít použití this () klíčového slova.
Ze základní třídy: Konstruktor základní třídy lze volat pomocí odvozeného třídy pomocí super klíčového slova.

Proč potřebujeme řetězení konstruktérů?

Když chceme v našem konstruktoru provádět více úkolů, pak místo provedení každého úkolu v jednom konstruktoru rozdělíme úkoly na více konstruktorů a potom zavoláme konstruktory od sebe, což povede k řetězení konstruktoru.

Níže uvádíme některá pravidla, která musíme dodržovat při provádění řetězení konstruktorů.

Řetězení konstruktérů se provádí v libovolném pořadí a přinese stejné výsledky.
Klíčové slovo výraz „toto“ by mělo být prvním výrazem v konstruktoru.
Měli bychom mít alespoň jednoho konstruktora bez tohoto klíčového slova.

Když máme v našem programu dědičnost, můžeme také provést řetězení konstruktorů. V tomto případě bude podtřída volat konstruktor základní třídy. Tímto způsobem začíná tvorba objektů podtřídy inicializací členů nadtřídy.

Nyní implementujeme řetězení konstruktorů v Javě pomocí výše uvedených přístupů.

# 1) Řetězení konstruktérů ve stejné třídě

class DemoClass { // No args constructor DemoClass() { System.out.println('DemoClass::No args constructor'); } // parameterized constructor DemoClass(int val1) { // calls default constructor this(); System.out.println('DemoClass::Constructor with 1 argument: ' + val1); } // parameterized constructor DemoClass(int val1, int val2) { // invokes parameterized constructor with 1 argument this(5); System.out.print('DemoClass::constructor with 2 arguments:'); System.out.println('Product of 2 arguments = ' + val1 * val2); } } class Main{ public static void main(String args()) { // call parameterized constructor with 2 arguments new DemoClass(10, 15); } }

Výstup:

řetězení ve stejné třídě

Jak již bylo zmíněno, řetězců konstruktorů ve stejné třídě dosáhneme pomocí klíčového slova „this“. Ve výše uvedeném programu máme tři konstruktory a voláme jeden konstruktor z druhého pomocí klíčového slova „this“.

Ze základní třídy

Když třída zdědí jinou třídu, potom se nejprve vyvolá konstruktor nadřazené třídy, když vytvoříme objekt odvozené třídy, což je zřetězení konstruktoru.

Pokud chceme explicitně zavolat konstruktor základní třídy v odvozené třídě, měli bychom pro tento účel použít klíčové slovo „super“. Pomocí klíčového slova „super“ můžeme nazývat konstruktory nadtřídy v hierarchii dědičnosti, dokud nedosáhneme nejvyšší třídy.

Níže uvedený program demonstruje použití klíčového slova „super“ pro řetězení konstruktorů.

class BaseClass { String name; // no args constructor BaseClass() { this(''); System.out.println('BaseClass::No-argument constructor'); } // Parameterized constructor BaseClass(String name) { this.name = name; System.out.println('BaseClass::Parameterized constructor'); } } class DerivedClass extends BaseClass { // No-argument constructor DerivedClass() { System.out.println('DerivedClass::No-argument constructor'); } // parameterized constructor DerivedClass(String name) { super(name); // invokes Parameterized constructor of BaseClass System.out.println('DerivedClass::Parameterized constructor'); } } class Main { public static void main(String args()) { // invokes DerivedClass parameterized constructor DerivedClass obj = new DerivedClass('Java'); } }

Výstup:

Ze základní třídy

Ve výše uvedeném programu vyvoláme parametrizovaný konstruktor odvozené třídy s hodnotou „Java“. Tento konstruktor má zase volání konstruktoru základní třídy pomocí „super (name);“ který provádí parametrizovaný konstruktor základní třídy.

sql rozhovor otázky a odpovědi pro testery

Často kladené otázky

Otázka č. 1) Jak vytvoříte konstruktor v Javě?

Odpovědět: Vytvoříme konstruktor jako speciální metodu, která má stejný název jako název třídy. Konstruktor nemůže mít také návratový typ. Může mít modifikátory přístupu, ale nemůže být konečné, statické, abstraktní nebo synchronizované.

Pokud je ABC třída, můžeme její konstruktor definovat jako

ABC(){} //no args constructor OR ABC(param1, param 2, …, param n) {} //parameterized constructor

Otázka 2) Jaká je výhoda konstruktoru v Javě?

Odpovědět: Pomocí konstruktoru můžeme inicializovat členy třídy jako první věc, kterou je momentový objekt vytvořen. Konstruktor eliminuje potřebu implicitně volat normální metody.

V konstruktoru můžeme provádět různé úkoly související s inicializací, spouštěním úkolů atd., Protože konstruktory jsou vyvolány během fáze vytváření objektu.

Otázka č. 3) Proč se používají konstruktéři?

Odpovědět: Konstruktory se používají hlavně k inicializaci členů třídy a jsou vyvolány při vytváření objektu třídy.

Otázka č. 4) Může být konstruktor soukromý?

Odpovědět: Ano, můžeme mít soukromého konstruktéra. Když je konstruktor soukromý, pak třídě lze zabránit v vytváření instancí.

Otázka č. 5) Může být konstruktér konečný?

Odpovědět: Ne, nemůžeme mít konečného konstruktora.

Závěr

V tomto tutoriálu jsme zahájili diskusi o konstruktorech v Javě. Naučili jsme se základy konstruktoru, jeho vytvoření a pravidla, která je třeba dodržovat. Diskutovali jsme také o konstruktorech kopírování v Javě.

Výchozí konstruktor a typy konstruktorů a koncepty, jako je přetížení konstruktoru a řetězení konstruktorů, byly stručně popsány s příklady. V rámci těchto témat jsme také viděli použití klíčového slova „this“ v konstruktorech.

=> Přečtěte si řadu Easy Java Training Series.

Konstruktor Java - konstruktory třídy, kopírování a výchozí