Crearea ierarhiilor de clase (Principiul Moștenirii)

Moștenirea este unul din principiile POO şi reprezintă inima acesteia. Ideea de moștenire este una simplă, dar puternică: atunci când doriți să creați o clasă nouă și există deja o clasă care include o parte din codul dorit, puteți deriva noua clasă din clasa existentă. Făcând acest lucru, puteți reutiliza câmpurile și metodele clasei existente fără a fi nevoie să le scrieți singur, sau să le rescrieți astfel generând cod duplicat în proiectul dvs. Deci în moștenire avem: 

1. Clasa părinte (superclass, supercalsă) – conține atribute și metode generale.
2. Clasa copil (subclass, subclasă) – moștenește și poate extinde sau modifica comportamentul.

Fie că avem de creat clasele Dreptunghi, Patrat, Romb. Aceste clase au multe trăsături comune (număr de unghiuri, număr de laturi, culoare, ș.a). Folosind conceptul de moștenire vom putea implementa aceste clase ca să fie ușor de înțeles, menținut şi fără cod duplicat. Astfel vom proiecta o clasă generală (superclasă, clasă de bază, clasă părinte), de exemplu clasa Paralelogram, care să poată fi extinsă mai târziu pentru a crea clase specifice (subclase, clase copil, clase derivate), de exemplu clasele Dreptunghi, Romb, Triunghi. Clasa nouă va moșteni toate atributele și metodele clasei de bază, având posibilitatea de a avea metode și atribute proprii.

O subclasă moștenește toți membrii (câmpuri, metode și clase imbricate) din superclasa sa.

După cum am menționat la lecțiile anterioare în Java poate fi implementată doar moștenirea simplă, adică o clasă poate avea o singură superclasă sau clasă părinte.

Cu excepția clasei Object, care nu are superclasă, fiecare clasă are o singură superclasă, și numai una, directă (moștenire unică). În absența oricărei alte superclase explicite, fiecare clasă este implicit o subclasă a clasei Object.

Pentru a deriva o clasă se folosește cuvântul cheie extends în semnătura clasei copil, urmată de numele clasei părinte.

Să ne reamintim sintaxa generală de declarare a claselor:

[public][abstract][final] class nume_clasa

                               [extends nume_super_clasă]

[implements Interfata1,Interfata2,...,InterfataN]

{

     // atribute, metode, blocuri de cod, alte clase 

}

Sintaxa generală a moștenirii:

class SuperClasa

{

    // variabile ale superclasei
    // metode ale superclasei

    // metode ale superclasei

}

class SubClasa extends SuperClasa

{

    // variabile ale subclasei

    // metode ale subclasei

}

Exemplu: 

Definiți clasa Persoana caracterizată de următoarele atribute: nume. Din clasa Persoana derivați clasa Student caracterizată de atributele: nume și notă. 

class Persoana {

    String nume;

    void afiseazaNume() {

        System.out.println("Nume: " + nume);

    }

}

class Student extends Persoana {

    int nota;

    void afiseazaNota() {

        System.out.println("Nota: " + nota);

    }

}

public class Main{

public static void main(String [] args){

Student s = new Student();

s.nume = "Victoria";

s.nota = 9;

System.out.println(s.nume + " " + s.nota);

}}

Deci, Student moștenește variabila nume și metode metoda afiseazaNume(), adică are o poate apela ori de câte ori este necesar, dar adaugă și un atribut propriu care este nota.

Iată un alt exemplu de cod, pentru o posibilă implementare a unei clase Bicicleta:

public class Bicicleta {

public int cadenta;//numărul de rotații a pedalelor pe minut

public int angrenaj;

public int viteza;

public Bicicleta (int startCadenta, int startViteza, int startAngrenaj) {

angrenaj = startAngrenaj;

cadenta = startCadenta;

viteza = startViteza;

}

public void setCadenta(int valoareNoua) {

cadenta = valoareNoua;

}

public void setAngregaj(int valoareNoua) {

angrenaj = valoareNoua;

}

public void aplicaFrina(int decrementare) {

viteza-= decrementare;

}

public void maresteViteza(int incrementare) {

viteza += incrementare;

}}

O declarație de clasă pentru o clasă BicicletaMunte care este o subclasă de Bicicleta ar putea arăta astfel:

public class BicicletaMunte extends Bicicleta{

public int scaunGreutate;

public BicicletaMunte(int startGreuatate, int startCadenta, int startViteza, int startAngrenaj) {

super(startCadenta, startViteza, startAngrenaj);

scaunGreutate = startGreuatate;

}

public void setGreutate(int valoareNoua) {

scaunGreutate = valoareNoua;

}

}

BicicletaMunte moștenește toți membri clasei Bicicleta, dar în același timp adaugă câmpul scaunGreutate și o metodă pentru a-i seta valoarea.

Rețineți!

1. O subclasă moștenește toți membrii public și protected ai superclasei, indiferent de pachetul în care se află subclasa. 
2. Dacă subclasa se află în același pachet ca și părintele său, moștenește și membrii impliciți ai părintelui, adică cei care nu au nici un modificator de acces specificat. 
3. Puteți folosi membrii moșteniți așa cum sunt, îi puteți înlocui, îi puteți ascunde sau îi puteți completa cu membri noi:
4. Câmpurile moștenite pot fi utilizate direct, la fel ca orice alte câmpuri.
5. Puteți declara un câmp din subclasă cu același nume cu cel din superclasă, astfel ascunzându-l. (NU este recomandat).
6. Puteți declara câmpuri noi în subclasă care nu sunt în superclasă.
7. Metodele moștenite pot fi utilizate direct așa cum sunt.
8. Puteți scrie o nouă metodă de instanță în subclasă care are aceeași semnătură cu cea din superclasă, suprascriind-o astfel (overriding).
9. Puteți scrie o nouă metodă statică în subclasă care are aceeași semnătură cu cea din superclasă, ascunzând-o astfel.
10. Puteți declara metode noi în subclasă care nu sunt în superclasă.
11. Puteți scrie un constructor de subclasă care invocă constructorul superclasei, fie implicit, fie folosind cuvântul cheie super.
12. Nu puteți moșteni membrii privați ai clasei părinte. Totuși, dacă superclasa are metode public sau protected pentru accesarea câmpurilor sale private, acestea pot fi folosite și de subclasă.

În cadrul moștenirii poate fi folosită variabila predefinită super în următoarele cazuri:
1. pentru a referi o variabilă din clasa părinte: super.<nume_variabila>

class ClasaParinte{

int num=100;

}

class Subclasa extends ClasaParinte{

int num=110;

void printNumber(){

System.out.println(super.num);

}

public static void main(String args[]){

Subclasa obj= new Subclasa ();

obj.printNumber();

}}

Atenție!
În cadrul moștenirii, o subclasă poate avea câmpuri cu același nume ca și clasa părinte. În acest caz, câmpul din clasa părinte este "ascuns" în favoarea câmpului cu același nume din subclasă. În codul de mai sus, subclasa Subclasa definește un câmp num care ascunde câmpul cu același nume din clasa părinte ClasaParinte. În metoda printNumber(), se folosește super.num pentru a accesa câmpul num din clasa părinte, care este ascuns în subclasă.

Dacă omitem super.num prioritate va avea variabila din clasa copil:

class ClasaParinte{

int num=100;

}

class Subclasa extends ClasaParinte{

int num=110;

void printNumber(){

System.out.println(num);

}

public static void main(String args[]){

Subclasa obj= new Subclasa ();

obj.printNumber();

}} 

Este important de reținut că utilizarea ascunderii câmpurilor poate duce la confuzie și este bine să fiți atenți la acest aspect. În mod obișnuit, este recomandat să evitați ascunderea câmpurilor, iar dacă este necesar, să fiți conștienți de acest lucru și să folosiți cu atenție super pentru a accesa câmpurile din clasa părinte.

2. pentru a forța apelarea unei metode din cadrul unei clase părinte: 

super.<method_name>

3. pentru apelarea constructorului clasei părinte. Constructorii nu sunt membri, deci nu sunt moșteniți de subclase, dar constructorul superclasei poate fi invocat din subclasă folosind apelul: super([lista_argumente])

Exemplu: 

class Persoanaa{

protected String nume, prenume;

protected int virsta;

Persoanaa (String nume, String prenume, int virsta){

this.nume = nume;

this.prenume = prenume;

this.virsta = virsta;

}

void detalii() {

System.out.print("Nume "+nume+" \nPrenume "+ prenume+" \nVirsta "+virsta);

}}

class Elev extends Persoanaa{

private String adresa;

private double media;

Elev(String nume, String prenume, int virsta, String adresa, double media){

super(nume, prenume, virsta);

this.adresa = adresa;

this.media = media;

}

void detalii() {

super.detalii();

System.out.println(" \nAdresa "+adresa+" \nMedia "+ media);

}}

class Test_mostenire {

public static void main(String[] args) {

Elev e1 = new Elev("Creanga", "Ion", 16, "str. Sarmizegetusa 48", 10);

e1.detalii();

}}

Rețineți !

1. Apelul super() trebuie să fie prima instrucțiune din corpul constructorului subclasei.
2. Dacă constructorul subclasei nu va invoca explicit constructorul superclasei, compilatorul Java va însera automat un apel la constructorul clasei fără parametri.
3. Dacă superclasa nu are constructor fără argumente veți obține eroare de compilare.
4. O clasă declarată final nu poate fi extinsă.

Importanța moștenirii:
1. Moștenirea permite dezvoltatorilor să reutilizeze codul deja scris într-o clasă de bază, fără a-l rescrie în mod repetat în clasele derivate. Acest lucru duce la o eficiență sporită în dezvoltarea software-ului, deoarece codul poate fi scris și testat o singură dată.
2. Moștenirea permite extinderea funcționalității claselor de bază prin adăugarea de metode sau atribute noi în clasele derivate. Astfel, este ușor să adăugați funcționalități noi fără a afecta funcționalitatea existentă.
3. Moștenirea contribuie la organizarea și structurarea codului. Clasele de bază pot reprezenta concepte generale sau abstracte, iar clasele derivate pot să ofere implementări specifice sau detaliate ale acestor concepte.
4. Moștenirea facilitează implementarea polimorfismului, unde obiecte de tipuri diferite pot fi tratați în mod uniform. Acest lucru duce la o mai mare flexibilitate și modularitate în proiectare.
5. Prin intermediul moștenirii, modificările într-o clasă de bază pot avea impact în toate clasele derivate. Astfel, întreținerea și actualizarea codului pot fi mai ușoare, deoarece modificările trebuie făcute doar într-un singur loc.
6. Moștenirea reflectă relații de tip "este-un" între clase. De exemplu, dacă avem o clasă de bază "Animal" și o clasă derivată "Câine", putem spune că "Câinele este un Animal". 

În ansamblu, moștenirea în programare contribuie la creșterea eficienței, flexibilității și ușurinței în dezvoltarea și întreținerea software-ului. Dar...moștenirea o folosim doar când există o relație logică reală „este un”. 

Mulți începători o folosesc forțat, când de fapt ar fi mai corectă alte tipuri de relații despre care noi vom discuta. În proiecte reale, folosirea abuzivă a moștenirii duce deseori la ierarhii rigide și greu de întreținut.

Știați că...
Java 17 introduce câteva funcții noi și îmbunătățiri menite să îmbunătățească lizibilitatea codului, mentenața și securitatea? 

Una dintre cele mai notabile completări la Java 17 este introducerea claselor sealed care oferă mai mult control asupra ierarhiilor de clasă și ajută la aplicarea unei încapsulări mai puternice. Prin declararea unei clase ca sealed, dezvoltatorii pot specifica care clase au voie să o extindă. Acest lucru restricționează efectiv subclasele la un set predefinit, prevenind astfel extensiile neautorizate. Însă ... este suficient pentru această lecție .... vom discuta în altă postare această facilitate a limbajului. 

Dar dacă nu aveți răbdare ... 😍 ...pentru mai multe detalii accesați aici 👉 https://websparrow.org/java/java-17-sealed-classes 

Succes!

❤️

Relații între obiecte Java

Din definiția Programării Orientate spre Obiecte cunoaștem că acesta este un stil de programare în care programele sunt organizate ca şi colecții de obiecte ce cooperează între ele pentru a realiza funcțiile aplicației. Acestea obiecte cooperează între ele prin intermediul unor relații stabilite de programator.

Există mai multe tipuri de relații între obiecte, iar câteva dintre cele comune sunt:

1. Moștenire. Există între o superclasă și o subclasă, este tipul de relație ”is a” sau ”este un/o”. De exemplu: Angajatul este o Persoana, Ciinele este un Animal, SefDepartament este un Angajat.

Exemplu:

class Angajat{
private String nume;
private String adresa;
private int oreLucrate;

public Angajat(String nume, String adresa, int oreLucrate) {
this.nume = nume;
this.oreLucrate = oreLucrate;
this.adresa = adresa;
}
String getNume(){return nume;}
public void setNume(String nume) { this.nume = nume; }

String getAdresa(){return adresa;}
public void setAdresa(String adresa) { this.adresa = adresa; }

public void setOreLucrate(int oreLucrate) { this.oreLucrate = oreLucrate; }
int getOre(){return oreLucrate;}

public int salariu() { return oreLucrate*20; }
}

class SefDepartament extends Angajat {
public SefDepartament(String nume, String adresa, int oreLucrate) {
super(nume, adresa,oreLucrate); }
public int salariuSef() { return salariu()+1000; }
}

class Test{
public static void main(String[] args) {
System.out.println("---------------------------------------------------");
SefDepartament s = new SefDepartament("Decebal Dumitru", "or. Chisinau", 20);
System.out.println(s.getNume() + " "+ s.getAdresa()+" "+s.getOre()+" "+s.salariuSef());
System.out.println("---------------------------------------------------");
Angajat a = new Angajat("Musteata Victoria", "or. Chisinau", 20);
System.out.println(a.getNume() + " "+ a.getAdresa()+" "+a.getOre()+" "+a.salariu());
}}

2. Agregare. Există între două clase în care nu este relație de moștenire, este tipul de relație ”has a” sau ”are un /o”. 

Are la bază următorul principiu: o clasă A, face referire la unul sau mai multe obiecte ale unei alte clase B, o modificare produsă în clasa A nu afectează existența instanțelor clasei B. 

Un exemplu de astfel de relație servește relația între clasele Universitate și Student. O universitate poate avea mai mulți studenți, dar studenții pot exista și în afara universității. Un alt exemplu sunt clasele Proiect și MembruEchipa. Deși membrii echipei sunt asociați cu proiectul, aceștia pot exista independent și pot face parte din alte proiecte sau activități. 

Deci o astfel de interacțiune între obiectele unei clase o numim relație de agregare în contextul domeniului IT.

Exemplu:
class Universitate {

private String denumire;
private Student s;

public Universitate (String denumire, Student l) {
this.denumire = denumire;
s = l;
}

public void afiseazaDetalii(){
System.out.println("Denumirea universitatii: "+denumire);
System.out.println("Elevi: ");
System.out.println(s.getNume() + " " + s.getGrupa());
}}

class Student {
private String nume;
private String grupa;

public String getNume() {return nume; }
public void setNume(String nume){ this.nume = nume; }

public String getGrupa() { return grupa;}
public void setGrupa(String grupa){ this.grupa = grupa; }

public Student(String nume, String grupa) {
this.nume = nume;
this.grupa = grupa;
}}

class Test{
public static void main(String[] args) {
Student x = new Student("Victoria","I5413");
Universitate p = new Universitate ("Digitalizare", x);
p.afiseazaDetalii();
}}

Exemplu:
class Universitate {
private String denumire;
private Student [] lista = new Student[2];

public Universitate (String denumire, Student [] l) {
this.denumire = denumire;
lista = l;
}

public void afiseazaDetalii(){
System.out.println("Denumirea universitatii >>>> "+denumire);
System.out.println("Are elevii: ");
for (int i=0; i<lista.length; i++)
System.out.println(lista[i].getNume() + " " + lista[i].getGrupa()); }
}

class Student {
private String nume;
private String grupa;

public String getNume() {return nume; }
public void setNume(String nume) {
this.nume = nume;
}

public String getGrupa() { return grupa;}
public void setGrupa(String grupa) {
this.grupa = grupa;
}

public Student(String nume, String grupa) {
this.nume = nume;
this.grupa = grupa;
}}

class Test{
public static void main(String[] args) {
Student [] lista = new Student[2];
lista[0] = new Student("Victoria","I5413");
lista[1] = new Student("Mihai","I5412");

Universitate p = new Universitate ("Digitalizare", lista);
p.afiseazaDetalii();
}}

3. Compoziție. Similară agregării, dar cu o legătură mai strânsă. O clasă A este compusă din unul sau mai multe obiecte ale unei alte clase B. Dacă clasa A încetează să existe, și clasa B încetează, de asemenea, să existe. Un exemplu de astfel de relație este:
- relația între clasele Casa și Dormitor, dormitorul nu există separat, el face parte dintr-o casă, respectiv dacă dispare casa nu există nici dormitorul.
- relația dintre clasele Laptop și Procesor. Acest component, procesorul, nu există independent de laptop, indicând astfel o relație de compoziție.
- relația între clasele Masina și Motor. Mașina are un motor, cu alte cuvinte motorul este o componentă a mașinii. Dacă mașina va fi distrusă, motorul va fi distrus la fel. Ciclul de viață pentru obiectul Motor este dependent total de ciclul de viață al obiectului Masina:

class Motor {
private String tip;
private int caiPutere;

Motor(String tip, int caiPutere) {
this.tip = tip;
this.caiPutere = caiPutere;
}

public String getTip() { return tip; }

public void setTip(String tip){this.tip = tip; }

public int getPutere() {return caiPutere; }
public void setPutere(int caiPutere){
this.caiPutere = caiPutere;
}}

class Masina {
private String nume;
private Motor motor;

public Masina(String nume) {
this.nume= nume;
this.motor = new Motor("Motorina", 300);
}
public String getNume() { return nume; }
public Motor getMotor() { return motor; }
}

class TestMasina{
public static void main(String[] args) {
Masina masina = new Masina("BMW");

System.out.println("Denumire masina: " +masina .getNume()+ "\n" +"Tip motor: " +masina.getMotor().getTip()+ "\n" + "Cai putere: " +masina.getMotor().getPutere());
}}

Următorul tabel prezintă diferențele între cele trei tipuri de relații între obiecte în context POO:

Caracteristică	Agregare	Compoziție	Moștenire
Definiție	O relație între două clase în care unul dintre obiecte este parte a altuia, dar poate exista independent.	O relație între două clase în care un obiect este format din alt obiect și nu poate exista independent.	O relație între două clase în care o clasă derivată (subclasă) preia caracteristicile și comportamentul unei clase de bază (superclasă).
Dependența ciclului de viață	Obiectul "parte" poate exista independent de obiectul "întreg".	Obiectul "parte" este de obicei creat și distrus împreună cu obiectul "întreg".	O subclasă poate exista independent de superclasă, dar se bazează pe moștenire pentru a împărți caracteristicile superclasei.
Reprezentare	O clasă poate conține o referință la altă clasă, dar fără a controla durata de viață a obiectelor asociate.	O clasă conține direct un alt obiect și controlează durata de viață a obiectelor asociate.	Subclasă extinde sau specializează superclasă, moștenind și adăugând funcționalități noi.
Flexibilitate	Mai flexibilă, deoarece obiectul "parte" poate exista independent și poate fi partajat între mai multe obiecte "întreg".	Mai rigidă, deoarece obiectul "parte" este strâns legat de obiectul "întreg" și nu poate fi partajat ușor între alte obiecte.	Oferă extensibilitate prin adăugarea și modificarea funcționalității în subclasă, dar poate duce la o dependență puternică între subclasă și superclasă.
Exemplu	O universitate are mulți studenți.	Un calculator are o placă de bază, ce are componente precum procesor, memorie etc.	O clasă "Cercetator" derivată dintr-o clasă "Angajat", moștenind atribuțiile și metodele comune angajaților.

Aceste relații sunt foarte importante în programarea orientată pe obiect pentru a crea structuri flexibile, ușor de înțeles și de întreținut. Este important să se adapteze aceste concepte la contextul specific al aplicației sau sistemului pe care îl dezvoltați. Ele facilitează modularitatea, reutilizarea codului și gestionarea complexității în dezvoltarea software-ului.

Succes!

❤️

Constructori în limbajul JAVA

Constructorii unei clase sunt metode speciale care au același nume ca și clasa, nu returnează nici o valoare și sunt folosiți pentru inițializarea obiectelor acelei clase în momentul instanțierii acestora.

Rețineți!

• De fiecare dată când este creat un obiect este apelat un constructor;

Elev elev1 = new Elev();

• Corpul constructorului este format din instrucțiuni care se execută la crearea unui nou obiect al clasei respective;

• Fiecare clasă Java are cel puțin un constructor;

• Dacă nu există declarați în mod explicit alți constructori atunci compilatorul va oferi un constructor implicit cu 0 argumente, care va avea forma:

public numeClasa(){

}

• Constructorii au același nume (case-sensitive) ca și clasa acestuia;

• Constructorii NU au tip de return. Putem avea definite metode cu același nume ca și clasa însă NU sunt constructori, de exemplu:

class Masina{

   int nrUsi;

   void Masina(int x){

        nrUsi = x;

    }}

public class Main{

    public static void main(String[] args) {

        Masina m = new Masina(); //constructor implicit

        m.Masina(4);

        System.out.println("Masina are"+ m.nrUsi + " usi!");

}}

• Constructorii pot avea orice nume de argumente şi o clasă poate avea orice număr de constructori;

• Dacă specificăm explicit un constructor atunci compilatorul va anula constructorul implicit, nu îl va mai genera, de aceea va trebui și pe acesta să îl definim;

• Constructorul NU poate fi static, final sau abstract;

• Pentru a apela un constructor al superclasei se folosi cuvântul cheie super.

• Constructorii NU pot fi moșteniți.

În Java, există mai multe tipuri de constructori, în funcție de modul în care aceștia sunt declarați și folosiți:

a) Constructor implicit – este generat automat de compilator în cazul în care programatorul nu a definit un constructor. Acesta nu conține cod în interior. Așa tip de constructor nu îl veți găsi în cod deoarece acesta este creat în momentul compilării și inclus în fișierul cu extensia .class:

De exemplu:

class Masina{

    int nrUsi;

}

public class Main{

 public static void main(String[] args) {

   Masina m = new Masina(); //constructor implicit

    m.nrUsi = 4;

System.out.println("Masina are "+ m.nrUsi + " usi!");

}}

Notă! În cazul în care veți declara un constructor, constructorul default NU va fi generat.

class Masina{

    int nrUsi;

    Masina(int x){

        nrUsi = x;

    }

}

public class Main{

    public static void main(String[] args) {

        Masina m = new Masina(); //eroare

        m.nrUsi = 4;

        System.out.println("Masina: culoare "+ m.nrUsi + " usi!");

}}

b) Constructor fără parametri – este scris de către programator și nu conține argumente, mai este numit constructor no-arg. Semnătura este aceeași cu cea a constructorului implicit, însă corpul poate avea orice cod, spre deosebire de constructorul implicit, unde corpul constructorului este gol.

class Masina{

    int nrUsi;

    Masina(){ System.out.println("Acesta NU este constructor implicit!");

    }

}

public class Main{

    public static void main(String[] args) {

        Masina m = new Masina();

        m.nrUsi = 4;

        System.out.println("Masina are"+ m.nrUsi + " usi!");

 }}

c) Constructor parametrizat – este scris de programator și poate conține orice număr de parametri sau argumente. Se utilizează pentru a inițializa datele unui obiect.

class Masina{

  int nrUsi;

  Masina(int x){

    nrUsi = x;

    }

}

public class Main{

  public static void main(String[] args) {

    Masina m = new Masina(4);

    System.out.println("Masina are " + m.nrUsi + " usi!");

  }}

Este posibil ca în interiorul clasei să fie folosită variabila predefinită this care face referire la obiectul curent al clasei, mai jos vom explica și alte aspecte legate de această variabilă. Dar în contextul exemplului de mai sus observăm că argumentul costructorului are un identificator diferit de atributul clasei, dar sunt cazuri în care acestea pot avea același identificator.
Pentru a diferenția atributul clasei de argumentul constructorului se folosește this, ca în exemplul de mai jos:

class Masina{

    int nrUsi;

    Masina(int nrUsi){

        this.nrUsi = nrUsi;

    }

}

public class Main{

    public static void main(String[] args) {

        Masina m = new Masina(4);

        System.out.println("Masina are " + m.nrUsi + " usi!");

  }}

Deci, la atributul clasei i se atribuie argumentul constructorului, și nu invers!!!!


În cadrul unei clase pot fi definiți constructori cu listă diferită de parametri.
De exemplu:

class Masina{
    int nrUsi;
    String culoare;
    String marca;
    Masina(){
    }
    Masina(int nrUsi){
        this.nrUsi = nrUsi;
    }
    Masina(String culoare){
        this.culoare = culoare;
    }
    Masina(int nrUsi, String culoare,String marca){
        this.nrUsi = nrUsi;
        this.culoare = culoare;
        this.marca = marca;
    }
}
public class Main{
    public static void main(String[] args) {
        Masina m1 = new Masina(4);
        System.out.println("Masina 1 are " + m1.nrUsi + " usi si culoare "+ m1.culoare);
        Masina m2 = new Masina("rosie");
        System.out.println("Masina 2 are " + m2.nrUsi + " usi si culoare "+ m2.culoare);
        Masina m3 = new Masina(2,"rosie","BMW");
        System.out.println("Masina 3 are " + m3.nrUsi + " usi si culoare "+ m3.culoare +
                  " marca"+m3.marca);
    }}

Așa tip de constructori se numesc supraîncărcați. Fiți atenți în utilizarea acestor constructori, fiecare are destinația sa, primul va inițializa doar numărul de uși restul atributelor clasei vor fi inițializate cu valori default după cum urmează: atributele de tip String vor fi inițializate cu valoarea null, cele de tip întreg cu valoarea 0, cele boolean cu valoarea false, iar cele reale cu valoarea 0.0.

Variabila predefinită this are în linii generale trei utilizări în cadrul clasei și anume:

a) în interiorul constructorului, pentru a face diferență dintre variabilele instanță și cele locale (de metodă) dacă acestea au aceeași denumire sau pentru a referi obiectul construit.

De exemplu:

b) atunci când o referință la obiectul receptor trebuie transmisă ca parametru la apelul unei alte metode. 

De exemplu:

c) pentru a apela un constructor din interiorul aceleiași clase:





Dacă ați ajuns până aici, vă invit să urmăriți următorul spot video relevant temei curente 

Succes!

❤️