Konštruktéri Java. Prečo sú potrební konštruktéri? Koncept predvoleného konštruktora

1. Koncept predvoleného konštruktora

Predvolený konštruktor je konštruktor, ktorý nemá žiadne parametre. Predvolený konštruktor môže byť explicitne deklarovaný v triede alebo generovaný automaticky.

V najvšeobecnejšom prípade pre triedu ClassName predvolený konštruktor vyzerá takto:

trieda Názov triedy(... // vyhlásenie konštruktora ClassName() ( // telo konštruktora // ... } ... }

2. V ktorých prípadoch je predvolený konštruktor automaticky generovaný v triede a v ktorých nie? Príklad

Ak v triede nie je deklarovaný žiadny konštruktor, vygeneruje sa predvolený konštruktor. To znamená, že predvolený konštruktor sa v triede automaticky vygeneruje iba vtedy, ak trieda neobsahuje implementácie iných konštruktorov. Ak trieda obsahuje implementáciu aspoň jedného konštruktora s parametrami, potom aby bolo možné deklarovať predvolený konštruktor, musí byť explicitne deklarovaný v triede.

Napríklad. V nasledujúcej deklarácii triedy sa automaticky vygeneruje predvolený konštruktor

trieda CMyClass( int d; int GetD() ( vrátiť d; ) neplatné SetD( int nd) ( d = nd; ) )

Vyššie uvedený kód znamená, že môžete deklarovať objekt triedy pomocou predvoleného konštruktora:

// funguje, pretože trieda už neimplementuje žiadny konštruktor CMyClass mc = Nový CMyClass();

Ak sa do tela triedy CMyClass pridá aspoň jeden ďalší konštruktor (napríklad konštruktor s jedným parametrom), predvolený konštruktor sa nevygeneruje automaticky

trieda CMyClass( int d; // predvolený konštruktor sa už negeneruje automaticky CMyClass( int nd) (d = nd; ) int GetD() ( vrátiť d; ) neplatné Set( int nd) ( d = nd; ) )

Po implementácii vyššie deklarovanie objektu pomocou predvoleného konštruktora zlyhá. Je však možné deklarovať objekt pomocou konštruktora s jedným parametrom

// chyba kompilácie, pretože v triede je už deklarovaný iný konštruktor // CMMyClass mc = new CMyClass(); CMyClass mc2= Nový CMyClass(7); // a tento kód funguje

Vyššie uvedený riadok bude mať za následok chybu kompilácie:

Konštruktor CMyClass() nie je definovaný

Ak chcete mať implementáciu predvoleného konštruktora a deklarovať objekt triedy pomocou predvoleného konštruktora, musí byť explicitne nastavený. Mohlo by to byť napríklad takto

trieda CMyClass( int d; // explicitné predvolené vyhlásenie konštruktora CMyClass() (d = 0; ) // deklarácia konštruktora s 1 parametrom, CMyClass( int nd) (d = nd; ) int GetD() ( vrátiť d; ) neplatné Set( int nd) ( d = nd; ) )

Po takejto implementácii môžete vytvoriť inštanciu triedy napríklad pomocou dvoch konštruktorov

CMyClass mc = Nový CMyClass(); // zavolá sa predvolený konštruktor mc.d = 25; CMyClass mc2= Nový CMyClass(5); // volá sa konštruktor s 1 parametrom

3. Volanie konštruktorov z iných konštruktorov. Príklad

Programovací jazyk Java vám umožňuje volať konštruktory tried z iného konštruktora rovnakej triedy. Na tento účel sa používa kľúčové slovo this, ktoré je odkazom na aktuálnu triedu.

Príklad. Príklad demonštruje použitie triedy CPixel, ktorá implementuje pixel na obrazovke monitora.

// Trieda, ktorá implementuje pixel na obrazovke monitora verejnosti trieda CPixel( // interné premenné triedy súkromné int x, y; // súradnice pixelov súkromné int farba; // farba pixelov // konštruktor bez parametrov (predvolený konštruktor) CPixel() ( x = y = farba = 0; ) // konštruktor s 2 parametrami, ktoré iba inicializujú súradnice CPixel( int _X, int _y) (x = _x; y = _y; farba = 0; ) // konštruktor s 1 parametrom, ktorý iba inicializuje farbu CPixel( int _color) ( farba = _farba; x = y = 0; ) // 3-parametrový konštruktor, ktorý volá 2-parametrový konštruktor CPixel( int _X, int _y, int _color) ( // volanie konštruktora s 2 parametrami: povinná prvá operácia a iba raz toto(_x, _y); //toto(_farba); // opakované volanie konštruktora je zakázané toto.farba = _farba; // takže je to možné) // prístupové metódy int GetX() ( vrátiť X; ) int GetY() ( vrátiť y; ) int GetColor() ( vrátiť farba; ))

Použitie triedy CPixel v inom programovom kóde (metóda)

CPixel cp1= Nový CPixel(2,8); // volanie konštruktora s 2 parametrami CPixel cp2= Nový CPixel(3,5,8); // zavoláme konštruktor, ktorý zavolá iný konštruktor int d; d = cp1.GetX(); // d = 2 d = cp2.GetColor(); // d = 8 d = cp2.GetY(); // d = 5 ...

4. Aké obmedzenia (požiadavky) sú kladené na volanie iných konštruktorov z konštruktora triedy?

Na správne volanie iných konštruktorov z konštruktora triedy musia byť dodržané nasledujúce požiadavky (obmedzenia):

• možno zavolať iba jeden ďalší konštruktor triedy. Volanie dvoch alebo viacerých iných konštruktorov tejto triedy je zakázané. Vyplýva to z logiky, že konštruktor triedy je navrhnutý tak, aby vytvoril objekt triedy iba raz (a nie dvakrát alebo viackrát);
• volanie iného konštruktora musí byť prvou operáciou vo volajúcom konštruktore. Ak je vo volajúcom konštruktore volanie iného konštruktora implementované druhou (treťou atď.) operáciou, kompilátor vygeneruje chybu.

Metóda v Jave je súbor výrazov, ktorých súhrn umožňuje vykonať určitú operáciu. Napríklad, keď sa zavolá metóda System.out.println(), systém vykoná sériu príkazov na vytlačenie správy do konzoly.

V tomto kroku sa naučíte vytvárať vlastné metódy s návratovými hodnotami alebo bez nich, volať metódy s parametrami alebo bez nich a izolovať metódy pri vývoji programu.

Vytvorte metódu

Nižšie je uvedený príklad ilustrujúci syntax metódy, ako vytvoriť metódu v jazyku Java.

Syntax

public static int methodName(int a, int b) ( // telo )

• verejný statik - modifikátor;
• int - návratový typ;
• methodName - názov metódy;
• a, b - formálne parametre;
• int a, int b - zoznam parametrov.

Definícia metódy je reprezentovaná hlavičkou a telom metódy. To isté môžeme pozorovať v nasledujúcej syntaxi vytvárania metódy.

Syntax

modifikátor returnType nameOfMethod (Zoznam parametrov) ( // telo metódy )

Vyššie uvedená syntax zahŕňa:

• modifikátor - určuje typ prístupu pre metódu a možnosť jej použitia.
• returnType - metóda môže vrátiť hodnotu.
• nameOfMethod - Určuje názov metódy. Podpis metódy obsahuje názov metódy a zoznam parametrov.
• Zoznam parametrov - zoznam parametrov je reprezentovaný typom, poradím a počtom parametrov metódy. Táto možnosť je nastavená ľubovoľne, v metóde môže byť prítomný parameter null.
• telo metódy - telo metódy definuje spôsob práce s príkazmi.

Príklad

/* útržok kódu vráti minimum medzi dvoma číslami */ public static int minFunction(int n1, int n2) ( int min; if (n1 > n2) min = n2; inak min = n1; return min; )

Volanie metódy

Pred použitím metódy je potrebné ju zavolať. Existujú dva spôsoby, ako zavolať metódu v Jave, t.j. metóda vytvára návratovú hodnotu alebo nevytvára (neexistuje žiadna návratová hodnota).

Algoritmus volania metódy je pomerne jednoduchý. Keď program volá metódu v jazyku Java, programové riadenie sa prenesie na volanú metódu. Táto volaná metóda potom vráti riadenie volajúcemu klientovi v dvoch prípadoch, ak:

• vykoná sa príkaz return;
• bola dosiahnutá uzatváracia zložená zátvorka konca metódy.

Metóda void return vyvolá príkaz. Zvážte príklad:

System.out.!");

Metódu návratu hodnoty možno ilustrovať na nasledujúcom príklade:

int vysledok = suma(6, 9);

Príklad nižšie ukazuje, ako definovať a volať metódu v jazyku Java.

Príklad

public class ExampleMinNumber ( public static void main(String args) ( int a = 11; int b = 6; int c = minFunction(a, b); System.out.println("Min value = " + c); ) / * Vráti minimálne dve čísla */ public static int minFunction(int n1, int n2) ( int min; if (n1 >

Minimálna hodnota = 6

Kľúčové slovo neplatné

Kľúčové slovo neplatné v Jave nám umožňuje vytvárať metódy, ktoré nevracajú hodnotu. V nižšie uvedenom príklade sme uvažovali o metóde typu void – methodRankPoints. Metódy Java void nevracajú žiadnu hodnotu. Volanie metódy typu void sa vykonáva príkazom, t.j. methodRankPoints(255.7);. Toto je java výraz, ktorý končí bodkočiarkou, ako je znázornené v príklade nižšie:

Príklad

public class ExampleVoid ( public static void main(String args) ( methodRankPoints(255.7); ) public static void methodRankPoints(double points) ( if (body >= 202.5) ( System.out.println("Rank A1"); )else if (body >= 122,4) ( System.out.println("Rank A2"); )else ( System.out.println("Rank A3"); ) ) )

V dôsledku toho sa získa nasledujúci výsledok:

Poradie A1

Odovzdávanie parametrov hodnotou v jazyku Java

Keď sa proces volania spustí, Java odovzdá argumenty. Postup sa musí vykonať v poradí špecifikovanom zodpovedajúcimi parametrami v špecifikácii metódy. Parametre je možné odovzdať hodnotou alebo odkazom.

V Jave odovzdávanie parametrov hodnotou znamená volanie metódy s parametrom. Z tohto dôvodu je hodnota argumentu odovzdaná parametru.

Príklad

Nasledujúci program ukazuje príklad odovzdávania parametra hodnotou. Hodnoty argumentov zostávajú nezmenené aj po zavolaní metódy.

Príklad výmeny verejnej triedy ( public static void main(String args) ( int a = 30; int b = 45; System.out.println("Pred odovzdaním budú hodnoty argumentov a = " + a + " a b = " + b); // Volanie metódy prenosu swapFunction(a, b); System.out.println("\nTeraz, pred a po odovzdaní hodnoty argumentov "); System.out.println("zostal nezmenený, a = " + a + " a b = " + b); ) public static void swapFunction(int a, int b) ( System. out. println("Pred výmenou: a = " + a + " b = " + b ); // Odovzdávanie parametrov int c = a; a = b; b = c; System.out.println("Po nahradení: a = " + a + " b = " + b); ) )

Dostaneme nasledujúci výsledok:

Pred odovzdaním hodnoty argumentov a = 30 a b = 45 Pred nahradením: a = 30 b = 45 Po nahradení: a = 45 b = 30 Teraz, pred a po odovzdaní, zostali hodnoty argumentov nezmenené, a = 30 a b = 45

Preťaženie metódy

Preťaženie metódy v jazyku Java- prípad, keď sú v triede dve alebo viac metód s rovnakým názvom, ale odlišnými parametrami. Tento proces sa líši od základných metód. Keď sú metódy prepísané, metóda je charakterizovaná rovnakým názvom, typom, počtom parametrov atď.

Zvážte príklad uvedený vyššie pri definovaní minimálnych čísel celočíselného typu. Povedzme teda, že chceme definovať minimálny počet typu double. V tomto prípade sa zavedie koncept preťaženia na vytvorenie dvoch alebo viacerých metód s rovnakým názvom, ale odlišnými parametrami.

Vyššie uvedený príklad ilustruje vyššie uvedené.

Príklad

public class ExampleOverloading ( public static void main(String args) ( int a = 7; int b = 3; double c = 5.1; double d = 7.2; int vysledok1 = minFunction(a, b); // rovnaká funkcia s ostatnými parametrami double result2 = minFunction(c, d); System.out.println("Minimálna hodnota = " + výsledok1); System.out.println("Minimálna hodnota = " + výsledok2); ) // pre celočíselné verejné statické int minFunction ( int n1, int n2) ( int min; if (n1 > n2) min = n2; inak min = n1; return min; ) // pre double public static double minFunction(double n1, double n2) ( double min; if ( n1 > n2) min = n2; inak min = n1; návrat min; ) )

V dôsledku toho sa získa nasledujúci výsledok:

Minimálna hodnota = 3 Minimálna hodnota = 5,1

Metódy preťaženia robia program čitateľným. Existujú teda dve metódy s rovnakým názvom, ale odlišnými parametrami. V dôsledku toho sme dostali minimálne číslo typu int a číslo typu double.

Používanie argumentov príkazového riadku

Počas programu možno budete musieť preniesť určité informácie. To sa dá urobiť v Jave odoslaním argumentov príkazového riadka do main().

V jazyku Java predstavuje argument príkazového riadka informácie, ktoré bezprostredne nasledujú za názvom programu v príkazovom riadku, keď je spustený. Získanie prístupu k argumentom príkazového riadku v programe Java nie je ťažké. Sú uložené ako reťazec v poli reťazcov odovzdaných do main().

Príklad

Nižšie uvedený program zobrazuje všetky vyvolané argumenty príkazového riadku.

Verejná trieda CommandLine ( public static void main(String args) ( for(int i = 0; i

Skúste spustiť tento program, ako je uvedené nižšie:

$java CommandLine je príkazový riadok 300 -200

V dôsledku toho sa získa nasledujúci výsledok:

args: toto je args: príkazový riadok args: string args: 300 args: -200

Konštruktor v Jave

V Jave konštruktér inicializuje objekt, keď je vytvorený. Jeho názov je podobný názvu triedy a jeho syntax je podobná syntaxi metódy. Na rozdiel od posledne menovaného však konštruktor nemá návratovú hodnotu.

Typicky sa konštruktor v jazyku Java môže použiť na nastavenie počiatočnej hodnoty pre premenné inštancie definované triedou alebo na vykonanie akýchkoľvek iných spúšťacích procedúr potrebných na vytvorenie plne vytvoreného objektu.

Konštruktory sú prítomné vo všetkých triedach bez ohľadu na to, ako sú špecifikované, pretože Java automaticky poskytuje predvolený konštruktor, ktorý inicializuje všetky premenné členov triedy na nulu. Keď však zadefinujete svoj vlastný konštruktor, predvolený konštruktor sa už nebude používať.

Príklad

Nižšie uvedený príklad ukazuje použitie konštruktora triedy bez parametrov.

// Jednoduchý konštruktor. class MyClass ( int x; // Ďalej nasleduje konštruktor MojaTrieda() ( x = 10; ) )

Ak chcete inicializovať objekty, musíte vykonať volanie konštruktora ako v nasledujúcom príklade.

Verejná trieda ConsDemo ( public static void main(String args) ( MyClass t1 = new MyClass(); MyClass t2 = new MyClass(); System.out.println(t1.x + " " + t2.x); ) )

Dostaneme výsledok:

Parametrizovaný konštruktor

Najčastejšie budete potrebovať konštruktor, ktorý má jeden alebo viac parametrov. Pridávanie parametrov do konštruktora je rovnaké ako ich pridávanie do metódy, len ich musíte vložiť do zátvoriek za názov konštruktora.

Príklad

// Jednoduchý konštruktor. class MojaTrieda ( int x; // Pod konštruktorom MojaTrieda(int i) ( x = i; ) )

Ak chcete inicializovať objekty, budete musieť zavolať konštruktor ako v nasledujúcom príklade.

Verejná trieda ConsDemo ( public static void main(String args) ( MyClass t1 = new MyClass(10); MyClass t2 = new MyClass(20); System.out.println(t1.x + " " + t2.x); ) )

Dostaneme nasledujúci výsledok:

toto kľúčové slovo

toto kľúčové slovo- používa sa na označenie aktuálnej triedy danej inštanciou metódy alebo konštruktora. Pomocou tohto v jazyku Java môžete odkazovať na inštancie triedy, ako sú konštruktory, premenné a metódy.

Poznámka: Kľúčové slovo this sa používa iba v rámci metód inštancie alebo konštruktorov.

Toto kľúčové slovo v jazyku Java sa zvyčajne používa na:

• diferenciácia medzi premennými inštancie a lokálnymi premennými, ak majú rovnaký názov, ako súčasť konštruktora alebo metódy.

trieda Študent ( int age; Student(int age) ( this.age = age; ) )

• volanie konštruktora jedného typu (parametrizovaný konštruktor alebo predvolený konštruktor) z iného v rámci triedy. Tento proces sa tiež nazýva explicitné vyvolanie konštruktora.

trieda Študent ( int age Student() ( this(20); ) Student(int age) ( this.age = age; ) )

Príklad

Verejná trieda This_Example ( // Inicializácia premennej num int num = 11; This_Example() ( System. out. println("Toto je vzorový program s kľúčovým slovom this"); ) This_Example(int num) ( // Volanie predvoleného konstruktor this(); // Priraďte lokálnu premennú num k premennej inštancie num this.num = num; ) public void greet() ( System.out.println("Ahoj! Vitajte v ProgLang!"); ) public void print() ( // Lokálna premenná num int num = 20 // Volanie metódy triedy pozdrav this.greet() // Tlač lokálnej premennej System.out.println("Hodnota lokálnej premennej num: " + num); // Tlač premennej inštancie System .out.println("hodnota premennej inštancie num: " + this.num); ) public static void main(String args) ( // Inicializácia triedy This_Example obj1 = new This_Example(); // Volanie metódy tlače obj1.print() ; // Odovzdanie novej hodnoty premennej num cez parametrizovaný konštruktor This_Example obj2 = new This_Example(30); // You opätovné volanie metódy print obj2.print(); ))

V dôsledku toho sa získa nasledujúci výsledok:

Toto je príklad programu s kľúčovým slovom this Hello! Vitajte v Proglangu! Hodnota lokálnej premennej num: 22 Hodnota inštancie premennej num: 11 Toto je príklad programu s kľúčovým slovom this Hello! Vitajte v Proglangu! Hodnota lokálnej premennej num: 22 Hodnota inštancie premennej num: 30

Variabilné argumenty (var-args)

JDK 1.5 a vyššie vám umožňuje odovzdať metóde premenlivý počet argumentov rovnakého typu. Parameter v metóde je deklarovaný takto:

TypeName... parameterName

Pri deklarovaní metódy zadávate typ, za ktorým nasleduje elipsa (...). V metóde možno zadať iba jeden parameter s premennou dĺžkou a tento parameter musí byť posledným parametrom. Všetky bežné parametre mu musia predchádzať.

Príklad

public class VarargsDemo ( public static void main(String args) ( // Volanie metódy s premennou argumentov printMax(27, 11, 11, 5, 77.1); printMax(new double(10, 11, 12, 77, 71)); ) public static void printMax(double...numbers) ( if (čísla.dĺžka == 0) ( System.out.println("Neprešiel žiadny argument"); return; ) double result = čísla; for (int i = 1 ; i výsledok) výsledok = čísla[i]; System.out.println("Maximálna hodnota " + výsledok); ) )

V dôsledku toho sa získa nasledujúci výsledok:

Maximálna hodnota 77,1 Maximálna hodnota 77,0

metóda finalize().

metóda finalize().- metóda, ktorá bude vyvolaná bezprostredne pred konečným zničením objektu smetiarom. (finalizátor). V jazyku Java sa dá finalize() použiť na zabezpečenie čistého dokončenia objektu.

Napríklad môžeme použiť finalize(), aby sme sa uistili, že otvorený súbor vlastnený daným objektom bol zatvorený.

Ak chcete do triedy pridať finalizátor, musíte jednoducho definovať metódu finalize() v jazyku Java. Runtime prostredie Java volá túto metódu tesne pred spracovaním objektu tejto triedy.

V rámci metódy finalize() zadávate akcie, ktoré sa musia vykonať pred zničením objektu.

Vo všeobecnosti metóda finalize() vyzerá takto:

Protected void finalize() ( // finalizácia kódu tu )

Kľúčové slovo protected tu predstavuje špecifikátor, ktorý bráni prístupu finalize() kódu definovanému mimo jeho triedy.

To znamená, že nemôžete vedieť, ako a kedy sa vykoná finalize(). Napríklad, ak sa váš program ukončí pred garbage collection, finalize() sa nevykoná.

Konštruktor je špeciálna metóda, ktorá sa volá pri vytvorení nového objektu. Nie je vždy vhodné inicializovať všetky premenné triedy pri vytváraní jej inštancie. Niekedy je jednoduchšie nechať niektoré hodnoty predvolene vytvoriť pri vytváraní objektu. V skutočnosti je konštruktor potrebný na automatickú inicializáciu premenných.

Konštruktor inicializuje objekt priamo v čase vytvorenia. Názov konštruktora je rovnaký ako názov triedy vrátane veľkosti písmen a syntax konštruktora je podobná ako pri metóde bez návratovej hodnoty.

Private int Cat(); // takto vyzerá metóda s názvom Cat(); // takto vyzerá konštruktor triedy Cat

Na rozdiel od metódy konštruktor nikdy nič nevracia.

Konštruktor definuje akcie, ktoré sa majú vykonať, keď je vytvorený objekt triedy a je dôležitou súčasťou triedy. Programátori sa spravidla snažia explicitne špecifikovať konštruktor. Ak neexistuje explicitný konštruktor, Java ho automaticky vytvorí na predvolené použitie. Keď sme implementovali triedu box, potom nebol vytvorený žiadny konštruktor.

Pridajme do triedy konštruktor, ktorý jednoducho nastaví počiatočné hodnoty pre box.

Class Box ( int width; // box width int height; // box height int depth; // box hĺbka // Box() konštruktor ( šírka = 10; výška = 10; hĺbka = 10; ) // výpočet objemu boxu int getVolume() ( návratová šírka * výška * hĺbka; ) )

Metódu sme dočasne odstránili setDim() a pridal konštruktor. Poďme sa pozrieť čo sa stalo:

Box catBox = new Box(); mInfoTextView.setText("Objem boxu: " + catBox.getVolume());

Program vypíše objem krabice, aj keď sme pre ňu nešpecifikovali žiadne rozmery. Vďaka konštruktorovi bude mať každá vytvorená krabica určitý pevný objem.

Prirodzene, môžete vrátiť metódu setDim()(pozri článok o triedach) a nastavte si vlastné rozmery boxu:

Box catBox = new Box(); // nastavenie vlastných rozmerov boxu catBox setDim(10, 20, 30); mInfoTextView.setText("Objem boxu: " + catBox.getVolume());

Teraz by vám už malo byť jasné, že keď po kľúčové slovo Nový napíšeme názov triedy so zátvorkami, potom vlastne voláme konštruktor triedy.

Vyvstáva otázka - ale najprv sme pri vytváraní triedy nevytvorili konštruktor, ale kód newBox() pracoval. Faktom je, že ak konštruktor nie je explicitne definovaný, Java vytvorí konštruktor, ktorý sa bude štandardne používať. V tomto prípade jednoducho priradí nulové hodnoty všetkým premenným. Ak ste si vytvorili konštruktor sami, predvolený konštruktor sa nepoužije.

Ako každá metóda, aj konštruktor môže mať argumenty. Argumenty konštruktora odovzdávajú parametre na inicializáciu objektu. Napríklad, ak trieda kat existuje konštruktor, ktorý berie ako argument celé číslo označujúce vek mačky a potom objekty kat bude vytvorený takto:

Cat cat = nová Cat(8); // mačka má 8 rokov

Ak mačka (int) je jediný konštruktor triedy, kompilátor nedovolí vytvárať objekty kat nejakým iným spôsobom.

Ale späť k boxom pre mačky. Konštruktor, ktorý sme vytvorili, nie je obzvlášť užitočný, pretože vytvára rovnaké boxy. Vytvorme konštruktor s parametrami v triede box a komentujte prvý bezparametrický konštruktor:

// Druhý konštruktor Box(int ​​​​š, int h, int d) ( šírka = š; výška = v; hĺbka = d; )

Ak trieda obsahuje jeden konštruktor s parametrami, pri deklarovaní triedy budete musieť zadať hodnoty:

// Tento konštruktor už nie je platný // Box catBox = new Box(); // V konštruktore musíte zadať hodnoty veľkosti boxu Box catBox = new Box(100, 200, 100); mInfoTextView.setText("Objem boxu: " + catBox.getVolume());

Mimochodom, s takýmto konštruktorom je metóda setDim() už to nepotrebujeme. Rozmery boxu môžeme nastaviť priamo v konštruktore. Keďže krabica je s najväčšou pravdepodobnosťou konštantná a nemení svoju veľkosť, metóda je možno zbytočná. Ale ak zmeníme veľkosť krabice, potom bude potrebné metódu opustiť.

Trieda môže mať viacero konštruktorov. Odkomentujte prvý konštruktor a vytvorte dva boxy – predvolený box a veľký box.

Box defaultBox = new Box(); mInfoTextView.setText("Štandardný objem boxu: " + defaultBox.getVolume()); Box bigBox = new Box(100, 200, 200); mInfoTextView.append("\nObjem veľkého poľa: " + bigBox.getVolume());

To znamená, že vidíme, že konštruktory podporujú preťaženie, rovnako ako metódy.

Napríklad môžeme vytvoriť ďalší konštruktor špeciálne pre krabicu vo forme kocky, kde sú všetky strany rovnaké:

// Tretí konštruktor pre kocku Box (int ​​len) ( šírka = výška = hĺbka = dĺžka; )

Vypočítajte veľkosť kocky:

Box kocka = new Box(5); intvol = cube.getVolume(); mInfoTextView.setText("Objem kocky: " + objem);

Použitie objektu ako parametrov

Ako parametre v konštruktoroch sme doteraz používali jednoduché typy. Môžete však odovzdať aj objekt samotnej triedy. Pridajme ďalší konštruktor:

// Použite objekt typu Box Box(Box ob) ( width = ob.width; height = ob.height; depth = ob.depth; )

V kóde programu môžete použiť konštruktor takto:

Box1 = new Box(100, 200, 100); Box cloneBox = new Box(box1); intvol = cloneBox.getVolume(); mInfoTextView.setText("Objem boxu: " + objem);

Krabicová trieda (zdroj)

balík sk.alexanderklimov.box; class Box ( int width; // šírka boxu int height; // výška boxu int hĺbka; // hĺbka boxu // Constructor Box() ( šírka = 10; výška = 10; hĺbka = 10; ) // Druhý konštruktor Box( int w, int v, int d) ( šírka = š; výška = v; hĺbka = d; ) // Tretí konštruktor pre kocku Box (int ​​len) ( šírka = výška = hĺbka = len; ) // Použite objekt typu Box Box(Box ob) ( šírka = ob.width; výška = ob.height; hĺbka = ob.depth; ) // výpočet objemu boxu int getVolume() ( návratová šírka * výška * hĺbka; ) // nastavenie rozmerov boxu void setDim (int w, int v, int d) ( šírka = š; výška = v; hĺbka = d; ) )

Volanie preťažených konštruktorov cez toto ()

Pri práci s preťaženými konštruktormi je vhodné volať jeden konštruktor z druhého cez kľúčové slovo toto. Pri vykonávaní konštruktora toto () preťažený konštruktor, ktorý zodpovedá zoznamu parametrov, sa vykoná ako prvý. Potom sa vykonajú príkazy v pôvodnom konštruktore, ak nejaké existujú. Výzva konštruktéra toto () musí byť prvým príkazom v konštruktore.

Najprv vytvorte triedu, ktorá nepoužíva konštruktor. toto () aby si pochopil rozdiel.

Trieda Cat ( int vek; int narodeniny; // Inicializácia premenných explicitne Cat(int i, int j) ( vek = i; narodeniny = j; ) // Inicializácia premenných s rovnakou hodnotou Cat(int i) ( vek = i; narodeniny = i; ) // Nastavte predvolené hodnoty na 0 Cat() (vek = 0; narodeniny = 0; ) )

Vytvorili sme triedu s tromi konštruktormi. Prepíšte triedu pomocou konštruktora toto ().

Trieda Cat( int vek; int narodeniny; // Inicializácia premenných explicitne Cat(int i, int j) ( vek = i; narodeniny = j; ) // Inicializácia premenných s rovnakou hodnotou Cat(int i) ( this(i, i); // volanie Cat(i, i); ) // Nastaviť predvolené hodnoty na 0 Cat() ( this(0); // volanie Cat(0); ) )

Teraz máme iba jeden konštruktor, ktorý priraďuje hodnoty poliam - Cat(int, int). Čo sa stane po vykonaní príkazu:

Cat cat = nová Cat(8);

Výzva konštruktéra mačka (8) spôsobí spustenie konštruktora toto (8, 8), čo je ekvivalentné volaniu konštruktora Mačka (8, 8).

Čo sa stane po vykonaní príkazu:

Cat cat2 = new Cat();

V tomto prípade sa volá konštruktor toto (0), čo spôsobí spustenie konštruktora mačka(0), pretože toto je verzia konštruktora, ktorá zodpovedá zoznamu parametrov. Zároveň aj konštruktér mačka(0) v podstate volá konštruktor mačka(0, 0).

Používanie preťažených konštruktérov prostredníctvom konštruktora toto () umožňuje eliminovať duplicitu kódu, čím sa skracuje čas načítania triedy.

Ale buďte opatrní, pretože konštruktory, ktoré volajú konštruktor toto (), sú o niečo pomalšie.

súkromný konštruktér

Niekedy sa trieda vytvorí len na uloženie niektorých statických polí a statických metód. Je zvykom, že takéto triedy sú pomenované komunálne služby, ale toto je voliteľné. Takáto trieda nepotrebuje konštruktor, ale ak ho autor triedy nevytvoril, potom systém sám vytvorí predvolený konštruktor. Takýto konštruktor nedáva zmysel a môže byť aj zdrojom chýb. Na ochranu pred týmto problémom musíte sami explicitne vytvoriť prázdny konštruktor a nastaviť ho ako súkromný.

public class Utils ( private Utils() ( throw new AssertionError(); ) ... //váš správny kód // Nesprávny kód, len na demonštračné účely! public static void someMethod()( Utils utils = new Utils(); utils . toString(); ) )

Linka hodiť nové AssertionError() nie je povinný, ale pomôže to zachytiť chybu, ak zavoláte konštruktor na samotnej triede. Kompilátor túto možnosť preskočí, ale program sa ukončí s chybou.

Utils.someMethod(); // program sa zatvorí s chybou

Pre túto triedu nemôžete vytvoriť podtriedu.

Faktom je, že:

1. Ak vytvoríte triedu a zadefinujete konštruktor s argumentmi v ňom (trieda AClass, ktorá má iba jeden konštruktor, ktorý má int i), kompilátor už nebude vytvárať predvolený konštruktor. Pretože by to porušilo zmluvu AClass, ktorú nemožno inicializovať bez argumentov. Ak chcete mať aj predvolený konštruktor, nastavte ho teraz explicitne.

Inak by nebolo možné zabrániť vytvoreniu predvoleného konštruktora, čo by bolo zlé.

2. Pri vytváraní konštruktorov triedy BClass, ktorá je zdedená z inej triedy, kompilátor vyžaduje, aby prvý riadok konštruktora bol volaním iného konštruktora (zdedeného alebo v tejto triede).

prečo? Pretože vychádzate z triedy, chcete znova použiť jej logiku. Konštruktor uvedie inštanciu triedy do nejakého počiatočného integrálneho stavu. Vo vašom prípade AClass vyžaduje na inicializáciu argument, bez ktorého JVM nevie, ako inicializovať inštanciu triedy.

Ak trieda nemá definované žiadne konštruktory, tak sa pokúsi vytvoriť predvolený konštruktor, t.j. bez argumentov:

verejná trieda ACclass1 ( )

Keďže tu nie sú explicitne definované žiadne konštruktory A trieda nie je dedená od iných tried, kompilátor vygeneruje predvolený konštruktor.

Toto je ekvivalentné s touto definíciou:

Verejná trieda ACclass1 ( public ACclass1() ( ) )

Teraz sa pozrime na BClass1:

verejná trieda BClass1 rozširuje triedu AC1 ( )

Ani tu nie sú konštruktory explicitne definované a kompilátor sa snaží vytvoriť predvolený konštruktor. Keďže trieda AClass1 má predvolený konštruktor, vytvorí predvolený konštruktor, ktorý bude volať konštruktor AClass1. Tento kód je ekvivalentný tomuto:

Verejná trieda BClass1 rozširuje triedu AC1 ( public BCclass1() ( super(); ) )

Vo vašom prípade sa trieda vytvorí BEZ predvoleného konštruktora:

Verejná ACtrieda ( public ACtrieda(int i) ( ) )

Keďže je tu deklarovaný (aspoň jeden) konštruktor, predvolený konštruktor sa už nevytvára. To znamená, že takýto kód sa už nebude kompilovať:

ACtrieda a = new ACtrieda(); // nefunguje

potrebovať niečo ako

ACtrieda a = nová ACtrieda(1);

Podľa toho bude každý konštruktor BClass vyžadovať volanie nejakého konštruktora ACtriedy alebo BCtriedy. S týmto popisom bude kompilátor prisahať:

Verejná BCtrieda rozširuje ACtriedu()

Pretože dôjde k pokusu zavolať predvolený konštruktor triedy AClass, ktorý nie je definovaný:

Public BClass rozširuje triedu AC ( public BClass() ( super(); // chyba; v triede AC nie je takýto konštruktor))

Je však možné vytvoriť BClass s predvoleným konštruktorom nastavením konštruktora AClass na nejakú hodnotu:

Verejná trieda BClass rozširuje triedu AC ( public BClass() ( super(1); ) )

Toto sa skompiluje.

Ahoj! Dnes si rozoberieme veľmi dôležitú tému, ktorá sa týka našich objektov. Tu môžeme bez preháňania povedať, že tieto znalosti využijete každý deň v skutočnej práci! Porozprávame sa o konštruktérov.

Možno ste tento výraz počuli prvýkrát, ale v skutočnosti ste pravdepodobne používali konštruktory, len ste si to sami nevšimli :) To uvidíme neskôr.

Čo sú konštruktéri a prečo sú potrebné?

Uvažujme o dvoch príkladoch. public class Car ( String model; int maxSpeed; public static void main (String args) ( Car bugatti = nové auto () ; bugatti. model = "Bugatti Veyron" ; bugatti. maxSpeed ​​​​= 407; ) ) Vytvorili sme naše auto a nainštalovaný pre neho model a maximálnu rýchlosť. V skutočnom projekte však objekt Car evidentne nebude mať 2 polia. A napríklad 16 polí! verejná trieda Car (String model; //model int maxSpeed; //maximálna rýchlosť//objem motora//priezvisko majiteľa//počet miest v kabíne Strunový salónMateriál; // materiál interiéru boolovské poistenie; //je poistená//krajina výroby inttrunkVolume; // objem kufra vnútorné zrýchlenie na 100 km; public static void main (String args) ( Auto bugatti = nové auto () ; bugatti. farba = "modrá" ; bugatti. zrýchlenie na 100 km = 3 ; bugatti. motor Objem = 6,3 ; bugatti. prvý výrobcaCountry = "Taliansko" ; Fi bugatti = "bugatti. Amigo" ; bugatti. yearOfIssue = 2016 ; bugatti. poistenie = pravda ; bugatti. cena = 2000000 ; bugatti. isNew = false ; bugatti. placesInTheSalon = 2 ; bugatti. model maxSpeed ​​Ve ​​bugatti = 4077 ) ) Vytvorili sme nový objekt Auto. Jeden problém: máme 16 polí, ale inicializovali sme iba 12! Skúste teraz pomocou kódu nájsť tie, na ktoré sme zabudli! Nie je to také ľahké, však? V takejto situácii sa môže programátor ľahko pomýliť a preskočiť inicializáciu niektorého poľa. V dôsledku toho sa správanie programu stane chybným: verejná trieda Car (String model; // model int maxSpeed; //maximálna rýchlosť vnútorné kolesá; //šírka disku double engineVolume; //objem motora Farba strún; //color int yearOfIssue; //rok vydania String ownerFirstName; //meno vlastníka String ownerPriezvisko; //priezvisko majiteľa dlhá cena; //price boolean isNew; //new or not int placesInTheSalon; //počet miest v kabíne Strunový salónMateriál; // materiál interiéru boolovské poistenie; //je poistená Výrobca strún Krajina; //krajina výroby inttrunkVolume; // objem kufra vnútorné zrýchlenie na 100 km; //zrýchlenie na 100 km/h v sekundách public static void main (String args) ( Auto bugatti = nové auto () ; bugatti. farba = "modrá" ; bugatti. zrýchlenieNa 100 km = 3 ; bugatti. motor Objem = 6,3 ; bugatti. prvý výrobcaCountry = "Taliansko" ; Fi bugatti = "bugatti. Amigo" ; bugatti. yearOfIssue = 2016 ; bugatti. poistenie = pravda ; bugatti. cena = 2000000 ; bugatti. isNew = false ; bugatti. placesInTheSalon = 2 ; bugatti. model maxSpeed ​​Ve ​​bugatti = 4077 System. out.println( "Model Bugatti Veyron. Objem motora -"+ bugatti. motorObjem + ", kufor - " + bugatti. objem kufra + "Salón je vyrobený z"+ bugatti. salón Materiál + ", šírka disku - "+ bugatti. kolesá + ". Získal ho v roku 2018 p."+ bugatti. vlastníkPriezvisko); ) ) Výstup konzoly: Model Bugatti Veyron. Objem motora - 6,3, kufor - 0, interier z null, sirka kolesa - 0. Kupoval v roku 2018 p. null Vášmu zákazníkovi, ktorý zaplatil 2 milióny dolárov za auto, sa očividne nebude páčiť, keď bude menovaný “ pán null“! Ale vážne, v dôsledku toho náš program skončil s nesprávne vytvoreným objektom - autom so šírkou disku 0 (teda úplne bez diskov), chýbajúcim kufrom, interiérom z neznámeho materiálu a dokonca aj so niekomu kto vie. Možno si len predstaviť, ako môže takáto chyba „vystreliť“, keď je program spustený! Takýmto situáciám sa musíme nejako vyhýbať. Je potrebné, aby náš program mal obmedzenie: pri vytváraní nového strojového objektu vždy musí byť špecifikovaný, napríklad model a maximálna rýchlosť. V opačnom prípade nepovoľte vytváranie objektov. Táto úloha sa dá ľahko zvládnuť funkcie konštruktora. Svoje meno dostali z nejakého dôvodu. Konštruktor vytvára akúsi „kostru“ triedy, ktorej musí zodpovedať každý nový objekt triedy. Pre pohodlie sa vráťme k jednoduchšej verzii triedy Car s dvoma poľami. Vzhľadom na naše požiadavky bude konštruktor pre triedu Car vyzerať takto: public Car (String model, int maxSpeed) ( this . model = model; this . maxSpeed ​​​​= maxSpeed; ) A vytvorenie objektu teraz vyzerá takto: public static void main (String args) (Auto bugatti = nové auto ("Bugatti Veyron" , 407); ) ako sa vytvára konštruktor. Je podobná bežnej metóde, ale nemá návratový typ. V tomto prípade je názov triedy uvedený v konštruktore aj s veľkým písmenom. V našom prípade - Auto . Konštruktor navyše použije pre vás nové kľúčové slovo toto. „this“ v angličtine – „this one“. Toto slovo sa vzťahuje na konkrétny predmet. Kód v konštruktore: public Car (String model, int maxSpeed) ( this . model = model; this . maxSpeed ​​​​= maxSpeed; ) možno preložiť takmer doslovne: " model pre toto auto (ktorý práve vytvárame) = argument modelu, ktorý je špecifikovaný v constructor.maxSpeed ​​​​pre tento stroj (ktorý vytvárame) = na argument maxSpeed ​​​​uvedený v konštruktore." A tak sa to stalo: verejná trieda Car ( String model; int maxSpeed; public Car (String model, int maxSpeed) ( this . model = model; this . maxSpeed ​​​​= maxSpeed; ) public static void main (String args) ( Car bugatti = nové auto ("Bugatti Veyron" , 407 ); System. out. println (bugatti. model) ; System. out. println (bugatti. maxSpeed) ; ) ) Výstup na konzolu: Bugatti Veyron 407 Konštruktor úspešne priradil požadované hodnoty. Možno ste si všimli, že konštruktor je veľmi podobný bežnej metóde! Takže je to: konštruktor je metóda, len trochu špecifická :) Rovnako ako v metóde, aj my sme nášmu konštruktorovi odovzdali parametre. A rovnako ako volanie metódy, volanie konštruktora zlyhá, ak nie sú špecifikované: public class Car (String model; int maxSpeed; public Car (String model, int maxSpeed) ( this . model = model; this . maxSpeed ​​​​= maxSpeed; ) public static void main (String args) ( Auto bugatti = nové auto () ; //chyba! ) ) Vidíte, konštruktor urobil to, čo sme sa snažili dosiahnuť. Teraz nemôžete vytvoriť auto bez rýchlosti alebo bez modelu! Podobnosti medzi konštruktormi a metódami tu nekončia. Rovnako ako metódy môžu byť aj konštruktéri preťaženie. Predstavte si, že máte doma 2 mačky. Jedného z nich ste si vzali ako mačiatko a druhého ste si priniesli domov z ulice ako dospelý a neviete presne, koľko má rokov. To znamená, že náš program by mal byť schopný vytvoriť mačky dvoch typov - s menom a vekom pre prvú mačku a iba s menom - pre druhú mačku. Aby sme to urobili, preťažíme konštruktor: public class Cat ( String name; int age; //pre prvú mačku //pre druhú mačku public Cat (String name) ( this . name = name; ) public static void main (String args) ( Cat barsik = new Cat ("Barsik" , 5 ) ; Cat streetCatNamedBob = new Cat ("Bob" ) ; ) ) to pôvodný konštruktor s parametrami “meno” a “vek” sme pridali ďalší, len s názvom. Rovnakým spôsobom sme preťažovali metódy v predchádzajúcich lekciách. Teraz môžeme úspešne vytvoriť obe varianty mačiek :)

Pamätáte si, že na začiatku prednášky sme povedali, že ste už používali konštruktory, ale sami ste si to nevšimli? A existuje. Faktom je, že každá trieda v Jave má tzv predvolený konštruktor. Nepotrebuje žiadne argumenty, ale spustí sa vždy, keď sa vytvorí akýkoľvek objekt akejkoľvek triedy. public class Cat ( public static void main (String args) ( Cat špinenie = new Cat () ; ) ) Na prvý pohľad to nevidno. No vytvorili objekt a vytvorili ho, kde je práca konštruktéra? Aby sme to videli, napíšme priamo prázdny konštruktor pre triedu Cat a v ňom zobrazíme nejakú frázu v konzole. Ak sa zobrazí, konštruktor funguje. public class Mačka ( public Cat () ( System. out. println ("Vytvorená mačka!" ) ; ) public static void main (String args) ( Mačacie šmuhy = nová mačka () ; //tu fungoval predvolený konštruktor } } Výstup na konzolu: Vytvoril mačku! Tu je potvrdenie! Predvolený konštruktor je vždy neviditeľne prítomný vo vašich triedach. Musíte však vedieť ešte jednu jeho vlastnosť. Predvolený konštruktor zmizne z triedy, keď vytvoríte nejaký konštruktor s argumentmi. Dôkaz toho, v skutočnosti, sme už videli vyššie. Tu v tomto kóde: public class Cat ( Meno reťazca; int vek; public Cat (Názov reťazca, int vek) ( this . name = meno; this . age = vek; ) public static void main (String args) ( Cat barsik = new Cat () ; //chyba! ) ) Nemohli sme vytvoriť mačku bez mena a veku, pretože sme definovali konštruktor pre Cat: reťazec + číslo. Hneď potom predvolený konštruktor zmizol z triedy. Preto si nezabudnite: ak potrebujete vo svojej triede niekoľko konštruktorov, vrátane prázdneho, je potrebné ho vytvoriť samostatne. Vytvárame napríklad program pre veterinárnu ambulanciu. Naša klinika chce robiť dobré skutky a pomáhať mačkám bez domova, o ktorých nevieme ani meno, ani vek. Potom by náš kód mal vyzerať takto: public class Cat ( String name; int age; //pre domáce mačky verejná mačka (meno reťazca, int vek) ( toto . meno = meno; toto . vek = vek; ) //pre pouličné mačky public Cat () ( ) public static void main (String args) ( Cat barsik = new Cat ("Barsik" , 5 ) ; Cat streetCat = new Cat () ; ) ) Teraz, keď sme explicitne napísali predvolený konštruktor, môžeme vytvorte mačky oboch typov :) Pre konštruktor (ako pre každú metódu) je poradie argumentov veľmi dôležité. Vymeňme si argumenty mena a veku v našom konštruktore. public class Cat ( String name; int age; public Cat (int age, String name) ( this . name = name; this . age = age; ) public static void main (String args) ( Cat barsik = new Cat („Barsik " , 10 ); //chyba! ) ) Chyba! Konštruktor jasne popisuje: pri vytváraní objektu Cat ho treba odovzdať číslo a reťazec v tomto poradí. Preto náš kód nefunguje. Nezabudnite na to a majte to na pamäti pri vytváraní vlastných tried: verejná mačka (meno reťazca, int vek) ( toto . meno = meno; toto . vek = vek; ) verejná mačka (int vek, názov reťazca) ( toto . vek = vek; toto .meno = meno; ) Toto sú dva úplne odlišné konštruktory! Ak vyjadríte odpoveď na otázku jednou vetou Prečo potrebujete konštruktéra?, môžeš povedať: aby boli predmety vždy v správnom stave. Keď použijete konštruktory, všetky vaše premenné budú správne inicializované a v programe nebudú žiadne stroje s rýchlosťou 0 a iné „nesprávne“ objekty. Ich použitie je veľmi výhodné predovšetkým pre samotného programátora. Ak si polia inicializujete sami, existuje veľké riziko, že niečo vynecháte a urobíte chybu. S konštruktorom sa to však nestane: ak ste mu neodovzdali všetky požadované argumenty alebo ste pomiešali ich typy, kompilátor okamžite zobrazí chybu. Samostatne stojí za zmienku do konštruktora by ste nemali vkladať logiku svojho programu. Na tento účel máte k dispozícii metódy, v ktorom môžete popísať všetky funkcie, ktoré potrebujete. Pozrime sa, prečo je logika konštruktora zlý nápad: verejná trieda CarFactory ( Názov reťazca; int vek; int carsCount; public CarFactory (názov reťazca, int vek, int počet áut) ( this . name = názov; this . age = vek; toto. carsCount = carsCount;system.out.println( "Bola založená" "V priemere produkuje"+ (toto . autaPocet/ tento . vek) + "auta za rok" ) ; ) public static void main (String args) ( CarFactory ford = new CarFactory ("Ford" , 115 , 50000000 ) ;) ) Máme triedu CarFactory, popisujúci automobilku. Vo vnútri konštruktora inicializujeme všetky polia a sem vložíme logiku: vytlačte nejaké informácie o továrni do konzoly. Zdalo by sa, že na tom nie je nič zlé, program fungoval perfektne. Výstup na konzolu: Naša automobilka sa volá Ford Bola založená pred 115 rokmi Za ten čas vyrobila 50 000 000 áut V priemere vyrobí 434 782 áut ročne Ale v skutočnosti sme nastražili časovanú bombu. A takýto kód môže veľmi ľahko viesť k chybám. Predstavte si, že teraz nehovoríme o Forde, ale o novej továrni „Amigo Motors“, ktorá existuje necelý rok a vyrobila 1000 áut: verejná trieda CarFactory (Názov reťazca; int vek; int carsCount; verejná CarFactory (String name, int age, int carsCount) ( this . name = name; this . age = age; this . carsCount = carsCount; System. out. println ( "Naša automobilka sa volá"+ toto. názov); systém. von. println ( "Bola založená"+ toto. vek + "pred rokmi"); systém. von. println ( "Počas tejto doby to bolo vyrobené"+ toto. carsCount + "cars" ); systém. von. println ( "V priemere produkuje"+ (toto . autaPocet/ tento . vek) + "auta za rok" ) ; ) public static void main (String args) ( CarFactory ford = new CarFactory ("Amigo Motors" , 0 , 1000 ) ; ) ) Výstup konzoly: Naša automobilka sa volá Amigo Motors Exception vo vlákne "main" java.lang.ArithmeticException: / by zero Bola založená pred 0 rokmi Počas tejto doby vyrobila v CarFactory 1000 áut. (CarFactory.java:15) v CarFactory.main(CarFactory.java:23) Proces ukončený s kódom ukončenia 1 Prišli sme! Program skončil nejakou zvláštnou chybou. Uhádnete, čo je dôvodom? Dôvod je v logike, ktorú sme vložili do konštruktora. Konkrétne v tomto riadku: Systém. von. println ( "V priemere produkuje"+ (toto . autaPocet/ tento . vek) + "auta za rok" ) ; Tu vykonáme výpočet a rozdelíme počet vyrobených strojov podľa veku továrne. A keďže naša fabrika je nová (teda má 0 rokov), výsledkom je delenie 0, čo je v matematike zakázané. V dôsledku toho sa program ukončí s chybou. Ako sme mali postupovať? Presuňte celú logiku do samostatnej metódy a zavolajte ju, napríklad printFactoryInfo() . Môžete mu odovzdať objekt CarFactory ako parameter. Môžete tam dať aj všetku logiku a zároveň - spracovanie prípadných chýb, ako je naša s nula rokmi. Každému svoje. Na správne nastavenie stavu objektu sú potrebné konštruktory. Pre obchodnú logiku máme metódy. Nemiešajte jedno s druhým. Tu je niekoľko užitočných odkazov, kde si môžete prečítať viac o konštruktoroch: