Laboratorul 4: Abstractizare, Clase Speciale și Restricții

• Autori: Florian-Luis Micu , Sorina-Anamaria Buf , Ștefan Cocioran
• Data publicării: 27.10.2025
• Data ultimei modificări: 27.10.2025

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 abstractizării și a modului în care ascunde detaliile interne.
• utilizarea corectă a claselor abstracte și interfețelor pentru refolosirea și organizarea codului.
• înțelegerea diferenței dintre clase normale, abstracte și interfețe.
• exersarea implementării metodelor abstracte și default.
• înțelegerea și utilizarea polimorfismului în Java.
• folosirea obiectelor imutabile pentru cod sigur și clar.
• aplicarea constantelor cu final pentru valori fixe.

Aspectele bonus urmărite sunt:

• Problema diamantului pentru metode default în interfețe.
• clase de tip Record.
• clase de tip Enum.

Abstractizarea este unul dintre cele 4 principii POO de bază (Abstractizare, Încapsulare, Moștenire, Polimorfism).

Acest principiu este folosit pentru a ascunde detaliile interne ale obiectelor și evidențiază doar comportamentele esențiale. Ea oferă un șablon comun pentru o categorie de obiecte, fără a specifica implementarea fiecăruia. În Java, abstractizarea este realizată prin clase abstracte și interfețe.

Programarea orientată pe obiecte permite modelarea unor concepte generale care pot avea comportamente variate în funcție de implementare. Clasele și metodele abstracte oferă un mecanism esențial pentru proiectarea ierarhiilor de clase flexibile și extensibile.

O metodă abstractă este o metodă fără implementare, declarată doar pentru a defini ce ar trebui să facă o metodă, fără a spune cum o face. Rolul ei este să oblige clasele derivate să furnizeze propria implementare.

Marcarea unei metode abstracte se face folosind keyword-ul abstract.

public abstract void startEngine(); 

Caracteristici:

• Nu are corp (doar semnătură, terminată cu ;).
• Este destinată suprascrierii în clasele copil.
• Nu poate fi apelată direct
• Poate exista doar într-o clasă abstractă.

O clasă abstractă este o clasă care poate conține:

• metode abstracte
• metode obișnuite cu implementare
• variabile membru
• constructori

Pentru a marca o clasă ca fiind abstractă folosim keyword-ul abstract în declararea clasei.

public abstract class Vehicle { 
    private String name;
 
    public Vehicle(String name) {
        this.name = name;
    }
 
    public abstract void startEngine();
 
    public void setName(String name) {
        this.name = name;
    }
 
    public String getName() {
        return name;
    } 
}

O clasă abstractă, nu poate fi instanțiată direct, trebuie moștenită de o altă clasă folosind keyword-ul extends.

Acest mecanism funcționează și pe lanțuri de moștenire între clase abstracte: o clasă abstractă poate moșteni o altă clasă abstractă și poate adăuga metode abstracte noi. Toate metodele abstracte din lanț trebuie să fie implementate în cele din urmă într-o clasă concretă pentru a putea crea obiecte.

Vehicle.java

public abstract class Vehicle { 
    private String name;
 
    public Vehicle(String name) {
        this.name = name;
    }
 
    public abstract void startEngine();
 
    public void setName(String name) {
        this.name = name;
    }
 
    public String getName() {
        return name;
    } 
}

Car.java

public abstract class Car extends Vehicle { 
    public abstract void openTrunk();
 
    public Car(String name) {
        super(name);
    }
 
    @Override
    public void startEngine() {
        System.out.println("Car engine started!");
    }
}

Sedan.java

public class Sedan extends Car {
    public Sedan(String name) {
        super(name);
    }
 
    @Override
    public void openTrunk() {
        System.out.println("Trunk opened in the back of the car!");
    }
}

După implementare, pot fi create obiecte de tipul clasei Sedan:

Vehicle vehicle = new Sedan();
vehicle.startEngine(); // Output: Car engine started!
vehicle.openTrunk(); // Output: Trunk opened in the back of the car!

Folosește o clasă abstractă atunci când:

• Ai nevoie să definești un comportament comun pentru mai multe clase
  • Exemplu: Instrument oferă doar metodele abstracte play() și stop(), iar clasele care o moștenesc vor avea aceste metode de bază în comun (Saxophone, Guitar etc.).
• Vrei să implementezi parțial o clasă, lăsând detalii subclaselor
  • Exemplu: Vehicle oferă metoda comună start(), dar fiecare subclasă (Car, ElectricScooter) definește propriul tip de combustibil prin metoda fuelType().
• Există metode care nu au sens la nivel general, dar sunt obligatorii în subclase
  • Exemplu: Document are metoda abstractă print(), pentru că doar documentele concrete (PDFDocument, WordDocument) pot defini cum se tipăresc.
• Vrei să eviți instanțierea unei clase de bază
  • Exemplu: Shape nu poate fi instanțiată direct; doar formele concrete (Circle, Square) pot fi folosite pentru a calcula aria.

Interfețele oferă un mecanism prin care putem defini comportamente fără a forța clasele să moștenească implementarea. Ele stabilesc un contract pe care orice clasă îl poate îndeplini, indiferent din ce parte a ierarhiei de clase provine.

O interfață este un tip de referință în Java ce conține doar semnături de metode (fără implementare). Ea definește un set de capabilități pe care o clasă trebuie să le ofere, astfel poate fi considerată o clasă abstractă pură, deoarece conține doar metode abstracte.

Interfețele se definesc cu keyword-ul interface în locul keyword-ului class. O interfață poate conține:

• constante
• metode

Metodele dintr-o interfață:

• sunt implicit public și abstract
• nu au corp (doar semnătură)
• pot fi implementate de orice clasă

public interface Driveable {
    boolean startEngine();
    void stopEngine();
    float accelerate(float acc);
    boolean turn(Direction dir);
}

O clasă implementează o interfață folosind keyword-ul implements, furnizând implementarea tuturor metodelor:

public class Automobile implements Driveable {
    public boolean startEngine() {
        engineRunning = true;
        return true;
    }
 
    public void stopEngine() {
        engineRunning = false;
    }
 
    public float accelerate(float acc) {
        // logică accelerare
        return acc;
    }
 
    public boolean turn(Direction dir) {
        // logică pentru viraj
        return true;
    }
}

Ca și în cazul moștenirii clasice, putem avea o altă clasă care implementează aceeași interfață fără a avea legătură prin moștenire:

public class Lawnmower implements Driveable {
    // implementări proprii pentru metodele din interfață
}

În interfețe toate câmpurile sunt implicit public static final. Nu pot exista blank finals (câmpuri finale neinițializate), dar pot exista constante non-primitive dacă sunt inițializate la declarație.

public interface MathConstants {
    double PI = 3.14159; // valid
}

După ce definim o interfață, ea devine un tip de referință în Java, la fel ca o clasă. Asta înseamnă că putem:

• Declara variabile de tipul interfeței
• Folosi interfața ca tip pentru parametrii unor metode
• Specifica interfața ca tip de return al unei metode

Astfel, orice obiect care implementează interfața poate fi atribuit unei variabile de acel tip, indiferent de clasa sa concretă (upcasting).

Driveable vehicle;
 
vehicle = new Automobile();
vehicle.startEngine();
vehicle.stopEngine();
 
vehicle = new Lawnmower();
vehicle.startEngine();
vehicle.stopEngine();

Interfețele pot extinde alte interfețe folosind keyword-ul extends:

public interface Monster {
    void actMenacing();
}
 
public interface DangerousMonster extends Monster {
    void destroyEverything();
}

Clasa care va moșteni interfața DangerousMonster va trebui să implementeze ambele metode actMenacing() și destroyEverything():

public class LochNessMonster implements DangerousMonster {
    public void actMenacing() {
        System.out.println("*Jump out of water*");
    }
 
    public void destroyEverything() {
        System.out.println("*Attack every pier and boat*");
    }
}

În Java, o interfață poate moșteni mai multe interfețe folosind keyword-ul extends. Acesta permite combinarea comportamentelor din mai multe surse fără a fi nevoie de moștenire multiplă de clase (care nu este permisă în Java).

interface Flyer {
    void fly();
}
 
interface Swimmer {
    void swim();
}
 
// Moștenire multiplă de interfețe
interface Duck extends Flyer, Swimmer {
    void quack();
}
 
class Mallard implements Duck {
    public void fly() { System.out.println("Flying!"); }
    public void swim() { System.out.println("Swimming!"); }
    public void quack() { System.out.println("Quack!"); }
}

Totodată, o clasă poate moșteni mai multe interfețe folosind keyword-ul implements:

// Interfețe separate
interface Flyer {
    void fly();
}
 
interface Swimmer {
    void swim();
}
 
// Clasă care implementează ambele interfețe
class Duck implements Flyer, Swimmer {
    @Override
    public void fly() {
        System.out.println("Flying high!");
    }
 
    @Override
    public void swim() {
        System.out.println("Swimming in the pond!");
    }
}

Dacă două interfețe au metode cu aceeași semnătură și același tip de return, nu există probleme, deoarece clasa care le implementează poate furniza o singură implementare.

Însă, dacă metodele au același nume și parametri, dar tipuri de return diferite, apare un conflict, deoarece Java nu știe ce tip de return să folosească.

// Exemplu valid: metode cu aceeasi semnatura si acelasi tip de return
interface A { int run(); }
interface B { int run(); }
 
class ABRunner implements A, B {
    @Override
    public int run() {
        return 42; // o singura implementare pentru ambele interfete
    }
}
 
// Exemplu care dă eroare: metode cu același nume și parametri, dar tipuri diferite
interface C { String run(); }
 
// Clasa de mai jos va genera eroare dacă încercăm să implementăm A și C simultan
class ACFail implements A, C {  
    // eroare: conflicte la tipul return
    @Override
    public ??? run() { ... } // Java nu știe dacă să returneze "int" sau "String"
}

interface Animal {
    default void eat() {
        System.out.println("Animal is eating");
    }
}

interface A {
    default void hello() { System.out.println("Hello from A"); }
}
 
interface B {
    default void hello() { System.out.println("Hello from B"); }
}
 
class C implements A, B {
    // EROARE: conflict, Java nu știe ce versiune de hello() să folosească
}

class C implements A, B {
    @Override
    public void hello() {
        A.super.hello(); // sau B.super.hello();
    }
}

După cum se poate observa, atât clasele abstracte cât și interfețele oferă avantaje similare. Să observăm următorul tabel pentru o comparație directă:

Proiectele voastre ar trebui să conțină o combinație între clase abstracte și interfețe.

Să presupunem următoarea ierarhie de clase.

Explicație:

1. Living este abstractă pentru că vrem să forțăm implementarea metodei eat() în toate clasele care o extind, dar oferim și un comportament comun grow().
2. Animal este abstractă pentru că nu are sens să instanțiem un animal generic; fiecare subclasă (Cat, Dog, Bird) trebuie să implementeze makeSound().
3. Clasele normale (Cat, Dog, Bird) implementează metodele abstracte și pot fi instanțiate.
4. Interfețele (Domesticable, Guardable, Flyable) definesc capabilități suplimentare, fără a impune moștenirea ierarhiei.
5. Clasele pot implementa mai multe interfețe pentru a combina comportamente, exemplu: Dog poate fi Domesticable și Guardable.

Reamintim din laboratoarele trecute cum final poate fi folosit pentru a crea câmpuri sau variabile locale constante:

public class Alien {
    private final String name; // camp constant
 
    public Alien(String name) {
        this.name = name;
    }
 
    public String sayHelloToHumans() {
        // Constante locale
        final String evilMessage = " prepare your world to be conquered!";
        final String goodMessage = " we want to taste shaorma!";
 
        if (name.equals("Good Boy Roy")) {
            return "My name is " + name + goodMessage;
        }
 
        return "My name is " + name + badMessage;
    }
 
    public String getName() {
       return name;
    }
}

De asemenea, putem marca parametrii unei metode ca fiind final pentru a indica faptul că aceștia nu pot fi schimbați în corpul unei metode:

public class Alien {
    private final String name; // camp constant
 
    public Alien(String name) {
        this.name = name;
    }
 
    public String sayHelloToHumans() {
        // Constante locale
        final String evilMessage = " prepare your world to be conquered!";
        final String goodMessage = " we want to taste shaorma!";
 
        if (name.equals("Good Boy Roy")) {
            return "My name is " + name + goodMessage;
        }
 
        return "My name is " + name + badMessage;
    }
 
    public void shootRayGun(final Human human) {
        human.decreaseHealthBy(70);
        System.out.println("Resistence is futile!");
 
        human = new Human(); // eroare, human este final
        human.job = "plumber"; // se poate, final se refera doar la referinta obiectului 
    }
 
    public String getName() {
       return name;
    }
}

Un obiect imutabil este un obiect a cărui stare internă nu poate fi modificată după ce a fost creat. Cu alte cuvinte, toate câmpurile sale sunt constante după inițializare, iar orice operație aparentă de “modificare” va genera de fapt un nou obiect.

Pentru ca o clasă să fie considerată imutabilă, trebuie să respecte următoarele reguli:

• Toate câmpurile sale trebuie să fie private și finale.
• Clasa trebuie declarată final pentru a preveni moștenirea.
• Nu trebuie să existe setters sau alte metode care modifică starea internă.
• Obiectele returnate de metode trebuie să fie copii, nu referințe directe către câmpurile interne (pentru a evita modificarea indirectă).

• Siguranță în programe paralelizabile: Obiectele imutabile pot fi partajate între thread-uri fără sincronizare suplimentară.
• Simplitate: Nu este nevoie de protecție împotriva modificărilor accidentale.
• Fiabilitate: Pot fi folosite ca chei în colecții (HashMap, HashSet) fără riscul ca starea lor să se schimbe.
• Cache și reutilizare: Obiectele pot fi memorate în cache fără teama că valorile se vor modifica ulterior.

• Consum mai mare de memorie: Crearea de obiecte noi la fiecare modificare poate fi costisitoare.
• Performanță scăzută în cazurile în care modificările frecvente sunt inevitabile.

Exemplu de clasă imutabilă:

Adress.java

public final class Adress {
    private final String street;
    private final String city;
    private final int zipCode;
 
    public Adresa(String street, String city, int zipCode) {
        this.street = street;
        this.city = city;
        this.zipCode = zipCode;
    }
 
    public String getStreet() { return street; }
    public String getCity() { return city; }
    public int getZipCode() { return zipCode; }
 
    @Override
    public String toString() {
        return street + ", " + city + " (" + zipCode + ")";
    }
}

Main.java

public class Main {
    public static void main(String[] args) {
        Adresa adresa1 = new Adresa("Str. Florilor", "București", 12345);
        Adresa adresa2 = new Adresa("Str. Florilor", "București", 12345);
 
        // ambele obiecte sunt independente și nu pot fi modificate
        System.out.println(adresa1); // Str. Florilor, București (12345)
    }
} 

Java oferă numeroase exemple de clase imutabile, printre care:

• String
• Wrapper-urile pentru tipurile primitive (Integer, Double, Boolean etc.).
• LocalDate, LocalTime, LocalDateTime (din pachetul java.time).

Enums sunt tipuri speciale de clasă care definesc un set fix de constante. Ele oferă o modalitate sigură și lizibilă de a reprezenta valori finite și constante într-un program.

Exemplu simplu:

enum Direction {
    NORTH,
    SOUTH,
    EAST,
    WEST
}

• Reprezintă un set fix de valori constante.
• Sunt tipuri sigure, deci nu poți atribui o valoare invalidă.
• Poți adăuga metode, constructori și câmpuri într-un enum.
• Implicit, toate valorile enum sunt public static final.

enum Planet {
    MERCURY(3.3e+23, 2.4e6),
    VENUS(4.87e+24, 6.1e6),
    EARTH(5.97e+24, 6.4e6);
 
    private final double mass;   // în kilograme
    private final double radius; // în metri
 
    Planet(double mass, double radius) {
        this.mass = mass;
        this.radius = radius;
    }
 
    public double getMass() {
        return mass;
    }
 
    public double getRadius() {
        return radius;
    }
 
    public double surfaceGravity() {
        final double G = 6.67300E-11;
        return G * mass / (radius * radius);
    }
}

Pentru exemplul simplu de mai sus avem:

Direction dir = Direction.NORTH;
 
switch (dir) {
    case NORTH:
        System.out.println("Mergeți spre nord");
        break;
    case SOUTH:
        System.out.println("Mergeți spre sud");
        break;
    default:
        System.out.println("Altă direcție");
}

Pentru exemplul mai complex avem:

public class PlanetExample {
    public static void main(String[] args) {
        double massOnEarth = 70; // masa în kg (nu greutatea!)
 
        for (Planet planet : Planet.values()) {
            double weight = planet.surfaceGravity() * massOnEarth;
            System.out.printf("Greutatea ta pe %s este %.2f N%n", planet.name(), weight);
        }
    }
}

Greutatea ta pe MERCURY este 25.94 N
Greutatea ta pe VENUS este 61.47 N
Greutatea ta pe EARTH este 687.30 N

• Cod mai clar și mai lizibil comparativ cu constantele int sau String.
• Siguranță la compilare: nu poți atribui valori invalide.
• Poți adăuga metode și comportamente specifice fiecărei constante.
• Se integrează bine cu switch/case pentru decizii pe valori finite.

Tipul record este un tip special de clasă introdus în Java 16, creat pentru a reprezenta date imutabile într-un mod concis. Scopul său principal este să reducă codul boilerplate necesar pentru clasele care doar păstrează date (data carriers), cum ar fi DTO-uri sau simple modele.

Un record:

• Este implicit final (nu poate fi moștenit).
• Are câmpuri imutabile (private final).
• Generează automat:
  • Constructor,
  • equals() și hashCode(),
  • toString(),
  • Getteri (numiți exact ca atributele, fără get).

public record Person(String name, int age) {}

Exemplul de mai sus este echivalent cu:

public final class Person {
    private final String name;
    private final int age;
 
    public Person(String name, int age) { 
        this.name = name; 
        this.age = age; 
    }
 
    public String name() { return name; }
    public int age() { return age; }
 
    @Override
    public boolean equals(Object o) { ... }
 
    @Override
    public int hashCode() { ... }
 
    @Override
    public String toString() { ... }
}

Person p = new Person("Ana", 25);
System.out.println(p.name()); // Ana
System.out.println(p.age());  // 25

Constructorul compact ne permite să validăm datele fără să repetăm lista de parametri.

public record Product(String name, double price) {
    public Product {
        if (price < 0) {
            throw new IllegalArgumentException("Price must be positive");
        }
    }
}

Pe lângă getteri și setteri putem adăuga de asemenea și metode.

public record Point(int x, int y) {
    public double distanceToOrigin() {
        return Math.sqrt(x * x + y * y);
    }
}

Records pot implementa interfețe, dar nu pot extinde clase.

public interface Printable {
    void print();
}
 
public record Book(String title, String author) implements Printable {
    @Override
    public void print() {
        System.out.println(title + " by " + author);
    }
}

Records sunt potrivite pentru:

• DTO-uri (Data Transfer Objects)
• Rezultate interne ale metodelor
• Clase imutabile simple
• Chei pentru mapări (hashCode generat automat)
• Proiecții din baze de date (ex: Spring repository projections)

Limitări:

• Nu pot extinde alte clase (extends interzis).
• Sunt implicit immutabile (valorile nu pot fi schimbate).
• Nu sunt potrivite pentru obiecte cu logică complexă sau stare mutabilă.

Abstractizare

• Permite ascunderea detaliilor interne și expunerea doar a comportamentului esențial.
• Realizată prin clase abstracte și interfețe.
• Favorizează polimorfismul și reutilizarea codului.

Clase abstracte

• Pot conține metode abstracte și metode cu implementare.
• Pot avea câmpuri și constructori.
• Nu pot fi instanțiate direct.
• Forțează subclasele să implementeze metodele abstracte.
• Permite moștenire între clase abstracte.

Interfețe

• Definește un contract de comportamente (metode abstracte).
• Poate conține metode default (cu implementare) și static.
• Permite moștenire multiplă fără conflicte de ierarhie (exceptând problema diamantului).
• Polimorfism: o variabilă de tip interfață poate referi orice clasă care o implementează.
• Nu poate avea constructori.
• Toate câmpurile sunt implicit public static final.

Problema diamantului (în interfețe)

• Apare când o clasă implementează două interfețe cu aceeași metodă default.
• Soluția: clasa trebuie să suprascrie metoda și să aleagă implementarea.

Constante (final)

• Variabilele final nu pot fi modificate după inițializare.
• Folosite pentru constante globale, valoare fixă în clase sau enum-uri.
• În interfețe, toate câmpurile sunt implicit public static final.

Obiecte imutabile

• Obiectele nu își pot schimba starea după creare.
• Se obțin prin câmpuri private final și fără setteri.
• Oferă siguranță în programarea concurentă.

Enums

• Tip special care reprezintă un set fix de constante.
• Fiecare constantă este de fapt un obiect de tip enum.
• Pot avea câmpuri, constructori și metode.
• Metode utile: .values(), .ordinal(), .name().

Records

• Introduse în Java 16, pentru tipuri de date imutabile.
• Au câmpuri finale, constructor generat automat, equals(), hashCode() și toString().
• Perfect pentru DTO-uri sau obiecte care transportă date fără logică suplimentară.

Implementaţi interfaţa Task în cele 3 moduri de mai jos:

• Un task (OutTask.java) care să afișeze un mesaj la output. Mesajul este specificat în contructorul clasei.
• Un task (RandomOutTask.java) care genereaza un număr aleator de tip int și afișeaza un mesaj cu numărul generat la output. Generarea se va realiza în constructor utilizandu-se o instanță globală a unui obiect de tip Random care a fost inițializat cu seed-ul 12345.
• Un task (CounterOutTask.java) care incrementeaza un contor global și afișează valoarea contorului după fiecare incrementare.

Interfaţa Container specifică interfaţa comună pentru colecţii de obiecte Task, în care se pot adăuga și din care se pot elimina elemente.

Interfața conține metodele:

• pop():Task
• push(Task):void
• size():int
• isEmpty():boolean
• transferFrom(Container):void

Creaţi două tipuri de containere care implementează această clasă:

• Stack - care implementează o strategie de tip LIFO
• Queue - care implementează o strategie de tip FIFO

Bonus (nepunctat): Incercați să evitaţi codul similar în locuri diferite!

Creați 4 interfețe: Minus, Plus, Mult, Div care conțin câte o metodă aferentă numelui ce are ca argument un număr de tipul float.

Spre exemplu interfața Minus va declara metoda:

void minus(float value);

Scrieți clasa Operation care să implementeze toate aceste interfețe. Pe lânga metodele interfețelor implementate aceasta va conține:

• un câmp number de tipul float asupra căruia se vor efectua operațiile implementate
• o metodata getter getNumber care va returna valoarea câmpului value
• un constructor care primește ca parametru valoarea inițială pentru campul value

Pentru cazul în care metoda div este apelată cu valoare 0 operația nu va fi efectuată și se va afișa mesajul “Division by 0 is not possible”.

Implementaţi clasa Song și clasa abstracta Album.

Song:

• stochează atributele name de tip String. id de tip int si composer de tip String
• are un constructor care va inițializa atributele specificate anterior
• implementează metodele de tip getter și setter pentru fiecare atribut
• suprascrie metoda toString() care va returna un String de forma “Song{name=name, id=id, composer=composer}”

Album:

• stochează o listă de cântece
• declară metoda abstractă numită addSong care primește un Song și nu returnează nimic
• implementează metoda removeSong care primește un song și nu returnează nimic
• suprascrie metoda toString() care va returna un String de forma “Album{songs=[Song, Song, …]}”

După implementarea claselor Song și Album, creați clasele DangerousAlbum, ThrillerAlbum și BadAlbum, care vor moșteni clasa Album și vor implementa metoda addSong după următoarele reguli:

• DangerousAlbum conține doar melodii cu id-ul număr prim
• ThrillerAlbum conține melodii scrise doar de Michael Jackson și au id-ul număr par
• BadAlbum conține doar melodii care au nume de 3 litere și id număr palindrom

În cazul în care criteriul de adăugare specific unui album nu este respectat, melodia nu va fi adaugată în acesta.

• Abstract methods and classes
• Interfaces
• Records
• Enums