Laboratorul 3: Design Avansat de Clase

• Autori: Ștefan Cocioran , Florian-Luis Micu , Sorina-Anamaria Buf
• Data publicării: 20.10.2025
• Data ultimei modificări: 25.10.2025
  • clarificări pentru gestionarea memoriei statice și VTables.
  • schimbat tipul de return în Lazy Evaluation.
  • clarificări pentru specificatorii de acces în contextul moștenirii.

Scopul acestui laborator este introducerea studenților în concepte mai avansate privind proiectarea claselor în Java, precum și familiarizarea acestora cu mecanismele de agregare, moștenire și polimorfism, alături de modul în care acestea pot fi utilizate pentru refolosirea și extinderea cu ușurință a codului existent.

Aspectele urmărite sunt:

• înțelegerea conceptelor de agregare și compunere.
• utilizarea corectă a moștenirii pentru refolosirea codului.
• înțelegerea diferenței între moștenire și agregare.
• exersarea conversiilor upcasting și downcasting.
• implementarea polimorfismului în Java.
• diferența dintre overriding și overloading.
• întrebuințarea cuvântului cheie super.

Aspectele bonus urmărite sunt:

• Problema diamantului.
• Diferența dintre getClass() și instanceof.
• Organizarea memoriei pentru moștenire în Java.

În programarea orientată pe obiecte, agregarea și compunerea sunt două tipuri de relații has-a (un obiect are alt obiect). Aceste relații apar atunci când o clasă conține o referință către alt obiect.

Un obiect conținut poate fi inițializat în mai multe moduri:

1. În momentul declarării câmpului (Eager initialization)

   class Car {
      private Engine engine = new Engine();
    
      ...
   }

2. Într-un bloc de inițializare

   class Car {
      private Engine engine;
    
      // Bloc de inițializare - se execută înainte de constructor
      { engine = new Engine(); }
    
      public Car() {
         ...
      }
    
      ...
   }

3. În constructor

   class Car {
      private Engine engine;
    
      Car(Engine engine) {
         this.engine = engine;
      }
      ...
   }

4. Doar când este necesar (Lazy initialization)

   class Car {
      private Engine engine;
    
      public Engine initializeEngine() {
         if (engine == null) {
            engine = new Engine();
         }
    
         return engine;
      }
   }

Agregarea reprezintă o relație slabă între obiecte. Obiectul container primește dependența din exterior, dar nu îi controlează ciclul de viață. Obiectul conținut poate exista independent.

Exemplu real: Un departament are angajați, dar angajații pot exista și fără acel departament.

public class Department {
    private String name;
    private Employee[] employees;
 
    public Department(String name, Employee[] employees) {
        this.name = name;
        this.employees = employees; // dependența vine din exterior → agregare
    }
}

Compunerea reprezintă o relație puternică între obiecte. Obiectul container creează și gestionează obiectele interne. Dacă obiectul container este distrus, obiectele conținute dispar și ele.

Exemplu real: O casă are camere. Camerele nu au sens să existe fără casă.

public class House {
    private Room[] rooms;
 
    public House(int numberOfRooms) {
        rooms = new Room[numberOfRooms]; // obiectele sunt create în interior → compunere
        for (int i = 0; i < numberOfRooms; i++) {
            rooms[i] = new Room("Camera " + (i + 1));
        }
    }
}

Moștenirea, numită și derivare, este un mecanism care permite refolosirea și extinderea codului unei clase existente.

• Clasa existentă: clasa-părinte / super-clasă / base class
• Clasa care extinde: clasa-copil / sub-clasă / derived class

Clasa copil poate prelua funcționalitatea clasei părinte și poate adăuga sau modifica comportamente, creând versiuni specializate ale claselor de bază.

Drept urmare, putem spune că prin moștenire clasa copil preia toții membrii (metodele și câmpurile) clasei părinte pentru a îi extinde sau folosi direct.

Avantajele principale ale moștenirii sunt:

• Reutilizarea codului
  • Clasa copil moștenește metodele și variabilele clasei părinte, deci nu trebuie să rescriem codul existent.
• Specializare și extensibilitate
  • Permite să creem clase “specializate” care extind comportamentul clasei de bază, adăugând sau modificând funcționalități.
• Structurare clară a ierarhiilor
  • Relațiile „is-a” (de exemplu, Dog is a Animal) oferă un mod intuitiv de a organiza clasele.
• Incremental development
  • Dezvoltarea se poate face pas cu pas: codul deja testat rămâne stabil, iar noile funcționalități sunt adăugate treptat.
• Polimorfism
  • Clasa copil poate fi tratată ca un obiect al clasei părinte, permițând apeluri generice și reutilizarea codului în funcții care lucrează cu clasa de bază.

În Java, folosim cuvântul cheie extends:

class Cat extends Mammal { ... }

Prin folosirea moștenirii putem crea lanțuri de moștenire. De exemplu să presupunem că avem clasa Cat care moștenește Mammal care moștenește la rândul ei clasa Animal:

Animal (clasă de bază)
  ↓
Mammal (clasă copil pentru Animal)
  ↓
Cat (clasă copil pentru Mammal)

Într-un proiect Java, aceste moșteniri multiple ar arăta astfel:

Animal.java

class Animal {
    float weight = 10.2f;
 
    void eat() { System.out.println("The animal is eating"); }
    void sleep() { System.out.println("The animal is sleeping"); }
}

Mammal.java

class Mammal extends Animal {
    int heartRate = 90;
 
    void breathe() { System.out.println("The mammal is breathing"); }
}

Cat.java

public class Cat extends Mammal {
    boolean longHair = true;
 
    void purr() { System.out.println("The cat is purring"); }
}

Main.java

class Main {
   public static void Main(String args[]) {
      // Se pot accesa toate metodele și câmpurile moștenite de către Cat
      Cat cat = new Cat();
      cat.purr();
      cat.breathe();
      cat.eat();
      cat.sleep();
      System.out.println("Cat weight: " + cat.weight);
 
      // Se pot accesa toate metodele și câmpurile moștenite de către Mammal
      Mammal mammal = new Mammal();
      mammal.breathe();
      mammal.eat();
      mammal.sleep();
      mammal.weight = 14.5f;
      System.out.println("Mammal weight: " + mammal.weight);
 
      // Se pot accesa doar metodele și câmpurile proprii ale clasei Animal pentru că se oprește lanțul de moștenire
      Animal animal = new Animal();
      animal.eat();
      animal.sleep();
      animal.weight = 45.3f;
      System.out.println("Animal weight: " + animal.weight);
   }
}

Reamintim specificatorii de acces prezentați în laboratorul trecut în contextul moștenirii membrilor:

Constructorii nu se moștenesc, însă inițializarea obiectelor urmează un lanț logic: mai întâi se construiesc membrii clasei părinte, apoi cei ai subclasei, până la clasa curentă.

Pentru exemplul de mai sus inițializarea s-ar întâmpla astfel:

Animal
  ↓
Mammal
  ↓
Cat

class Mammal extends Animal {
   ...
 
   public Mammal() {
      // Nu avem erori pentru că "Animal" și membrii lui au fost inițializați deja
      System.out.println("Animal inherited field value is: " + weight);
   }
 
   ...
}

Keyword-ul super este folosit în constructorul unei subclase pentru a inițializa partea moștenită a obiectului și pentru a accesa membri (metode sau variabile) ai clasei părinte.

class Parent {
    int value;
    Parent(int x) {
        value = x;
        System.out.println("Parent constructor");
    }
}
 
class Child extends Parent {
    Child(int x) {
        super(x); // apelul constructorului părinte trebuie să fie prima linie
        System.out.println("Child constructor, value = " + value);
    }
}

Pentru a asigura ordinea inițializării pe lanțul de moștenire, instrucțiunea super() sau super(…) trebuie să fie prima instrucțiune din fiecare constructor definit în clasa copil.

Keyword-ul super poate fi folosit și pentru accesul membrilor din părinte. Acest lucru este util când vrem să accesăm membrii ascunși sau suprascriși.

class Parent {
    int value = 100;
 
    void show() {
        System.out.println("Parent value: " + value);
    }
}
 
class Child extends Parent {
    int value = 200; // shadowing
 
    void show() {
        System.out.println("Child value: " + value);
        System.out.println("Parent value via super: " + super.value); // accesăm membrul ascuns
    }
}

În Java, o clasă poate fi declarată folosind cuvântul cheie final, ceea ce înseamnă că nu mai poate fi moștenită. Se folosește atunci când vrem să blocăm moștenirea pentru a proteja implementarea sau pentru motive de securitate/perfomanță (optimizări făcute de JVM).

public final class MathUtils {
    public static int square(int x) {
        return x * x;
    }
}

Încercarea de a moșteni o clasă final produce eroare de compilare:

class MyMath extends MathUtils { }  // Eroare: "cannot inherit from final class"

În general, întrebarea has-a sau is-a este suficientă pentru a determina tipul de relație, însă există obiecte pentru care relația nu poate fi stabilită ușor folosind această întrebare.

De exemplu, obiectele Button și Toolbar:

• Toolbar poate conține mai multe Button-uri → has-a (agregare)
• Dar putem spune și că Toolbar e un buton specializat → is-a (moștenire)

Pentru aceste situații este bine să folosim următoarea distincție:

• Agregare/Compunere: când vrem să folosim funcționalitatea unei clase în interiorul altei clase fără a-i expune toate metodele.
• Moștenire: când vrem să creăm o clasă specializată a unei clase existente, reutilizând și extinzând comportamentul acesteia.

În Java, upcasting și downcasting sunt operații care permit conversia între tipuri în ierarhia de moștenire a claselor.

Upcasting-ul este conversia unui obiect de tip derivat într-un obiect de tipul clasei de bază și are următoarele proprietăți:

• se face automat și nu necesită declarație explicită.
• instanța rămâne aceeași, doar referința este văzută ca tipul superior.
• permite apelarea doar a metodelor definite în clasa de bază.

Pentru ierarhia:

Animal.java

public class Animal {
   public void makeSound() {
      System.out.println("Animal makes a sound!");
   }
 
   public void eat() {
      System.out.println("Animal eats!");
   }
}

Dog.java

public class Dog extends Animal {
   public void wagTail() {
      System.out.println("Dog moves tail!");
   }
}

Avem exemplul de upcasting:

Main.java

public class Main {
   public static void main(String[] args) {
      Dog myDog = new Dog();
      Animal animal = myDog; // Upcasting automat
 
      Animal anotherAnimal = new Dog(); // Upcasting automat
 
      animal.makeSound(); // Funcționează
      animal.eat();       // Funcționează
 
      // EROARE de compilare - metoda "wagTail()" nu există în referința de tip "Animal"
      // animal.wagTail(); 
   }
}

Upcasting-ul permite tratarea diferitelor subclase într-un mod uniform.

De exemplu dacă avem clasa Shelter unde vrem să apelăm metoda eat() a fiecărui animal definit ar trebui să avem următoarea structură:

Shelter.java

public class Shelter {
   public void feedAnimal(Dog dog) {
      dog.eat();
   }
 
   public void feedAnimal(Cat cat) {
      cat.eat();
   }
 
   public void feedAnimal(Rabbit rabbit) {
      rabbit.eat();
   }
}

Main.java

public class Main {
   public static void main(String[] args) {
      Shelter shelter = new Shelter();
      Dog dog = new Dog();
      Cat cat = new Cat();
      Rabbit rabbit = new Rabbit();
 
      // Overloading
      shelter.feedAnimal(dog);
      shelter.feedAnimal(cat);
      shelter.feedAnimal(rabbit);
   }
}

Prin folosirea mecanismului de overloading putem apela metoda feedAnimal() pentru fiecare animal, doar că această abordare nu este scalabilă.

Putem folosi în schimb mecanismul de upcasting pentru a scurta semnificativ codul:

Shelter.java

public class Shelter {
   public void feedAnimal(Animal animal) {
      animal.eat();
   }
}

Main.java

public class Main {
   public static void main(String[] args) {
      Shelter shelter = new Shelter();
      Dog dog = new Dog();
      Cat cat = new Cat();
      Rabbit rabbit = new Rabbit();
 
      // Upcast la Animal
      shelter.feedAnimal(dog);
      shelter.feedAnimal(cat);
      shelter.feedAnimal(rabbit);
   }
}

Prin upcasting, convertim fiecare tip copil în tipul părinte Animal la pasarea în metodă, deoarece orice Dog/Cat/Rabbit este și un Animal.

Downcasting-ul este mecanismul prin care se face conversia explicită de la clasa de bază la o clasă derivată și are următoarele proprietăți:

• trebuie explicit declarat de programator.
• este sigur doar dacă obiectul este într-adevăr instanță a clasei derivate.
• folosim adesea operatorul instanceof pentru a verifica tipul înainte.

Pentru ierarhia de clase de mai sus avem exemplul:

Animal animal = new Dog(); // Upcasting
 
if (animal instanceof Dog) {
    ((Dog) animal).wagTail(); // Downcasting explicit
}

Downcasting-ul permite accesarea funcționalităților specifice subclasei atunci când avem o referință de tipul clasei părinte (upcast). Este necesar atunci când vrem să folosim metode sau câmpuri care nu sunt definite în clasa de bază, dar există în subclasa reală.

Fără downcast, nu am fi putu accesa metoda wagTail() din exemplul de mai sus.

Folosirea instanceof este considerată bad practice, deoarece:

• face codul repetitiv și greu de întreținut.
• necesită modificări ori de câte ori se adaugă o subclasă nouă.
• reduce lizibilitatea și încalcă principiul Open-Closed.

Pentru a rezolva această problemă putem folosi mecanismul de suprascriere prezentat în continuare.

Polimorfismul reprezintă abilitatea unui obiect să se comporte ca un alt obiect din ierarhia de moștenire. Este strâns legat de suprascrierea metodelor și permite tratamentul uniform al obiectelor de tipuri diferite printr-o interfață comună sau o clasă de bază.

Există două tipuri principale:

• Polimorfism dinamic (runtime): prin suprascrierea metodelor (override).
• Polimorfism static (compile-time): prin supraîncărcarea metodelor (overload).

Suprascrierea se referă la redefinirea unei metode moștenite pentru a schimba comportamentul acesteia în subclasa curentă.

Reguli de bază pentru suprascriere:

• Metoda suprascrisă trebuie să aibă aceeași semnătură și un tip de return compatibil.
  • Tip de return compatibil:
    • Pentru primitive: trebuie să folosiți același tip.
    • Pentru obiecte: trebuie să folosiți același tip sau un subtip al tipului de return din clasa părinte.
• Nu se pot suprascrie metode statice, final sau constructorii.
• Specificatorul de acces nu poate fi mai restrictiv decât cel al metodei din clasa părinte.

class Animal {
    public void makeSound() { System.out.println("Animal makes sound"); }
    public void eat() { System.out.println("Animal eating"); }
    public final void die() { System.out.println("Dying!"); }
}
 
class Dog extends Animal {
    // Suprascriem metoda din părinte
    @Override
    public void makeSound() { System.out.println("Bark!"); }
 
    public void wagTail() { System.out.println("Dog wags tail"); } // Nu suprascrie nici o metodă
}

Este important să înțelegem că suprascrierea nu ne garantează că metoda aleasă va fi întotdeauna cea din copil. Deoarece JVM se uită la tipul instanței și nu la referință, putem avea mai multe comportamente definite:

public class Main {
   public static void main(String[] args) {
      Animal a = new Animal(); // tipul instanței lui "a" este "Animal"
      a.makeSound(); // se va apela "makeSound()" din "Animal"
 
      Dog d = new Dog(); // tipul instanței lui "d" este "Dog"
      d.makeSound(); // se va apela "makeSound()" din "Dog"
 
      Animal anotherAnimal = new Dog(); // tipul instanței lui "anotherAnimal" este "Dog"
      anotherAnimal.makeSound(); // se va apela "makeSound()" din "Dog"
 
      a = new Dog(); // am schimbat instanța în "Dog"
      a.makeSound(); // acum se va apela "makeSound()" din "Dog"
   }
}

În Java, o metodă declarată folosind cuvântul cheie final nu poate fi suprascrisă în nicio subclasă. Aceasta este o modalitate de a proteja comportamentul unei metode astfel încât să nu fie modificat prin moștenire.

class Animal {
    public final void die() {
        System.out.println("Animal died.");
    }
}
 
class Dog extends Animal {
    // Eroare de compilare: "cannot override final method"
    @Override
    public void die() {
        System.out.println("Dog died.");
    }
}

Reamintim că supraîncărcarea este mecanismul în care putem defini mai multe metode cu același nume în aceeași clasă, dar cu parametri diferiți (număr sau tip).

Pentru mai multe detalii despre supraîncărcare reluați laboratorul 2 sau consultați imaginea de mai jos.

În afară de primitive, totul în Java este un obiect, iar acest lucru este ilustrat prin faptul că orice clasă moștenește clasa Object.

Deci ierarhia de moștenire pentru animale din exemplul anterior nu era chiar completă, dar o putem corecta astfel:

Object (clasa moștenită de toate obiectele)
  ↓
Animal (clasă de bază definită de programator)
  ↓
Mammal (clasă copil pentru Animal)
  ↓
Cat (clasă copil pentru Mammal)

Motivul pentru care există clasa Object este să ofere un set minim și comun de comportamente tuturor obiectelor, indiferent ce reprezintă ele. Astfel, orice instanță în Java are automat metode de bază precum:

• toString() – descrierea obiectului ca text
• equals(Object o) – comparație logică
• hashCode() – folosit în colecții (HashMap, HashSet etc.)
• getClass() – află tipul obiectului la runtime
• clone() – copiere superficială
• finalize() – cleanup (deprecated)

Cu ajutorul metodei toString(), care este deja implementată în mod predefinit pentru fiecare clasă în Java, putem obține o reprezentare a unui obiect ca String.

În cazurile claselor implementate de utilizator, este de recomandat să suprascriem metoda toString() pentru a afișa detaliile de interes ale clasei.

Un exemplu de implementare a metodei toString():

Student.java

public class Student {
    private String name;
    private int averageGrade;
 
    public Student(String name, int averageGrade) {
        this.name = name;
        this.averageGrade = averageGrade;
    }
 
 
    public String toString() {
        return "Nume student: " + name + "\nMedia studentului: " + averageGrade;
    }
}

Folosirea metodei toString():

Student st1 = new Student("Ilie Popescu", 5);
 
// Nu trebuie să specificăm "st1.toString()", compilatorul va adăuga automat apelul de metodă
System.out.println(st1);

Nume student: Ilie Popescu
Media studentului: 5

Metoda equals(Object o) este folosită pentru a compara corect două obiecte. Dacă am folosi operatorul == pentru verificarea egalității am ajunge să verificăm de fapt egalitatea referințelor (adică a adreselor de memorie). Prin metoda equals putem verifica dacă două obiecte diferite au aceeași stare internă conform unor criterii specifice.

Una din problemele cele mai des întâlnite este suprascrierea corectă a metodei equals. La fel ca metoda toString(), această metodă are un comportament default în care se verifică doar dacă referințele sunt egale.

class Person {
    String name;
}
 
class Main {
   public static void main(String[] args) {
      Person p1 = new Person();
      Person p2 = new Person();
 
      System.out.println(p1.equals(p2)); // false, pentru că p1 și p2 sunt obiecte diferite
   }
}

Mai jos putem vedea un exemplu de suprascriere incorectă a acestei metode.

Car.java

public class Car {
    private String name;
    private int horsePower;
    private int year;
 
    public Car(String name, int horsePower, int year) {
        this.name = name;
        this.horsePower = horsePower;
        this.year = year;
    }
 
    public boolean equals(Car c) {
        System.out.println("Car");
        return true;
    }
 
    public boolean equals(Object o) {
        System.out.println("Object");
        return false;
    }
}

Dacia.java

public class Dacia extends Car {
   ...
}

Prima metodă este o supraîncărcare a metodei equals iar a doua metodă este suprascrierea metodei equals.

Car a = new Car();
Dacia b = new Dacia();
int c = 10;
 
a.equals(a); // afișează Car
a.equals(b); // afișează Car deoarece se face upcasting de la Dacia la Car
a.equals(c); // afișează Object deoarece se face upcasting de la Int la Object

Problema care se poate observa este că putem pasa ca argumente metodei equals si tipuri de date diferite de Car, lucru ce ar putea arunca excepții de cast sau când vrem să accesăm anumite proprietăți din instanță. Mai jos este modul corect de a suprascrie metoda equals.

public class Car {
    private String name;
    private int horsePower;
    private int year;
 
    public Car(String name, int horsePower, int year) {
        this.name = name;
        this.horsePower = horsePower;
        this.year = year;
    }
 
    @Override
    public boolean equals(Object o) {
        // Verificăm dacă obiectul o este de tipul "Car"
        if (!(o instanceof Car car)) return false;
 
        // Verificăm câmpurile claselor să fie identice
        return horsePower == car.horsePower && year == car.year && Objects.equals(name, car.name);
    }
}

De reținut că folosirea instanceof nu este recomandată, însă în acest caz este singurul mod prin care ne putem asigura ca instanța de obiect trimisă metodei este de tip Car. Se poate folosi și metoda getClass() însă nici aceasta nu este recomandată din aceleași motive.

class Animal {}
 
class Dog extends Animal {}
 
class Main {
   public static void main(String[] args) {
      Animal a = new Animal();
      Dog d = new Dog();
 
      System.out.println(a.getClass() == d.getClass()); // false
 
      System.out.println(a instanceof Animal); // true
      System.out.println(d instanceof Animal); // true
      System.out.println(d instanceof Dog);    // true
      System.out.println(a instanceof Dog);    // false
   }
}

Keyword-ul super poate fi folosit de Java în clasele copil pentru a accesa metoda originală din clasa părinte atunci când metoda este suprascrisă.

class Parent {
    void sayHello() {
        System.out.println("Hello from Parent");
    }
}
 
class Child extends Parent {
    @Override
    void sayHello() {
        super.sayHello(); // apelăm metoda din părinte
        System.out.println("Hello from Child");
    }
}

Hello from Parent
Hello from Child

Când rulează o aplicație Java, memoria este împărțită în mai multe zone principale:

Când o clasă este încărcată de JVM, metainformațiile ei sunt puse în Metaspace:

• Numele clasei
• Lista metodelor
• Lista câmpurilor
• Informații despre moștenire (superclass)
• VTable (Virtual Method Table)
• Variabile și metode statice

VTable este o tabelă internă introdusă de JVM pentru a face posibil polimorfismul dinamic.

class Animal { 
   void makeSound() { 
      System.out.println("generic"); 
   } 
 
   static void info() { 
      System.out.println("Animal class"); 
   } 
}
 
class Dog extends Animal {
   @Override
   void makeSound() {
      System.out.println("woof");
   }
 
   static void info() { 
      System.out.println("Dog class"); 
   }
}

Când se încarcă clasele, JVM construiește două VTables în Metaspace, doar pentru metodele non-statice:

Animal vtable: 
- makeSound() -> Animal.makeSound 
 
Dog vtable:
- makeSound() -> Dog.makeSound (override)

Animal a = new Dog(); // upcast a.makeSound(); // JVM folosește vtable din Metaspace → Dog.makeSound
 
Animal.info(); // apelează Animal.info() din Metaspace
Dog.info(); // apelează Dog.info() din Metaspace

Metodele static aparțin clasei, nu obiectelor, deci JVM nu are motiv să le caute într-un VTable la runtime. Ele sunt apelate direct prin numele clasei, nu prin instanță.

Apelurile către metode static sunt rezolvate folosind Constant Pool, o zonă de memorie care se află tot în Metaspace și care este asociată fiecărei clase care conține referințe simbolice către metode, câmpuri și clase.

• Intrările din Constant Pool sunt folosite pentru a localiza metodele static în Metaspace, unde este stocată logica clasei.
• La apel, invokestatic citește adresa metodei direct din Constant Pool, fără polimorfism, fără VTable.

• Heap = locul în care trăiesc obiectele.
• Stack = ține referințele către ele.
• Metaspace = știe ce este fiecare obiect, ce metode are, inclusiv variabile și metode statice, prin vtables.
• Constant Pool = stocat tot în Metaspace; conține literaluri, referințe simbolice către clase, metode și câmpuri, folosit de JVM pentru rezoluție dinamică și apeluri de metode.
• Upcasting-ul funcționează fără probleme pentru că JVM știe din Metaspace ce este obiectul real.
• Downcasting-ul se verifică la runtime tot cu ajutorul informațiilor din Metaspace.

Relații între obiecte:

• Agregare - has a
• Moștenire - is a

Upcasting:

• convertire copil ⇒ părinte
• realizată automat

Downcasting:

• convertire părinte ⇒copil
• trebuie făcută explicit de către programator
• încercați să evitați folosirea operatorului instanceof

Suprascrierea:

• înlocuirea funcționalității metodei din clasa de bază în clasa derivată
• păstreaza numele și semnătura metodei

Supraîncărcarea:

• în interiorul clasei pot exista mai multe metode cu același nume, cu condiția ca semnătura (tipul, argumentele) să fie diferită

Cuvântul cheie super:

• instanța clasei părinte
• amintiți-vă din laboratorul anterior că this se referă la instanța clasei curente

Veți proiecta o clasă Form care va avea câmpul privat color (String).

Clasa va avea, de asemenea:

1. un constructor fără parametri, care va inițializa culoarea cu “white”;
2. un constructor cu parametri;
3. o metodă de tip float getArea(), care va întoarce valoarea 0;
4. o metodă toString(): “This form has the color [color]”.

Din clasa Form derivați clasele Square, Triangle, Circle:

1. clasa Triangle (triunghi isoscel) va avea 2 membri height și base (adiacenta unghiurilor congruente) de tip float;
2. clasa Circle va avea membrul radius de tip float;
3. clasa Square va avea membrul side de tip float.

Clasele vor avea:

1. constructori fără parametri;
2. constructori care permit inițializarea membrilor. Identificați o modalitate de reutilizare a codului existent;
3. suprascrieți metoda getArea() pentru a întoarce aria specifică fiecărei figuri geometrice;
4. suprascrieți metoda toString() în clasele derivate, astfel încât aceasta să utilizeze implementarea metodei toString() din clasa de baza.

Adăugați o metodă equals(Object o) în clasa Triangle.

Justificați criteriul de echivalență ales.

Hint: Puteți genera automat metoda, cu ajutorul IDE. Selectați câmpurile considerate și analizați în ce fel va fi suprascrisă metoda equals.

Creați un vector de obiecte Form și populați-l cu obiecte de tip Triangle, Circle și Square (upcasting).

Parcurgeți acest vector și apelați metoda toString() pentru elementele sale. Ce observați?

Adăugați:

1. clasei Triangle metoda printTriangleDimensions,
2. clasei Circle metoda printCircleDimensions
3. clasei Square metoda printSquareDimensions

Implementarea metodelor constă în afișarea bazei și înălțimii, razei, respectiv laturii.

Parcurgeți vectorul de la exercițiul anterior și, folosind downcasting la clasa corespunzătoare, apelați metodele specifice fiecărei clase:

1. printTriangleDimensions pentru Triangle
2. printCircleDimensions pentru Circle
3. printSquareDimensions pentru Square

Pentru a stabili tipul obiectului curent folosiți operatorul instanceof.

Afișați dimensiunile formelor din vectorul creat fără a folosi operatorul instanceof.

Afișați perimetrul fiecărui obiect din vectorul creat utilizând exclusiv funcția printPerimeter, modificând doar ce se afla in corpul funcției, lasând antetul identic.

• UML Diagrams (class relations)
• Aggregation vs Composition
• Inheritance JavaDoc
• Multiple Inheritance
• Upcasting and Downcasting