UNIVERSITATEA TEHNICĂ A MOLDOVEI

Facultatea Calcultoare, Informatică și Microelectronică

Departamentul Informatică și Ingineria Sistemelor

RAPORT
la lucrarea de laborator nr.2
la Programarea Orientată pe Obiecte

Tema : Clase și obiecte. Constructori și destructor

pentru clasa.

Efectuat de studenta grupei TI-224: Lungu Constantin

Verificat de către profesorul: Astafi Valentina

 Chisinau, 2023
Scopul lucrării: Familiarizarea cu conceptele de bază ale programării orientate pe obiect,în
special cu clasele și obiectele, precum și cu constructorii și destructorii pentru clase.

Obiectivele lucrării:
● Înțelegerea conceptului de clasă și obiect în programarea orientată pe obiect;
● Posibilitatea de a defini și utiliza constructori pentru clase;
● Posibilitatea de a defini și utiliza destructori pentru clase;
● Utilizarea structurilor.
Sarcini practice:

public class Fantana {

private double inaltime;
private double latime;
private double adancime;

// Constructorul care primește valorile ca argumente

public Fantana(double inaltime, double latime, double adancime) {
this.inaltime = inaltime;
this.latime = latime;
this.adancime = adancime;
}

// Alte metode pentru a accesa și modifica variabilele de instanță, dacă este necesar

public double getInaltime() {

return inaltime;
}

public double getLatime() {

return latime;
}
public double getAdancime() {
return adancime;
}

public void setInaltime(double inaltime) {

this.inaltime = inaltime;
}

public void setLatime(double latime) {

this.latime = latime;
}

public void setAdancime(double adancime) {

this.adancime = adancime;
}

public static void main(String[] args) {

// Modul 1: Instanțierea unei fantani cu valorile specificate direct
Fantana prima = new Fantana(10.0, 5.0, 7.0);

// Modul 2: Citirea valorilor de la utilizator

java.util.Scanner scanner = new java.util.Scanner(System.in);
System.out.println("Introduceți înălțimea fantanei 2: ");
double inaltime2 = scanner.nextDouble();
System.out.println("Introduceți lățimea fantanei 2: ");
double latime2 = scanner.nextDouble();
System.out.println("Introduceți adâncimea fantanei 2: ");
double adancime2 = scanner.nextDouble();
Fantana doua = new Fantana(inaltime2, latime2, adancime2);

// Modul 3: Instanțierea unei cutii cu valorile implicite

Fantana treia = new Fantana(0.0, 0.0, 0.0); // Puteți seta valorile implicite aici
 // Afișarea informațiilor despre cutiile create
System.out.println("Fantana 1: Inaltime = " + prima.getInaltime() + ", Latime = " +
prima.getLatime() + ", Adancime = " + prima.getAdancime());
System.out.println("Fantana 2: Inaltime = " + doua.getInaltime() + ", Latime = " +
doua.getLatime() + ", Adancime = " + doua.getAdancime());
System.out.println("Fantana 3: Inaltime = " + treia.getInaltime() + ", Latime = " +
treia.getLatime() + ", Adancime = " + treia.getAdancime());

// Închide scanner-ul
scanner.close();
}
}

Sarcina 2 Să se creeze un program, utilizând structura, un tip abstract de date ce simulează o lista
(queue).
****************

import java.util.LinkedList;
import java.util.Scanner;

class Queue<T> {
private LinkedList<T> list = new LinkedList<T>();

// Adaugă un element la sfârșitul listei (coada)

public void enqueue(T item) {
list.addLast(item);
}

// Adaugă un element la o poziție specifică

public void addAtIndex(int index, T item) {
if (index >= 0 && index <= list.size()) {
list.add(index, item);
 } else {
System.out.println("Index invalid.");
}
}

// Șterge primul element din listă (coadă)

public void dequeue() {
if (!list.isEmpty()) {
list.removeFirst();
} else {
System.out.println("Coadă goală.");
}
}

// Șterge elementul de la o poziție specifică

public void removeAtIndex(int index) {
if (index >= 0 && index < list.size()) {
list.remove(index);
} else {
System.out.println("Index invalid.");
}
}

// Schimbă două elemente în listă

public void swap(int index1, int index2) {
if (index1 >= 0 && index1 < list.size() && index2 >= 0 && index2 < list.size()) {
T temp = list.get(index1);
list.set(index1, list.get(index2));
list.set(index2, temp);
} else {
System.out.println("Indecși invalidi.");
}
}
 // Afișează lista (coada)
public void display() {
System.out.println("Lista (Coadă): " + list);
}
}

public class Main {

public static void main(String[] args) {
Queue<Integer> queue = new Queue<>();
Scanner scanner = new Scanner(System.in);

while (true) {
System.out.println("Meniu:");
System.out.println("1. Adăugare element la sfârșit");
System.out.println("2. Adăugare element la poziție specifică");
System.out.println("3. Ștergere primul element");
System.out.println("4. Ștergere element de la poziție specifică");
System.out.println("5. Schimbare a două elemente");
System.out.println("6. Afișare coadă");
System.out.println("0. Ieșire");

System.out.print("Alegeți opțiunea: ");

int choice = scanner.nextInt();

switch (choice) {
case 1:
System.out.print("Introduceți elementul de adăugat: ");
int element1 = scanner.nextInt();
queue.enqueue(element1);
break;
case 2:
System.out.print("Introduceți poziția: ");
 int position = scanner.nextInt();
System.out.print("Introduceți elementul de adăugat: ");
int element2 = scanner.nextInt();
queue.addAtIndex(position, element2);
break;
case 3:
queue.dequeue();
break;
case 4:
System.out.print("Introduceți poziția elementului de șters: ");
int positionToRemove = scanner.nextInt();
queue.removeAtIndex(positionToRemove);
break;
case 5:
System.out.print("Introduceți poziția primului element: ");
int index1 = scanner.nextInt();
System.out.print("Introduceți poziția celui de-al doilea element: ");
int index2 = scanner.nextInt();
queue.swap(index1, index2);
break;
case 6:
queue.display();
break;
case 0:
scanner.close();
System.exit(0);
default:
System.out.println("Opțiune invalidă.");
break;
}
}
}
}
 Concluzie:
Am inteles conceptul de clasă și obiect în programarea orientată pe obiect;
●Am avut posibilitatea de a defini și utiliza constructori pentru clase;
●Am avut posibilitatea de a defini și utiliza destructori pentru clase;
● Am putut utiliza structuri.

În concluzie, Java oferă un model solid pentru lucrul cu clase și obiecte, iar constructorii
sunt instrumente esențiale pentru inițializarea obiectelor. Cu toate acestea, absența destructorilor
în Java și utilizarea unui colector de gunoi ușurează gestionarea memoriei și previne scurgerile
de memorie, făcând Java o limbaj de programare mai sigur și mai ușor de utilizat în ceea ce
privește managementul memoriei.