MINISTERUL EDUCAȚIEI ȘI CERCETĂRII

AL REPUBLICII MOLDOVA
Universitatea Tehnică a Moldovei
Facultatea Calculatoare, Informatică şi Microelectronică
Departamentul Informatică și Ingineria Sistemelor

Raport
pentru lucrarea de laborator Nr.2

la cursul de “Tehnici avansate de programare”

Tema: Moștenirea

Verificat:

Chișinău – 2023
 Cuprins
TEMA LUCRĂRII..............................................................................................................3
SCOPUL LUCRĂRII:........................................................................................................3
ETAPELE DE REALIZARE:............................................................................................3
SARCINA 1:........................................................................................................................3
CODUL:..............................................................................................................................3
OUTPUT:............................................................................................................................4
CONCLUZII........................................................................................................................6
 Lucrare de laborator nr. 1
Tema lucrării: Moștenirea
Scopul lucrării:
 Însușirea principiilor de moștenire a claselor;
1. Condiția problemei 1
Varianta 1
Scrieți un cod care ar conține două clase legate prin moștenire acestea să fie funcționale și
să satisfacă următoarele cerințe:
• Clasa de bază să conțină 3 constructori și 2 metode
• Clasa derivată să conțină 2 constructori și 3 metode
• Constructorii și metodele să fie apelați cu cuvintele cheie this și super
Creați următoarele obiecte în metoda main():
a) Obiectul clase de bază folosind constructorul clasei de bază;
b) Obiectul clase derivate folosind constructorul clasei de bază;
c) Obiectul clase de derivate folosind constructorul clasei derivate;
d) Obiectul clase de bază folosind constructorul clasei derivate;
Metodele declarate să fie apelate utilizând toate obiectele existente;
Codul:
class Time {
private int hours;
private int minutes;
public Time() {
this.hours = 0;
this.minutes = 0;
}
public Time(int hours, int minutes) {
this.hours = hours;
this.minutes = minutes;
}
public Time(Time time) {
this.hours = time.hours;
this.minutes = time.minutes;
}
public int getHours() {
return hours;
}
public void setHours(int hours) {
this.hours = hours;
}
public void setMinutes(int minutes) {
this.minutes = minutes;
 }
public void printTime() {
System.out.println("Ora: " + hours + ":" + minutes +" minute");
}
}
class DayTime extends Time {
private String daytime = "Necunoscut";
public DayTime() {
super();
}
public DayTime(int hours, int minutes) {
super(hours, minutes);
}
public void identDayTime() {
int hours = getHours();
if ((hours >= 0 && hours < 4) || (hours >= 21 )){
daytime = "Noapte";
}
if (hours >= 4 && hours < 12){
daytime = "Dimineață";
}
if (hours >= 12 && hours < 17){
daytime = "Zi";
}
if (hours >= 17 && hours < 21){
daytime = "Seară";
}
}
public void printDayTime() {
System.out.println("Timpul zilei: " + daytime);
}
}
public class Main {
public static void main(String[] args) {
// a) Obiectul clasei de bază folosind constructorul clasei de
bază;
Time time1 = new Time();
time1.printTime();
// b) Obiectul clasei derivate folosind constructorul clasei de
bază;
DayTime daytime1 = new DayTime();
daytime1.printTime();
// c) Obiectul clasei derivate folosind constructorul clasei
derivate;
DayTime daytime2 = new DayTime(17, 30);
 daytime2.printTime();
// d) Obiectul clasei de bază folosind constructorul clasei
derivate.
Time time2 = new DayTime();
time2.printTime();
// Apelarea metodelor
time1.setHours(3);
time1.setMinutes(45);
time1.printTime();

daytime1.setHours(11);
daytime1.setMinutes(15);
daytime1.printTime();
daytime1.identDayTime();
daytime1.printDayTime();

daytime2.setHours(3);
daytime2.setMinutes(15);
daytime2.printDayTime();
}
}
Output:
În figura 1 putem observa că ora și minutele sunt 0 ore și 0 minute deoarece în clasa de
bază am inițializat obiectul minutes și hours cu valoare 0.

Figura 1.1. Timpul inițial

Pentru a da valoare acestor obiecte am utilizat cuvântul cheie this care se referă la obiectul
curent.

Figura 1.2. Timp modificat cu constructorul clasei derivate

În figura 2, putem observa că timpul extras la ecran este 17 ore și 30 minute deoarece
utilizând constructorul clasei derivate creăm un obiect de timpul clasei TimeSubstract care
moștenește clasa de bază Time, pe care îl inițializăm cu valorile 17 și 30.

Figura 1.3. Setarea timpului cu metodele clasei de bază

Utilizând metodele din clasa de bază sau clasa părinte setăm timpul la valorile: ora 5 și 15
minute.
 Figura 1.4. Timpul zilei
Pentru a identifica timpul zilei este folosită metoda identDayTime care, în dependență de
ora setată obiectului, află în ce interval a zilei este această oră și atribuie variabilei daytime o
anumită valoare.

Figura 1.5. Timpul zilei necunoscut

În cazul în care obiectului nu este setată nici o oră și este apelată metoda identDayTime,
variabilei daytime i se atribuie valoarea default „Necunoscut”.

2.Sarcina 2:
Să se creeze clasa roata, care conține rază. Determinați constructorii și metodele de acces.
Creați clasa automobil, care conține roți și un câmp care reprezintă firma producătoare. Creați o
clasă derivată autocamion care se deosebește prin tonaj. Determinați constructorii, destructorul și
alte funcții necesare.
Codul:
import java.util.Scanner;

class Roata {
private int raza;

public Roata() {
raza = 0;
}

public Roata(int r) {
raza = r;
}

public int getRaza() {

return raza;
}

public void showRoata() {

System.out.println("Roata: " + raza);
}
}
class Automobil extends Roata {
private String firma;

public Automobil() {
super();
firma = "NoName";
}

public Automobil(int r, String nume) {

super(r);
firma = nume;
}

public void showAuto() {

System.out.println("Firma: " + firma);
}
}

class Autocamion extends Automobil {

private float tonaj;

public Autocamion() {
super();
tonaj = 0;
}

public Autocamion(int r, String nume, float t) {

super(r, nume);
tonaj = t;
}

public void show() {

this.showRoata();
this.showAuto();
System.out.println("Tonajul: " + tonaj);
}
}
 public class Main {
public static void main(String[] args) {
Autocamion a1 = new Autocamion();
Scanner scanner = new Scanner(System.in);
int r;
String nume;
float t;
System.out.print("Introduceti raza: ");
r = scanner.nextInt();
scanner.nextLine();
System.out.print("Introduceti firma: ");
nume = scanner.nextLine();
System.out.print("Introduceti tonajul: ");
t = scanner.nextFloat();
Autocamion a2 = new Autocamion(r, nume, t);
a1.show();
System.out.println();
a2.show();
}
}
Output:

Figura 2.1. Meniul

La rularea acestui cod, în consolă va fi solicitată introducerea razei, firmei și tonajului
pentru un autocamion. Raza este atribut a clasei roată. Firma este un atribut a clasei automobil, care
moștenește atributele și metodele clasei roată. Tonajul este atribut a clasei autocamion, acesta la
rândul său moștenește de la clasa automobil.

Figura 2.2. Opțiunea 1

Declararea obiectului fără setarea valorilor, obiectul va fi creat implicit și toate atributele
vor primi valori default(0 sau NoName pentru string).
 Figura 2.3. Opțiunea 2
Obiectul care a fost declarat cu valorile introduse de la tastatură a stocat toate datele și,
prin intermediul metodei show, afișează toate datele în consolă.
 CONCLUZII
La finele realizării acestei lucrări de laborator am studiat posibilitățile și mijloacele
limbajului Java pentru programarea claselor, studiind cum se lucrează cu moștenirea. În Java,
"super" este un cuvânt cheie care se referă la clasa părinte a unei clase sau la constructorul său.
Când o clasă derivată moștenește o clasă de bază, aceasta poate folosi cuvântul cheie "super"
pentru a accesa membrii clasei părinte, precum variabilele de instanță sau metodele. Astfel, se
poate extinde funcționalitatea clasei părinte sau se pot suprascrie metodele acesteia. Cuvântului
cheie "this" este util în situațiile în care este necesară o referință la obiectul curent în interiorul
metodelor și constructorilor. De asemenea, clasele pot fi moștenite, astfel încât să poată fi create
noi clase care moștenesc proprietățile si comportamentele unei clase existente. În concluzie,
moștenirea poate fi utilizată pentru a reduce cantitatea de cod duplicat, iar cuvintele cheie "super"
și "this" sunt utilizate pentru a accesa membrii clasei părinte și respectiv ai clasei curente.