Tipuri de relații între obiecte. Set de probleme

1. Un magazin comercializează diferite produse electronice. Pentru a gestiona aceste produse, se dorește realizarea unei aplicații în Java. Proiectați în UML clasele. Despre produse se cunosc următoarele. Fiecare produs are denumire și preț. Există două tipuri de produse:
- Laptop, care are ca caracteristică specifică memorie RAM
- Telefon, care are ca caracteristică specifică capacitate baterie.
Creați un sistem în care:
- Definiți clasele Produs, Laptop, Telefon și stabiliți în ce relație se află acestea.
- Definiți atributele și constructori pentru toate clasele.
- Adăugați claselor metoda afisare() pentru a afișa informațiile despre clase
- În metoda main(), instanțiați clasele Laptop și Telefon și afișați informația despre fiecare.

2. O platformă online gestionează cursuri și instructori. Pentru organizarea activității, se dorește realizarea unei aplicații în Java. Proiectați în UML clasele. Despre entități se cunosc următoarele:
- fiecare instructor are nume și specializare
- fiecare curs are titlu și durată.
Platforma are denumire instructor și cursuri.
Creați un sistem în care:
- Definiți clasele Instructor, Curs și Platforma și stabiliți relația dintre acestea.
- Definiți constructori pentru toate clasele.
- Adăugați claselor metoda afisare() pentru a afișa informațiile despre obiecte.
- În metoda main(), creați mai mulți instructori și cursuri, apoi o platformă și asociați aceste obiecte.
- Afișați informația despre platformă, instructorii și cursurile disponibile.

3. Un calculator este format din componente interne. Pentru a simula structura unui calculator, se dorește realizarea unei aplicații în Java. Proiectați în UML clasele. Se cunoaște că fiecare componentă are denumire și specificații. Un calculator are model și conține componente (procesor, memorie RAM, hard disk).
Creați un sistem în care:
- Definiți clasele Componenta și Calculator și stabiliți relația dintre acestea.
- Definiți constructori pentru toate clasele.
- Adăugați claselor metoda afisare() pentru a afișa informațiile despre obiecte.
- În clasa Calculator, creați componentele (în constructor).
- În metoda main(), creați un obiect de tip Calculator.
- Afișați informația despre calculator și componentele sale.

4. Un Smartwatch este format din componente electronice integrate. Pentru a simula structura unui ceas inteligent, se dorește realizarea unei aplicații în Java. Proiectați în UML clasele. Se cunoaște că fiecare componentă are denumire și consum energetic. Un ceas are model și conține componente (ecran, baterie, senzor).
Creați un sistem în care:
- Definiți clasele Componenta și Smartwatch și stabiliți relația dintre acestea.
- Definiți constructori pentru toate clasele.
- Adăugați claselor metoda afisare() pentru a afișa informațiile despre obiecte.
- În clasa Smartwatch, creați componentele (în constructor).
- În metoda main(), creați un obiect de tip Smartwatch.
- Afișați informația despre ceas și componentele sale.

5. Un spital colaborează cu medici specialiști care pot activa și în alte clinici. Pentru a simula structura unui cabinet medical, se dorește realizarea unei aplicații în Java. Proiectați în UML clasele. Se cunoaște că fiecare Medic are nume și specializare. Un Cabinet are denumire și colaborează cu medici (un tablou de obiecte).
Creați un sistem în care:
- Definiți clasele Medic și Cabinet și stabiliți relația dintre acestea.
- Definiți constructori pentru toate clasele (constructorul clasei Cabinet primește tabloul de medici).
- Adăugați claselor metoda afisare() pentru a afișa informațiile despre obiecte.
- În clasa Cabinet, parcurgeți tabloul de medici pentru a le afișa datele.
- În metoda main(), creați obiectele de tip Medic independent de cabinet.
- Transmiteți tabloul de medici la crearea obiectului de tip Cabinet și afișați informația completă.

6. O Facultate este formată dintr-un grup de angajați care pot activa și în alte instituții. Pentru a simula structura academică, se dorește realizarea unei aplicații în Java. Proiectați în UML clasele. Se cunoaște că există o superclasă Persoana cu nume și prenume. Din aceasta derivă clasa Profesor care are în plus titlu academic. O Facultate are denumire și conține profesori (un tablou de obiecte).
Creați un sistem în care:
- Definiți superclasa Persoana și subclasa Profesor, stabilind relația de moștenire.
- Definiți clasa Facultate și stabiliți relația de agregare cu clasa Profesor.
- Definiți constructori pentru toate clasele.
- Adăugați claselor metoda afisare() pentru a afișa informațiile despre obiecte.
- În clasa Facultate, parcurgeți tabloul de profesori pentru a le afișa datele complete (nume, prenume și titlu).
- În metoda main(), creați 3 obiecte de tip Profesor în mod independent (ca entități separate).
- Creați un tablou cu acești profesori și transmiteți-l ca parametru la crearea obiectului de tip Facultate.
- Afișați informația despre facultate și lista membrilor corpului didactic.

Succes! 

❤️

Tipuri de moștenire simplă în Java

Deja cunoaștem că limbajul Java, la nivel de clase, permite doar moștenire simplă. Adică, o clasă poate să extindă o singură clasă și numai una. Excepția este clasa Object, care este părintele tuturor claselor Java, dar ea însăși nu are părinte.

Dar ... chiar dacă Java nu permite moștenirea multiplă direct cu clase, conceptul de moștenire chiar și cea simplă este mai larg și poate fi împărțit în mai multe tipuri, fiecare cu avantajele și situațiile sale specifice. 

Să le examinăm pe rând pe rând:

1. Moștenire unică. Cel mai simplu tip de moștenire din Java, unde o clasă copil extinde doar o clasă părinte. 

O clasă derivată (B) moștenește o singură clasă de bază (A).

Exemplul 1

class Angajat1{
    float salariu=3500*12;
}
class Director extends Angajat1 {
    float bonus=1000*6;
}
class Test{
    public static void main(String args[]) {
        Director obj=new Director();
        System.out.println("Salariu total: "+obj.salariu);
        System.out.println("Bonus pentru 6 luni: "+obj.bonus);
    }}

2. Moștenire pe mai multe niveluri. Este un tip de moștenire în care o clasă copil extinde o altă clasă copil, care la rândul său extinde o clasă părinte.

O clasă derivată (B) devine la rândul ei clasă de bază pentru o altă clasă (C).

Exemplul 2

class FiguraGeometrica {
    public void suprafata() {
        System.out.println("Suprafata interioara");
    }}
class Dreptunghi extends FiguraGeometrica {
    public void arie() {
        System.out.println("Arie interioara");
    }}
class Patrat extends Dreptunghi{
    public void volum() {
        System.out.println("Volum interior");
    }}
class TestareIerarhica {
    public static void main(String[] arguments) {
        Patrat cube = new Patrat();
        cube.suprafata();
        cube.arie();
        cube.volum();
    }} 

3. Moștenirea ierarhică. Clasele copil extind aceeași clasă părinte. 

Mai multe clase derivate (B,C) moștenesc aceeași clasă de bază (A)

Exemplul 3 

class Vehicul {
    double pretBaza = 100000;
    public void afisarePret() {
        System.out.println("Pretul de baza: " + pretBaza);
    }}

class Bicicletaa extends Vehicul {
    double plusPret = 0.20;
    void pretFinal() {
        pretBaza  = pretBaza  + (pretBaza  * plusPret);
        System.out.println("Pretul pentru bicicleta:" + pretBaza);
    }}

class Masina extends Vehicul {
    double plusPret = 1;
    void pretFinal() {
        pretBaza  = pretBaza  + (pretBaza * plusPret);
        System.out.println("Pret pentru masina:" + pretBaza);
    }}
class TestareIerarhic {
    public static void main(String[] args) {
        System.out.println("----------------------");
        Bicicletaa bicicleta = new Bicicletaa();
        bicicleta.afisarePret();
        bicicleta.pretFinal();
        System.out.println("----------------------");
        Masina auto = new Masina();
        auto.afisarePret();
        auto.pretFinal();
    }}

4. Moștenirea hibridă. Este combinația mai multor tipuri de moștenire, de exemplu, un amestec între moștenire în lanț, sau pe mai multe niveluri, și moștenire ierarhică. 

Exemplul 4

class A {
    public void afiseaza() {
        System.out.println("clasa A");
    }}
class B extends A {
    public void afiseazaB() {
        System.out.println("clasa B");
    }}
class C extends A {
    public void afiseazaC() {
        System.out.println("clasa C");
    }}
class D extends C {
    public void afiseazaD() {
        System.out.println("clasa D");
    }}

class Mainn {
    public static void main(String[] args) {
        D obj = new D();
        obj.afiseaza();
    }}

La fel cum în viața de zi cu zi învățăm și ne construim experiențele pe baza a ceea ce știm deja, în programare clasele „împrumută” caracteristici și metode de la clasele părinte. Astfel codul devine mai clar, mai ordonat și mai elegant. 

Succes! 

❤️

Tipuri de moștenire Set de probleme

1. În cadrul unei școli, se dorește gestionarea informațiilor despre persoane și studenți. Proiectați în UML (https://app.diagrams.net/) diagrama proiectului care trebuie să conțină clasele, atributele, metodele și relațiile de moștenire. Creați un program Java care va afișa datele complete ale unui student.

Creați clasa Persoana, care conține două variabile: nume și telefon, precum și un constructor parametrizat care va inițializa aceste atribute. Clasa va avea metoda afiseazaDate() care va afișa numele și numărul de telefon al persoanei.

Creați clasa Student, derivată din clasa Persoana, care adaugă atributul grupa. Clasa va avea un constructor parametrizat și metoda afiseazaDate() care va afișa toate informațiile persoanei, inclusiv grupa studentului.

În clasa principală Main, creați un obiect de tip Student, introduceți de la tastatură valorile pentru nume, telefon și grupă și afișați la ecran informațiile complete despre student.

2. Un magazin vinde diferite tipuri de produse, inclusiv produse electronice. Proiectați în UML (https://app.diagrams.net/) diagrama proiectului care trebuie să conțină clasele, atributele, metodele și relațiile de moștenire. Creați un program Java care va afișa informațiile complete despre un telefon mobil.

Creați clasa Produs care conține două variabile: numeProdus și pret, precum și un constructor parametrizat care va inițializa aceste atribute. Clasa va avea metoda afiseazaProdus() care va afișa numele și prețul produsului.

Creați clasa ProdusElectronic, derivată din clasa Produs, care adaugă atributul garantie (în luni). Clasa va avea un constructor parametrizat și metoda afiseazaProdus() care va afișa atât informațiile din clasa de bază, cât și garanția produsului.

Creați clasa TelefonMobil, derivată din clasa ProdusElectronic, care adaugă atributul sistemDeOperare. Clasa va avea un constructor parametrizat și metoda afiseazaProdus() care va afișa toate informațiile despre telefon, inclusiv sistemul de operare.

În clasa principală Main, creați un obiect de tip TelefonMobil, introduceți de la tastatură toate valorile necesare și afișați informațiile complete despre telefon.

3. O companie de transport organizează excursii turistice. Proiectați în UML (https://app.diagrams.net/) diagrama proiectului care trebuie să conțină clasele, atributele, metodele și relațiile de moștenire. Creați un program Java care va calcula costul excursiei.

Creați clasa Vehicul care conține ca atribut distanta și constructorul parametrizat care va inițializa atributul clasei.

Creați clasa VehiculTransport derivată din Vehicul și are în plus atributul pretKm care semnifică prețul călătoriei pentru 1 km și metoda calculeazaCostTransport() care va folosi pentru calcule formula: cost = distanta * pretKm

Creați clasa AutobuzTuristic derivată din VehiculTransport și care adaugă ca atribut taxaGhid și are ca metodă calculeazaCostTotal() care va afișa costul total al călătoriei calculat după formula: costTotal = distanta * pretKm + taxaGhid

În clasa principală Main, creați un obiect de tip creați un obiect AutobuzTuristic, introduceți valori de la tastatură și afișați costul total al călătoriei.

4. Un magazin IT comercializează diferite tipuri de laptopuri. Proiectați în UML (https://app.diagrams.net/) diagrama proiectului care trebuie să conțină clasele, atributele, metodele și relațiile de moștenire. Creați un program Java care va calcula prețul final al unui laptop în funcție de componentele sale.

Creați clasa Laptop care conține atributul pretBaza și un constructor parametrizat care va inițializa acest atribut. De asemenea, clasa va conține metoda calculPretLaptop() care va returna prețul de bază al laptopului.

Creați clasa LaptopGaming derivată din clasa Laptop, care adaugă atributul pretPlacaVideo, reprezentând costul plăcii video dedicate. Clasa va avea un constructor parametrizat pentru inițializarea atributelor și metoda calculPretGaming() care va calcula prețul laptopului gaming folosind formula: pret = pretBaza + pretPlacaVideo.

Creați clasa LaptopGamingPro derivată din clasa LaptopGaming, care adaugă atributul pretSistemRacire, reprezentând costul sistemului avansat de răcire. Clasa va conține un constructor parametrizat și metoda calculPretTotal() care va calcula prețul final al laptopului folosind formula: pretTotal = pretBaza + pretPlacaVideo + pretSistemRacire.

În clasa principală Main, creați un obiect de tip LaptopGamingPro, introduceți valorile necesare de la tastatură și afișați pe ecran prețul laptopului simplu, prețul laptopului gaming și prețul total al laptopului gaming pro.

5. Într-o companie IT există mai multe tipuri de angajați care primesc salariul în mod diferit Proiectați în UML (https://app.diagrams.net/) diagrama proiectului care trebuie să conțină clasele, atributele, metodele și relațiile de moștenire. Creați un program Java care va calcula salariul pentru diferite tipuri de angajați.

Creați clasa Angajat care conține atributul salariuBaza și un constructor parametrizat care va inițializa acest atribut. Clasa va conține metoda calculSalariu() care va returna salariul de bază al angajatului.

Creați clasa Programator derivată din clasa Angajat, care adaugă atributul bonusProiect. Clasa va avea un constructor parametrizat pentru inițializarea atributelor și metoda calculSalariuProgramator() care va calcula salariul programatorului folosind formula:
salariu = salariuBaza + bonusProiect.

Creați clasa Designer derivată din clasa Angajat, care adaugă atributul bonusCreativitate. Clasa va conține un constructor parametrizat și metoda calculSalariuDesigner() care va calcula salariul designerului folosind formula: salariu = salariuBaza + bonusCreativitate.

Creați clasa Manager derivată din clasa Angajat, care adaugă atributul bonusManagement. Clasa va conține un constructor parametrizat și metoda calculSalariuManager() care va calcula salariul managerului folosind formula: salariu = salariuBaza + bonusManagement.

În clasa principală Main, creați obiecte de tip Programator, Designer și Manager, introduceți valorile necesare de la tastatură și afișați salariul pentru fiecare tip de angajat.

6. O bancă oferă mai multe tipuri de conturi pentru clienți, fiecare având reguli diferite de calcul al sumei disponibile. Proiectați în UML (https://app.diagrams.net/) diagrama proiectului care trebuie să conțină clasele, atributele, metodele și relațiile de moștenire. Creați un program Java care va calcula suma totală din diferite tipuri de conturi bancare.

Creați clasa ContBancar care conține atributul sold și un constructor parametrizat care va inițializa acest atribut. Clasa va conține metoda calculSold() care va returna soldul curent al contului.

Creați clasa ContEconomii derivată din clasa ContBancar, care adaugă atributul rataDobanda. Clasa va avea un constructor parametrizat pentru inițializarea atributelor și metoda calculSoldEconomii() care va calcula soldul contului folosind formula: soldFinal = sold + sold * rataDobanda / 100.

Creați clasa ContCurent derivată din clasa ContBancar, care adaugă atributul taxaAdministrare. Clasa va conține un constructor parametrizat și metoda calculSoldCurent() care va calcula soldul contului folosind formula: soldFinal = sold - taxaAdministrare.

Creați clasa ContPremium derivată din clasa ContBancar, care adaugă atributul bonus. Clasa va conține un constructor parametrizat și metoda calculSoldPremium() care va calcula soldul contului folosind formula: soldFinal = sold + bonus.

În clasa principală Main, creați obiecte de tip ContEconomii, ContCurent și ContPremium, introduceți valorile necesare de la tastatură și afișați soldul final pentru fiecare tip de cont.

Succes! 

❤️