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! 

❤️

Fluxuri de citire/scriere la nivel de octet

În lecțiile precedente am învățat ce reprezintă fluxurile de intrare și ieșire și cum se utilizează acestea la nivel de caractere.

În lecția de astăzi ne vom concentra pe modul de lucru cu fluxurile binare în limbajul de programare Java. Adică vom învăța cum se realizează citirea și scrierea datelor în fișiere binare. 

După cum cunoaștem, în limbajul Java, pentru a implementa orice funcționalitate, trebuie să cunoaștem clasele care ne permit realizarea ei, precum și constructorii și metodele specifice ale acestor clase.

La baza ierarhiei fluxurilor bazate pe octeți se află clasele abstracte OutputStream (pentru scriere) și InputStream (pentru citire). Cunoașterea metodelor acestor clase ne permite, practic, să stăpânim aproximativ 90% din funcționalitatea tuturor claselor care le moștenesc, deoarece anume cu aceste clase lucrăm de fapt.

Clasa InputStream conține următoarele metode:

1) public abstract int read() throws IOException; – citește octetul curent din flux şi îl returnează sub forma unui întreg cu valori între 0 şi 255. Dacă s-a ajuns la capătul fluxului se returnează valoarea –1
2) public int read(byte b[]) throws IOException; - citesc de la poziția curentă din flux un număr de octeți egal cu lungimea tabloului b şi îl înscriu în tabloul b, returnează numărul de octeţi citiţi în bufferul b sau –1 dacă s-a ajuns la capătul fluxului.
3) public int read(byte b[], int off, int len) throws IOException; - citesc de la poziția curentă din flux un număr de octeţi egal cu len şi îl înscriu în tabloul b, la poziția off. Returnează numărul de octeţi citiţi în bufferul b sau –1 dacă s-a ajuns la capătul fluxului.
4) public long skip(long n) throws IOException; - mută poziția cursorului de citire peste n octeţi, întorcând numărul efectiv de octeţi peste care s-a sărit, sau -1 în caz de EOF.
5) public int available() throws IOException; - returnează numărul de octeţi disponibili pentru citire din flux.
6) public void close() throws IOException;- închide un flux. Odată terminat lucrul cu un flux, acesta trebuie închis, eliberând astfel resursele sistem ocupate de acel flux. În mod normal JVM închide aceste fluxuri în momentul în care programul se termină, dar este recomandabil ca programatorul să facă „curat”.
7) public synchronized void mark(int readlimit); - prin această funcție se memorează poziția curentă în flux, specificând prin argumentul readlimit, maximul de octeţi (se crează un buffer de dimensiune readlimit) care se pot citi până la apelul funcției reset.
8) public synchronized void reset() throws IOException;- repoziționează cursorul de citire din flux la poziția la care s-a făcut marcarea prin funcția mark.
9) public boolean markSupported(); - returnează adevărat daca metodele mark() și reset() sunt implementate, și fals în caz contrar.
10) protected void finalize() throws IOException;- asigură apelarea metodei close() pentru fluxul curent în caz că nu mai sunt referinţe la acesta.

Pentru a utiliza clasa InputStream în programare a fost nevoie de construirea unor clase derivate din aceasta, clase care să fie conectate cu surse de date reale existente în sistem.

Din categoria claselor pentru fluxuri de intrare la nivel de octet conectate la diferite tipuri de resurse fac parte:
● ByteArrayInputStream permite conectarea unui flux la un tablou de octeţi.
● SequenceInputStream permite combinarea mai multor fluxuri având ca rezultat obținerea unui singur flux.
● AudioInputStream permite conectării cu un stream audio.
● FileInputStream oferă posibilitatea conectării cu un fişier pentru a citi datele înregistrate în acesta.

Clasa OutputStream conține următoarele metode:

1) public abstract void write(int i) throws IOException; - scrie în flux octetul cel mai puţin semnificativ al argumentului, care este de tip întreg.
2) public void write (byte b[]) throws IOException;- permit scrierea în flux a unui tablou de octeţi .
3) public void write (byte b[], int off, int len) throws IOException;- permit scrierea în flux a unei secțiuni din tabloul de octeţi b începând de la poziția off şi având lungimea len.
4) public long flush() throws IOException; - forţează transmiterea datelor la destinație (capătul flux-ului) şi este utilă în cazul în care se folosește un buffer de scriere (golește buffer-ul).
5) public void close() throws IOException; - închide fluxul deschis .

În cadrul acestui curs utiliza mai multe clase pentru a opera cu fluxurile la nivel de octeți. Toate metodele sunt moștenite de la clasele InputStream şi OutputStream, nu au metode noi.

Clasa FileInputStream are constructorii :

1) FileInputStream(File file) throws FileNotFoundException – va realiza conectarea cu un fişier concret. Numele și calea către fișier fiind setate cu ajutorul unei instanțe a clasei File.
2) FileInputStream(String name) - va realiza conectarea cu un fișier calea căruia este dată de name.

Clasa FileOutputStream are un singur constructor:

FileOutputStream (cale catre fisier);

Exemplu 1. Programul va crea un fișier binar numit binar.dat, va scrie în fișier primele 10 numere naturale la nivel de octet, folosind FileOutputStream. Va deschide fișierul pentru citire folosind FileInputStream și va afișa pe ecran toate valorile citite, separate prin spațiu.

import java.io.*;
public class Main {
    public static void main(String[] args) throws IOException{

        FileOutputStream output = new FileOutputStream("binar.dat");
        for (int i=1;i<=10;i++) output.write(i);
        output.close();

        FileInputStream input = new FileInputStream("binar.dat");
        int value;
        while((value=input.read()) != -1)
            System.out.print(value + " ");
        input.close();

    }}

Fișierul binar.dat creat în exemplul de mai sus este un fișier binar. Va putea fi citit de un program Java însă nu de un editor de text.

Extensia .dat este pur și simplu un nume generic pentru extensia fișierului creat. Nu are o semnificație aparte în Java sau în sistemul de operare.

Astfel puteți crea o extensie personalizată. De exemplu, .xyz sau .info pentru fișierele tale, atâta timp cât programul tău știe cum să le citească și să le scrie.

De exemplu:

FileOutputStream output = new FileOutputStream("date_elevi.myext");

Fișierul va avea extensia .myext, iar Java îl va percepe la fel ca pe orice fișier binar. 👌

După ce am învățat cum se utilizează clasele FileInputStream și FileOutputStream pentru citirea și scrierea simplă a octeților, următorul pas este să folosim clase care ne permit să lucrăm cu date structurate: DataInputStream și DataOutputStream, care extind funcționalitatea fluxurilor binare pentru a citi și scrie direct tipuri de date primitive. 

Clasa DataInputStream permite citirea octeţilor din flux şi convertirea lor la un tip dorit.Constructor: 

DataInputStream(InputStream fluxIntrare);

Metode:
1) boolead readBoolean() throws IOException;
2) byte readByte() throws IOException;
3) short readShort() throws IOException;
4) char readChar() throws IOException;
5) int readInt() throws IOException;
6) long readLong() throws IOException;
7) float readFloat() throws IOException;
8) double readDouble() throws IOException;
9) String readUTF() throws IOException;
10)void close() throws IOException;

Clasa DataOutputStream converteşte valorile primitive sau șiruri de caractere în octeţi şi le transmite la ieşire prin flux. Constructor:

 DataOutputStream(OutputStream fluxIesire);

Metode:
1) void writeBoolean(boolean b) throws IOException;
2) void writeByte(int b) throws IOException;
3) void writeBytes(String s) throws IOException;
4) void writeShort(int s) throws IOException;
5) void writeChar(int c) throws IOException;
6) void writeInt(int i) throws IOException;
7) void writeLong(long l) throws IOException;
8) void writeFloat(float f) throws IOException;
9) void writeDouble(double d) throws IOException;
10) void writeUTF(String s) throws IOException; 

Exemplul 2. Programul va crea fișierul binar numit out.dat folosind DataOutputStream. Va scrie în fișier numele și nota a trei elevi folosind metodele writeUTF() și writeDouble(). Apoi va citi din fișier datele cu ajutorul metodelor clasei DataInputStream și va afișa pe ecran numele și nota fiecărui elev. 

import java.io.*;
public class Main {
    public static void main(String [] args) throws IOException{
        DataOutputStream output=new DataOutputStream(new FileOutputStream("out.dat"));
        output.writeUTF("Mihai");    output.writeDouble(9.56);
        output.writeUTF("Ion");      output.writeDouble(9.81);
        output.writeUTF("Maria");    output.writeDouble(9.60);
        output.close();

        DataInputStream input=new DataInputStream(new FileInputStream("out.dat"));
        System.out.println(input.readUTF()+" "+input.readDouble());
        System.out.println(input.readUTF()+" "+input.readDouble());
        System.out.println(input.readUTF()+" "+input.readDouble());
        input.close();
    }
}

Exemplul 3. Programul va crea fișierul binar numit out.dat folosind DataOutputStream. Va scrie în fișier numele și nota citite de la tastatură a n elevi. Apoi va citi din fișier datele cu ajutorul metodelor clasei DataInputStream și va afișa pe ecran numele și nota fiecărui elev. 

import java.io.*;
import java.util.Scanner;
public class Main {
 public static void main(String[] args) throws IOException {
   Scanner scanner = new Scanner(System.in);
    System.out.print("Introduceți numărul de elevi: ");
    int n = scanner.nextInt();
    scanner.nextLine(); // consumă Enter-ul rămas după nextInt()

    DataOutputStream output = new DataOutputStream(new FileOutputStream("out.dat"));
      for (int i = 0; i < n; i++) {
        System.out.print("Introduceți numele elevului " + (i+1) + ": ");
        String nume = scanner.nextLine();
        System.out.print("Introduceți nota elevului " + (i+1) + ": ");
        double nota = scanner.nextDouble();
        scanner.nextLine(); // consumă Enter-ul rămas
        output.writeUTF(nume);
        output.writeDouble(nota);
      }
    output.close();

    DataInputStream input = new DataInputStream(new FileInputStream("out.dat"));
    System.out.println("\nLista elevilor cu notele lor:");
     try {
      for (int i = 0; i < n; i++) {
         String nume = input.readUTF();
         double nota = input.readDouble();
         System.out.println(nume + " " + nota);
      }} catch (EOFException e) {
            // Sfârșitul fișierului
        }
      input.close();
}}

Fișierul binar out.dat a fost creat și în el au fost salvate datele introduse de la tastatură. Deoarece este un fișier binar, acesta nu poate fi citit direct cu un editor de text, de aceea trebuie să oferim o modalitate de a verifica ce informații au fost stocate.
În acest scop, în metoda main() sunt incluse și instrucțiuni care citesc datele din fișier și le afișează pe ecran, astfel încât să putem vedea conținutul salvat.

Limbajul Java oferă oportunități de a salva și starea obiectelor în fișiere binare. De ce apare această necesitate? 

Atunci când lucrăm cu obiecte, în mod normal, acestea există doar pe durata execuției programului. După terminarea programului sau atunci când nu mai există referințe către ele, obiectele sunt eliminate automat din memorie de Garbage Collector.
Există însă situații în care dorim ca datele unui obiect să fie păstrate și după închiderea programului, pentru a putea fi utilizate ulterior.
În astfel de cazuri, limbajul Java permite salvarea obiectelor într-un fișier în format de obiect, printr-un proces numit serializare. Astfel, starea obiectului este salvată într-un fișier și poate fi refăcută mai târziu în program, atunci când este nevoie.

Dar despre serializare vom discuta într-o altă postare! 💬

Succes!

❤️

Lecție practică. Instrucțiunea switch

1. Planificator de activități zilnice. Scrieți un program care cu ajutorul instrucțiunii switch va afișa o activitate în funcție de ziua săptămânii.  De la tastatură se va citi o zi a săptămânii (ex: „Luni”, „Simbata”) și se va afișa activitatea corespunzătoare, de exemplu:

-        „Luni – Încep școala cu energie”,

-        „Sâmbătă – Merg în parc”,

-        „Duminică – Odihnă și planificare”, etc.

2.  Meniu pentru cafenea digitală.  Scrieți un program care citește de la tastatură o alegere numerică între 1 și 4:

-        1 – Cafea

-        2 – Ceai

-        3 – Ciocolată caldă

-        4 – Apă

Programul va afișa prețul băuturii selectate. Dacă utilizatorul introduce o opțiune invalidă, afișează „Opțiune inexistentă”. Utilizați switch cu default.

3.   Meteo. Scrieți un program care va citi de la tastatură starea vremii („soare”, „ploaie”, „ninsoare”, „vânt”) după care va afișa mesajul potrivit:

-        Dacă e „ploaie” sau „ninsoare” – „Ia umbrelă sau haină impermeabilă.”

-        Dacă e „soare” – „Poartă ochelari de soare.”

-        Dacă e „vânt” – „Verifică prognoza, poate fi furtună.”

Utilizați switch cu selector de tip String și mai multor etichete case pentru același rezultat.

4.  Beneficii abonamente. Scrieți un program care citește de la tastatură un tip de abonament introdus de utilizator ("Free", "Standard", "Premium") și afișează ce beneficii are abonamentul citit:

-        Free – acces limitat;

-        Standard – acces la toate cursurile;

-        Premium – acces complet + certificate.

Programați și cazul în care utilizatorul introduce un abonament necunoscut.

5.   Reducere la cumpărături. Scrieți un program care citește de la tastatură categoria clientului ("elev", "student", "profesor", "pensionar", sau altă categorie) și suma totală a cumpărăturilor. Programul va afișa procentul de reducere corespunzător și suma finală care trebuie achitată după aplicarea reducerii.

Reduceri:

-      Elev: 25%

-      Student: 15%

-      Profesor: 10%

-      Pensionar: 20%

-      alte categorii: 0%

6.     Planificator inteligent. Scrieți un program care citește de la tastatură ora curentă (număr între 0 și 23). În funcție de intervalul orei, programul afișează o activitate recomandată:

Interval orar	Activitate recomandată
6–8	„Trezire și mic dejun”
9–13	„Cursuri / lucru activ”
14–17	„Proiecte și exerciții practice”
18–21	„Relaxare sau activități fizice”
22–23, 0–5	„Timp de odihnă”

Creează un switch care grupează cazurile folosind mai multe valori case per bloc. Dacă ora introdusă este invalidă (negativă sau > 23), afișează un mesaj de eroare.

7.  Curier Express. Scrieți un program care citește de la tastatură tipul localității: "urban", "suburban", "rural" și greutatea coletului în kilograme. Programul va calcula și afișa: tipul livrării, costul total, un mesaj personalizat: „Mulțumim pentru alegerea serviciului nostru!”. Se cunoaște că taxele de livrare sunt următoarele:

-      Urban: 20 lei + 2 lei/kg

-      Suburban: 30 lei + 2.5 lei/kg

-      Rural: 40 lei + 3 lei/kg

8.   Convertor zile în activități zilnice. Scrieți un program care citește de la tastatură un număr întreg zi (1–7) și o perioadă a zilei: M (dimineața), P (după-amiaza), S (seara). Folosind switch pentru ziua săptămânii și, dacă e necesar, pe perioadă, se afișează activitatea recomandată:

Dimineața	După-amiaza	Seara
„Școală / muncă”	„Proiecte / teme”	„Relaxare”
„Sport / hobby”	„Vizită prieteni”	„Film / relaxare”
„Odihnă”	„Planificare săptămână”	„Odihnă”

De exemplu pentru Zi: 6 și Perioada: P se va afișa Activitate recomandată: Vizită prieteni.

Dacă ziua sau perioada introdusă este invalidă, se va afișa mesaj de eroare.

9.  Restaurant digital. Un restaurant digital recomandă meniuri în funcție de tipul clientului și nivelul de activitate fizică:

-      Tip client: "adult", "copil", "senior"

-      Activitate fizică: "scăzută", "moderată", "ridicată"

-      Valori calorice recomandate:

Tip client	Scăzută	Moderată	Ridicată
adult	1800	2200	2500
copil	1200	1500	1800
senior	1500	1800	2000

Elaborați un program care, folosind instrucțiunea switch, va citi de la tastatură tipul clientului și activitatea fizică și va recomanda câte calorii trebuie să conțină meniul acestuia. De exemplu pentru datele de intrare Tip: adult și Activitate: moderată se va afișa  Calorii recomandate: 2200 kcal.

10. Calculator de prețuri cu TVA diferențiat. Un magazin vinde produse din mai multe categorii, fiecare cu un TVA diferit:

-      "alimentar" → 5% TVA

-      "electronice" → 19% TVA

-      "haine" → 9% TVA

-      "carte" → 5% TVA

Elaborați un program care va citi categoria produsului și prețul fără TVA. Folosind instrucțiunea  switch programul va determina  TVA-ul și va calcula și afișa prețul final cu TVA. Dacă categoria introdusă nu există, afișează „Categorie invalidă”. De exemplu, pentru datele de intrare Categorie: electronice și Preț: 1000 se va afișa TVA: 19%  Preț final: 1190.0 lei.

11. Calcularea tarifelor dinamice pentru transport urban. Un sistem de transport urban calculează tariful biletelor în funcție de:

-      Categoria pasagerului: "adult", "elev", "student", "pensionar"

-      Tipul transportului: "autobuz", "troleibuz", "tramvai", "metrou"

-      Zona de deplasare: 1, 2 sau 3

Tarife de bază per categorie și tip transport: 

Categorie	Autobuz	Troleibuz	Tramvai	Metrou
adult	4	4	5	6
elev	2	2	2.5	3
student	3	3	3.5	4
pensionar	1.5	1.5	2	2.5

Dacă zona de deplasare este mai mare decât valoarea 1, se aplică un adaos de 1.5 lei per zonă suplimentară.

Dacă tipul de transport sau categoria este invalid, se afișează mesaj de eroare.

De exemplu pentru datele de intrare Categorie: adult Transport: tramvai  Zona: 2 se va afișa Tarif final: 6.5 lei

 

 

Să aveți o zi deosebită! 

❤️