Sunteți pe pagina 1din 15

Ministerul Educaţiei al Republicii Moldova

Universitatea de Stat din Moldova


Facultatea de Matematică şi Informatică
Departamentul “Informatica »

Dare de seama la „Java”

Lucrare de laborator № 2

Tema : „Moştenirea claselor în Java”

Varianta: № 04

Clasa: „Figura”

Efectuat: studenta grupei I1801

Tintaru Valeria

Verificat: lect.univers., magistru in inform.

Epifanova Irina .

- Chişinău 2020 -
Formularea problemei:

De descries în limbajul Java ierarhia de clase Figura → Pătrat → Dreptunghi → Paralelipiped

De descris clasa de bază ca o clasă abstractă, declarând în ea una sau mai multe funcții abstracte.

De descris interfața. De a preciza în ea funcția abstractă de afișare la ecran a tuturor câmpurilor clasei. De implementat
interfața în câteva clase din ierarhie.

Câmpurile obligatorii:
- culoarea liniilor Figurii
- lungimea laturii Pătratului
- lățimea Dreptunghiului
- înălțimea Paralelipipedului

Câmpurile neobligatorii: toate care Vă pot trece prin cap :)...

De descris pentru fiecare clasă din ierarhie următoarele:


- Câțiva constructori
- Funcțiile de acces la câmpurile clasei, și funcțiile de setare a lor.

De descris în clasa Figura funcția virtuală de calcul al perimetrului figurii.

Pentru fiecare clasă din ierarhie de redefinit funcția de calcul al ariei figurii(pentru paralelipiped – adică pentru cutia
spațială :) – asta va fi aria suprafeței)

Pentru toate clasele din ierarhie de redefinit funcția care calculează suma a două figuri de același tip (rezultatul de
păstrat în primul operand)

Pentru toate clasele din ierarhie de redefinit funcția, care efectuează compararea figurilor de același tip.

Pentru clasa Paralelipiped de descris funcția diferenței dintre 2 cutii (în fiecare câmp al cutiei noi se va scrie diferența
dintre câmpurile respective ale operanzilor, în afară de culoarea liniilor, desigur :))

În funcția main() de creat vectorul dinamic cu exemplarele tuturor figurilor descrise mai sus , dând ca tipul de bază – clasa
origine, și de inițializat aceste elemente cu obiectele tuturor claselor moștenite. După – de afișat la ecran printr-un ciclu
câmpurile tuturor obiectelor create. Pentru fiecare figura de calculat aria ei. De desenat fiecare figură creată. De adunat
câteva perechi de figuri tuturor tipurilor. Pe cele schimbate – de desenat din nou. De comparat câteva perechi de figuri de
același tip. De găsit diferența dintr-o pereche de paralelipipezi. Rezultatul – noul paralelipiped – de înscris într-un fișier
textual împreună cu operanzii. De introdus datele figurii de la tastatură, de a crea-o cu constructor cu parametri și de
calculat perimetrul ei, după ce de a-l afișa la ecran.

După ce totul a fost terminat fără greșeli — de spus “URRRRRRAAAAAAA ! ! !” și de prezintat profesorului al doilea
laborator. :)

În lucrare de laborator (obligatoriu !) trebuie sa fie prezent apelul constructorului clasei-părinte(celui implicit și cu
parametri), apelul funcției simple clasei-părinte (nu a constructorului), macară unul dintre elementele unuia dintre clase
trebuie să fie declarat ca final, și macară una dintre variabilile clasei trebuie sa fie constantă(statică)
Exemplul lucrării practice (listingul programului)

Figura.java

import java.io.*;

public abstract class Figura implements Interfata

{
String nume;
String culoare;

//CONSTRUCTORI
Figura()
{
System.out.print("Numele figurii: ");
nume = readString();
System.out.print("Culoarea figurii: ");
culoare = readString();
}

Figura(String n)
{
nume = n;
culoare = "negru";
}

//METODE DE ACCES
final String get_nume()
{
return nume;
}

final String get_culoare()


{
return culoare;
}

//METODE DE SETARE
final void set_nume(String nume_nou)
{
nume=nume_nou;
}

final void set_culoare(String culoare_nou)


{
culoare=culoare_nou;
}

public void afisare()


{
System.out.println("\n\t********************");
System.out.print("\t* AFISARE FIGURA *");
System.out.println("\n\t********************");
System.out.println(" Nume figura: "+nume);
System.out.println(" Culoare figura: "+culoare);
}
public abstract double perimetru();

public abstract double aria();

//public void suma(){}

//public void comparare(){}

static String readString()


{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String str=" ";
try{str=br.readLine();}
catch (Exception l){}
return str;
}

static double readDouble()


{
return (Double.valueOf(readString())).doubleValue();
}

static int readInt()


{
return (Integer.valueOf(readString())).intValue();
}

Patrat.java

public class Patrat extends Figura


{
double latura;

//CONSTRUCTORII
Patrat()
{
super();
do
{
System.out.print("Latura patratului: ");
latura=readDouble();
if (latura<0)
System.out.print("Error! Mai incercati ");
}
while (latura<0);
}

Patrat(String n, double l)
{
super(n);
latura=l;
}
//METODE DE ACCES
final double get_latura()
{
return latura;
}

//METODE DE SETARE
final void set_latura(double latura_nou)
{
if (latura_nou>0)
latura=latura_nou;
}

public void afisare()


{
super.afisare();
System.out.println(" Lungimea: "+latura);
}

public double perimetru()


{
return (4*latura);
}

public double aria()


{
return (latura*latura);
}

public void comparare(Patrat p1, Patrat p2)


{
System.out.println("\n\tCOMPARARE");
if(p1.aria() > p2.aria())
System.out.println(p1.nume+" este mai mare decit "+p2.nume);
else
System.out.println(p1.nume+" este mai mic decit "+p2.nume);
}

public void suma(Patrat p1)


{
System.out.println("\n\tSUMA");
System.out.println("Numele patratului nou este: "+this.nume);
System.out.println("Culoarea patratlui nou este: "+this.culoare);
System.out.println("Latura patratului nou este: "+(this.latura+=p1.latura));
}
}

Dreptunghi.java

public class Dreptunghi extends Patrat


{
double latime;

//CONSTRUCTORI
Dreptunghi()
{
super();
do
{
System.out.print("Latimea dreptunghiului: ");
latime=readDouble();
if (latime<0)
System.out.print("Error! Mai incercati");
}
while (latime<0);
}

Dreptunghi(String n, double l, double lat)


{
super(n,l);
latime=lat;
}

//METODE DE ACCES
final double get_latime()
{
return latime;
}

//METODE DE SETARE
final void set_latime(double latime_nou)
{
if (latime_nou>0)
latime=latime_nou;
}

public void afisare()


{
super.afisare();
System.out.println(" Latimea: "+latime);
}

public double perimetru()


{
return(2*latura+2*latime);
}

public double aria()


{
return (latura*latime);
}

public void comparare(Dreptunghi d1, Dreptunghi d2)


{
System.out.println("\n\tCOMPARARE");
if(d1.perimetru()>d2.perimetru())
System.out.println(d1.nume+" este mai mare decit "+d2.nume);
else
System.out.println(d1.nume+" este mai mic decit "+d2.nume);
}

public void suma(Dreptunghi d1)


{
System.out.println("\n\tSUMA");
System.out.println("Numele dreptunghiului nou este: "+this.nume);
System.out.println("Culoarea dreptunghiului nou este: "+this.culoare);
System.out.println("Lungimea dreptunghiului nou este: "+(this.latura+=d1.latura));
System.out.println("Latimea dreptnghiului nou este: "+(this.latime+=d1.latime));
}
}

Paralelepiped.java

import java.io.*;

public class Paralelepiped extends Dreptunghi implements Interfata


{
double inaltime;

//CONSTRUCTORI
Paralelepiped()
{
super();
do
{
System.out.print("Inaltimea paralelepipedului: ");
inaltime=readDouble();
if (inaltime<0)
System.out.print("Error! Mai incercati");
}
while (inaltime<0);
}

Paralelepiped(String n, double l, double lat, double inal)


{
super(n,l,lat);
inaltime=inal;
}

//METODE DE ACCES
final double get_inaltime()
{
return inaltime;
}

//METODE DE SETARE
final void set_inaltime(double inaltime_nou)
{
if (inaltime_nou>0)
inaltime=inaltime_nou;
}

public void afisare()


{
super.afisare();
System.out.println(" Inaltimea: "+inaltime);
}
public double perimetru()
{
return (4*latura+4*latime+4*inaltime);
}

public double aria()


{
return (latura*latime*2+latura*inaltime*2+latime*inaltime*2);
}

public double volum()


{
return (latura*latime*inaltime);
}

public void comparare(Paralelepiped par1, Paralelepiped par2)


{
System.out.println("\n\tCOMPARARE");
if(par1.volum()>par2.volum())
System.out.println(par1.nume+" este mai mare decit "+par2.nume);
else
System.out.println(par1.nume+" este mai mic decit "+par2.nume);
}

public void suma(Paralelepiped d1)


{
System.out.println("\n\tSUMA");
System.out.println("Numele paralelepipedului nou este: "+this.nume);
System.out.println("Culoarea paralelepipedului nou este: "+this.culoare);
System.out.println("Lungimea paralelepipedului nou este: "+
(this.latura+=d1.latura));
System.out.println("Latimea paralelepipedului nou este: "+
(this.latime+=d1.latime));
System.out.println("Inaltimea paralelepipedului nou este: "+
(this.inaltime+=d1.inaltime));
}

public void diferenta(Paralelepiped p1, Paralelepiped p2)


{

System.out.println("\n\tDIFERENTA");
if (p1.latura>p2.latura)
System.out.println(" Lungimea paralelepipedului: "+(p1.latura-=p2.latura));

else
System.out.println(" Lungimea paralelepipedului: "+(p2.latura-=p1.latura));

if (p1.latime>p2.latime)
System.out.println(" Latimea paralelepipedului: "+(p1.latime-=p2.latime));

else
System.out.println(" Latimea paralelepipedului: "+(p2.latime-=p1.latime));

if (p1.inaltime>p2.inaltime)
System.out.println(" Inaltimea paralelepipedului: "+(p1.inaltime-
=p2.inaltime));

else
System.out.println(" Inaltimea paralelepipedului: "+(p2.inaltime-
=p1.inaltime));
}

public void inscrie_dif(Paralelepiped p1, Paralelepiped p2)


{
try
{
FileOutputStream fOut = new FileOutputStream("dif.txt");
PrintStream flux = new PrintStream(fOut);
flux.println("\n\tDIFERENTA");

if (p1.latura>p2.latura)
flux.println(" Lungimea paralelepipedului: "+(p1.latura-=p2.latura));

else
flux.println(" Lungimea paralelepipedului: "+(p2.latura-=p1.latura));

if (p1.latime>p2.latime)
flux.println(" Latimea paralelepipedului: "+(p1.latime-=p2.latime));

else
flux.println(" Latimea paralelepipedului: "+(p2.latime-=p1.latime));

if (p1.inaltime>p2.inaltime)
flux.println(" Inaltimea paralelepipedului: "+(p1.inaltime-=p2.inaltime));

else
flux.println(" Inaltimea paralelepipedului: "+(p2.inaltime-=p1.inaltime));

flux.close();
fOut.close();
} catch (IOException ex)
{
System.out.println("Fisierul nnu a fost creat");
System.exit(1);
}
}
}

Interfata.java

public interface Interfata


{
public void afisare();

Main.java

public class Main {

public static void main(String[] args) {


// TODO Auto-generated method stub
Figura vector[]=new Figura[3];
for (int i=0; i<3; i+=3)
{
vector[i]=new Patrat("Patrat",5);
vector[i+1]=new Dreptunghi("Dreptunghi",6,8);
vector[i+2]=new Paralelepiped("Paralelepiped",5,9,3);
}

for (int i=0; i<3; i++)


{
vector[i].afisare();
}

for(int i=0; i<3; i++)


{
if (vector[i] instanceof Patrat)
vector[i].afisare();
}

System.out.println(" \nPerimetru fugurilor:");


for (int i=0; i<3; i++)
{
System.out.println(" Perimetrul figurii "+(i+1)+" este
"+vector[i].perimetru());
}

System.out.println(" \nAria figurilor:");


for (int i=0; i<3; i++)
{
System.out.println(" Aria figurii "+(i+1)+" este "+vector[i].aria());
}

Figura patr1=new Patrat("p1",2);


Figura patr2=new Patrat("p2",4);
Figura patr3=new Patrat("",0);
patr1.afisare();
patr2.afisare();

((Patrat)vector[0]).suma((Patrat)patr1);

((Patrat)patr3).comparare((Patrat)patr1,(Patrat)patr2);;
((Patrat)patr1).suma((Patrat)patr2);

Dreptunghi drept1=new Dreptunghi("d1",6,3);


Dreptunghi drept2=new Dreptunghi("d2",2,5);
Dreptunghi drept3=new Dreptunghi("",0,0);
drept1.afisare();
drept2.afisare();

drept3.comparare(drept1, drept2);
drept1.suma(drept2);

Figura par1=new Paralelepiped("w1",3,6,7);


Figura par2=new Paralelepiped("w2",4,9,2);
Figura par3=new Paralelepiped("",0,0,0);
par1.afisare();
par2.afisare();
((Paralelepiped)par3).comparare((Paralelepiped)par1,(Paralelepiped)par2);
((Paralelepiped)par1).suma((Paralelepiped)par2);
/*
Paralelepiped pr1=new Paralelepiped("paralelepiped1",5,8,7);
Paralelepiped pr2=new Paralelepiped("paralelepiped2",4,9,2);
Paralelepiped pr3=new Paralelepiped("",0,0,0);
pr1.afisare();
pr2.afisare();

pr3.diferenta(pr1, pr2);

Paralelepiped pr4=new Paralelepiped("paralelepiped1",5,8,7);


Paralelepiped pr5=new Paralelepiped("paralelepiped2",4,9,2);
Paralelepiped pr6=new Paralelepiped("",0,0,0);

pr6.inscrie_dif(pr4, pr5);

/*
Figura vect[]=new Figura[3];
for (int i=0; i<3; i+=3)
{
vect[i]=new Patrat();
vect[i+1]=new Dreptunghi();
vect[i+2]=new Paralelepiped();
}

for (int i=0; i<3; i++)


{
vect[i].afisare();
}
*/
}

}
Rezultatele rulării programului (testingul programului)

********************
* AFISARE FIGURA *
********************
Nume figura: Patrat
Culoare figura: negru
Lungimea: 5.0

********************
* AFISARE FIGURA *
********************
Nume figura: Dreptunghi
Culoare figura: negru
Lungimea: 6.0
Latimea: 8.0

********************
* AFISARE FIGURA *
********************
Nume figura: Paralelepiped
Culoare figura: negru
Lungimea: 5.0
Latimea: 9.0
Inaltimea: 3.0

********************
* AFISARE FIGURA *
********************
Nume figura: Patrat
Culoare figura: negru
Lungimea: 5.0

********************
* AFISARE FIGURA *
********************
Nume figura: Dreptunghi
Culoare figura: negru
Lungimea: 6.0
Latimea: 8.0

********************
* AFISARE FIGURA *
********************
Nume figura: Paralelepiped
Culoare figura: negru
Lungimea: 5.0
Latimea: 9.0
Inaltimea: 3.0

Perimetru fugurilor:
Perimetrul figurii 1 este 20.0
Perimetrul figurii 2 este 28.0
Perimetrul figurii 3 este 68.0

Aria figurilor:
Aria figurii 1 este 25.0
Aria figurii 2 este 48.0
Aria figurii 3 este 174.0

********************
* AFISARE FIGURA *
********************
Nume figura: p1
Culoare figura: negru
Lungimea: 2.0

********************
* AFISARE FIGURA *
********************
Nume figura: p2
Culoare figura: negru
Lungimea: 4.0

SUMA
Numele patratului nou este: Patrat
Culoarea patratlui nou este: negru
Latura patratului nou este: 7.0

COMPARARE
p1 este mai mic decit p2

SUMA
Numele patratului nou este: p1
Culoarea patratlui nou este: negru
Latura patratului nou este: 6.0

********************
* AFISARE FIGURA *
********************
Nume figura: d1
Culoare figura: negru
Lungimea: 6.0
Latimea: 3.0

********************
* AFISARE FIGURA *
********************
Nume figura: d2
Culoare figura: negru
Lungimea: 2.0
Latimea: 5.0

COMPARARE
d1 este mai mare decit d2

SUMA
Numele dreptunghiului nou este: d1
Culoarea dreptunghiului nou este: negru
Lungimea dreptunghiului nou este: 8.0
Latimea dreptnghiului nou este: 8.0

********************
* AFISARE FIGURA *
********************
Nume figura: w1
Culoare figura: negru
Lungimea: 3.0
Latimea: 6.0
Inaltimea: 7.0

********************
* AFISARE FIGURA *
********************
Nume figura: w2
Culoare figura: negru
Lungimea: 4.0
Latimea: 9.0
Inaltimea: 2.0

COMPARARE
w1 este mai mare decit w2

SUMA
Numele paralelepipedului nou este: w1
Culoarea paralelepipedului nou este: negru
Lungimea paralelepipedului nou este: 7.0
Latimea paralelepipedului nou este: 15.0
Inaltimea paralelepipedului nou este: 9.
Concluzii.
În aceasta lucrare am lucrat cu Eclipse. Am învaţat moştenirea în Java. Am creat clasa de bază
Figura, pe care am moştenit – o în clasa Patrat. Pe urmă de la Patrat am moştenit Dreptunghi, de la
Dreptunghi am moştenit Paralelepiped. În main am cread diferite obiecte şi le – am afisat. Am
folosit metode de calcularea ariei, perimetrului, suma a doua figuri, compararea lor ş.a.
În concluzie am învăţat moştenirea în Java.