Obiecte și constructori

1. Crearea unui obiect

Ei bine, am ajuns la crearea de obiecte. Ați mai întâlnit asta înainte, dar acum vom analiza acest subiect mai detaliat. De fapt, este foarte ușor să creezi obiecte.

Pentru a crea un obiect, trebuie să utilizați operatorul nou . Crearea unui obiect arată aproximativ astfel:

new Class(arguments)

După crearea unui obiect, cel mai adesea salvăm imediat o referință la acesta într-o variabilă, care de multe ori împărtășește același tip ca și obiectul creat. Asta înseamnă că atunci când creați un obiect, de obicei vedeți cod ca acesta:

Class name = new Class(arguments)

Unde este crearea unei noi variabile, iar codul din dreapta semnului egal este crearea unui nou obiect al cărui tip este .Class nameClass

Exemple:

Object o = new Object();

Cat pet = new Cat();

Scanner console = new Scanner(System.in)

Programatorii numesc adesea variabilele după clasele lor, dar cu litere mici. Pentru un programator începător, un astfel de cod poate fi confuz:

BufferedReader bufferedReader = new BufferedReader( reader );

Cat cat = new Cat();

PersonInfo personInfo = new PersonInfo()

Nu este nimic în neregulă cu acest cod - acesta este cel mai obișnuit cod, în care o variabilă este creată și apoi inițializată imediat de un obiect de același tip.

În stânga semnului egal avem crearea unei variabile. În dreapta, crearea unui obiect. Asta este.

2. Constructor

Probabil ați văzut că unele argumente sunt transmise frecvent la crearea unui obiect. Mai mult, se transmit argumente pentru unele obiecte, dar nu pentru altele. Cum funcționează întreg acest mecanism cu argumente?

Totul este simplu și aici: fiecare clasă are o metodă (sau metode) speciale care sunt responsabile pentru gestionarea argumentelor transmise la crearea unui obiect. Aceste metode sunt numite constructori . Sau când vorbim doar de unul: constructorul .

Este ușor să distingeți o metodă de constructor de o metodă obișnuită. Această metodă are două caracteristici distinctive:

• numele unui constructor este același cu numele clasei sale (și începe cu o literă mare)
• un constructor nu are niciun tip de returnare.

În general, iată cum arată de obicei:

modifiers Class(arguments)
{
   Code
}

Exemplu:

public class Point
{
   public int x;
   public int y;

   Point(int x, int y)
   {
      this.x = x;
      this.y = y;
   }
}

public class Solution
{
   public static void main(String[] args)
   {
      Point point = new Point(5, 10);
   }
}

Observați cum arată constructorul: nu are niciun tip de returnare și numele său este același cu numele clasei.

Și încă ceva: aruncați o privire la codul din interiorul constructorului. Parametrii constructorului au aceleași nume ca și câmpurile clasei: x și y. Este o practică standard să se evite crearea unor nume noi de parametri. Numele sunt aceleași cu cele ale câmpurilor clasei. Conflictul de nume este rezolvat folosind cuvântul cheie this.

3. Apelarea unui constructor

Când utilizați noul operator și o comandă precum „new Class ( arguments )” pentru a crea un nou obiect, se întâmplă două lucruri:

• Mașina Java creează un obiect al cărui tip este Class
• Mașina Java apelează constructorul obiectului și vă transmite argumentele

Ca programator, poți decide ce constructori ar trebui să aibă clasa ta și ce parametri ar trebui să aibă acești constructori.

Să presupunem că decideți să creați o clasă pentru a urmări pisicile la un adăpost de animale. Atunci Catclasa ta ar putea arăta astfel:

class Cat
{
   public String name;
   public int age;

   public Cat(String name, int age)
   {
      this.name = name;
      this.age = age;
   }
}

Cat cat = new Cat("Whiskers", 2);

Cat cat = new Cat("Whiskers");

Cat cat = new Cat();

Clasa Catare un singur constructor cu parametri de nume și vârstă. Deoarece nu există alți constructori, trebuie să treceți numele pisicii ( name) și vârsta ( age) ca argumente atunci când creați un obiect. Transmiterea argumentelor către constructor nu este opțională .

4. Constructori multipli

Dar dacă aveți nevoie, puteți adăuga mai mulți constructori la clasă. Nu există limită pentru numărul de constructori sau parametrii acestora. Când creați un obiect, compilatorul selectează automat constructorul care se potrivește cu parametrii

class Cat
{
   public static final int UNKNOWN = -1;
   public String name;
   public int age;

   public Cat(String name, int age)
   {
      this.name = name;
      this.age = age;
   }
   public Cat(String name)
   {
      this.name = name;
      this.age = UNKNOWN; // Unknown
   }
}

Cat cat = new Cat("Whiskers", 2);

Cat cat = new Cat("Whiskers");

Cat cat = new Cat();

Am decis să ținem cont de faptul că vârsta unei pisici poate să nu fie cunoscută. Pentru a gestiona acest caz, am adăugat constanta specială UNKNOWNîmpreună cu un constructor care are doar un parametru - numele pisicii.

Rețineți că încă inițializam ambele variabile în ambii constructori. Înlocuim parametrii necunoscuți/lipsă cu constanta UNKNOWN.

Dacă nu este atribuită nicio valoare variabilei de vârstă, atunci aceasta va avea valoarea implicită de 0. La urma urmei, un pisoi găsit pe stradă poate avea 0 ani întregi. Asta înseamnă că un zero în variabila vârstă nu înseamnă neapărat „vârsta necunoscută”.

5. Constructor implicit

Dacă doriți ca obiectele dvs. să fie instanțiate fără niciun parametru, clasa dvs. trebuie să declare un constructor fără argument.

Un constructor fără parametri nu este neapărat un constructor fără cod. Un astfel de constructor poate conține cod care inițializează variabile cu valori de pornire:

class Cat
{
   public static final int UNKNOWN = -1;
   public String name;
   public int age;

   public Cat(String name, int age)
   {
      this.name = name;
      this.age = age;
   }

   public Cat()
   {
      this.name = "Nameless";
      this.age = UNKNOWN; // Unknown
   }
}

Cat cat = new Cat("Whiskers", 2);

Cat cat = new Cat();

Constructor implicit

Există un punct foarte important pe care ar trebui să-l cunoașteți și să vă amintiți.

Dacă clasa dvs. nu declară niciun constructor , compilatorul va adăuga un constructor implicit, care este un constructor fără argument cu modificatorul public.

Dar dacă clasa dvs. declară chiar și un constructor , atunci nu va fi adăugat niciun constructor implicit și va trebui să îl adăugați singur dacă doriți.

class Cat
{
   public String name;
   public int age;
}

Cat cat = new Cat();