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 № 1

Tema : „Realizarea claselor în Java”

Varianta: № 08

Clasa: „Balaur”

Efectuat: studenta grupei I1801

Tintaru Valeria

Verificat: lect.univers., magistru in inform.

Epifanova Irina .

- Chişinău 2020 -
Formularea priblemei:

De creat clasa ”Balaur” cu cîteva câmpuri.

Câmpuri obligatorii:
- Cîmp întreg, care afișează numărul total de capete ale unui balaur.
- Vector dinamic în care se păstrează informația despre coeficientul de intelect al fiecărui cap balaurului.
- Cîmp static de numere întregi unde se va păstra numărul de balauri creați.

Plus cîteva câmpuri neobligatorii: vîrsta, greutatea, forța e.t.c...

De definit trei tipuri de constructori ai acestei clase(cu alocare dinamică de memorie):

- Constructor implicit(fără parametri) – toate datele se citesc de la tastatură.
- Cîțiva constructori diferiți cu parametri.
- Constructor de copiere.

De creat metodele pentru acces şi modificarea а tuturor câmpurilor clasei (metodele set() si get()).

De definit metoda de afișare a tuturor câmpurilor clasei.

De definit metoda statică de compareție a potențialului intelectual a doi balauri folosind media aritmetica a
coeficienților de intelect al tuturor capetelor unui balaur.

De definit metoda de lupta a doi balauri unde fiecare din ei aleator sau după o careva regulă pierde cîte un cap.

În funcția main() de creat diferiți balauri folosind toți constructorii descriși anterior. De creat un vector
dinamic de balauri. De inițiat acest vetor pe părți folosind toate trei tipuri de constructori definiți. După
crearea fiecărui nou obiect al clasei ”Balaur” de afișat toate câmpurile ”exemplarului” folosind metoda
corespunzătoare din clasă. De comparat coeficienții intelectuali a cîtorva perechi de balauri. De afișat
rezultatele comparării. Angajați cîteva perechi de balauri în lupte și apoi rezultatele luptelor(adică schimbările
în datele fiecărui) deasemenea de afișat la ecran. În ciclu de afișat toată informația despre fiecare balaur din
vector. În ultimul rînd de afișat numărul de balauri născuți.

Pentru nota 10. Adaugator pentru tot ce este descris mai sus:
- un constructor care primeşte ca parametru denumirea fişierului textual (String), de unde se incarcă valori
pentru câmpurile obiectului creat.
- o funcţie care înscrie toate cîmpurile clasei în fişier, numele fisierului se indică ca parametru la intrare.
- În funcţia main pentru toate obiectele create de salvat datele în fişiere, denumirile cărora se preiau de la
numele obiectelor.

Dupa aceea - de spus “URRRRAAAA ! ! !” si de prezentat prima lucrare de laborator la profesor. :)
Și nicicînd mai mult nu de avut de furcă cu fiare foc-răsuflătoare.
 Exemplul lucrării practice (listingul programului)

import java.io.*;

class Balaur
{
String nume;
byte nr_cap;
float greutatea;
int virsta;
float forta;
double intelect[];
static int nr;

////////////////Functii de citire//////////////////////////
static String readString()
{

str=" ";
try{str=box.readLine();}
catch (Exception l){}
return str;
}

static int readInt()

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

static float readFloat()

{
return (Float.valueOf(readString())).floatValue();
}

static double readDouble()

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

////////////// CONSTRUCTORI ////////////////////////

Balaur() //constructor fara parametri (introducerea de la tastatura)

{
System.out.print("Numele balaurului:");
nume = readString();
do
{
System.out.println ("Numarul de capuri ale balaurului:");
nr_cap = (byte)readInt();
if (nr_cap < 1 || nr_cap > 7) System.out.print("Nr. de capuri posibile este intre 1 si 7 inclusiv");
}
while (nr_cap < 1 || nr_cap > 7);
do
{
System.out.print("Greutatae balaurului:");
greutatea = readFloat();
if (greutatea <100 || greutatea > 1000) System.out.println("Greutatea este intre 100 si 1000 kg");
}
while(greutatea <100 || greutatea > 1000);
do
{
System.out.print("Virsta balaurului:");
virsta = readInt();
if (virsta < 1 || virsta > 100) System.out.println("Virsta este intre 1 si 100 ani");
}
while (virsta < 1 || virsta > 100);
do
{
System.out.print("Forta balaurului:");
forta = readFloat();
if (forta < 100 || forta > 500) System.out.println("Forta este intre 100 si 500 caiputere");
}
while (forta < 100 || forta > 500);

intelect = new double[nr_cap];

System.out.print("IQ-ul fiecarui cap al balaurului:");
for (int i = 0; i < nr_cap; i++)
intelect[i]=readDouble();
nr++;
}

Balaur(byte n_cap, float forta) //constructor cu 2 parametri

{
nume = "Zmei Garinici";
if ((n_cap >= 1) && (n_cap <= 7))
nr_cap = n_cap;
greutatea = 100.5f;
virsta = 10;
if ((forta >= 100)&&(forta <= 500))
this.forta = forta;
intelect = new double[nr_cap];
for (int i = 0; i < nr_cap; i++)
intelect[i]=130.6;
nr++;
}

Balaur(float gr, int virsta) //constructor cu alti 2 parametri

{
nume = "Zmei Vasilici";
nr_cap = 3;
if ((gr >= 100)&&(gr <= 1000))
greutatea = gr;
if ((virsta >= 10)&&(virsta <= 100))
this.virsta=virsta;
forta = 125.5f;
intelect = new double[nr_cap];
for (int i = 0; i < nr_cap; i++)
intelect[i] = 140.8;
nr++;
}

Balaur(Balaur Clon) //constructor de copiere

{
nume = Clon.nume;
nr_cap = Clon.nr_cap;
greutatea= Clon.greutatea;
virsta = Clon.virsta;
forta = Clon.virsta;
intelect = new double[nr_cap];
for (int i = 0; i < nr_cap; i++)
intelect[i] = Clon.intelect[i];
nr++;
}

/////////////////// METODELE DE ACCES LA CIMPURILE CLASEI (get_*)/////////

public String get_nume()

{
return nume;
}
public byte get_nr_cap()
{
return nr_cap;
}
public float get_greutatea()
{
return greutatea;
}
public int get_virsta()
{
return virsta;
}
public float get_forta()
{
return forta;
}
public double get_intelect(int index)
{
if ((index >= 0)&&(index <nr_cap))
return intelect[index];
else
{
System.out.println("Acest cap nu exista");
return -1;
}
}

////////////////METODELE DE SETARE A CIMPURILOR CLASEI (set_*)//////////////

public void set_nume(String nume_nou)

{
nume = nume_nou;
}
public void set_nr_cap(byte nr_cap_nou)
{
if ((nr_cap_nou >= 0)&&(nr_cap_nou < 7)&&(nr_cap_nou != nr_cap))
{
double tmp[] = new double[nr_cap];
for (int i = 0; i < nr_cap; i++)
{
tmp[i] = intelect[i];
}
intelect = new double[nr_cap_nou];
int i=0;
if (nr_cap_nou > nr_cap)
intelect[i] = tmp[i];
else
for (i = 0; i < nr_cap_nou; i++)
{
intelect[i] = tmp[i];
}
nr_cap = nr_cap_nou;
}
}
public void set_greutatea(float greutatea_nou)
{
if ((greutatea_nou >= 100)&&(greutatea_nou <= 500))
greutatea = greutatea_nou;
}
public void set_virsta(int virsta_nou)
{
if ((virsta_nou >= 10)&&(virsta_nou <= 100))
virsta = virsta_nou;
}
public void set_forta(float forta_nou)
{
if ((forta_nou >= 100)&&(forta_nou <= 500))
 forta = forta_nou;
}
public void set_intelect(int id, double intelect_nou)
{ int i=0;
if ((id >= 0)&&(id <= nr_cap)&&(intelect_nou > 100)&&(intelect_nou < 201))
intelect[i]=intelect_nou;
}

//////////////////// FUNCTIA DE AFISARE //////////////////

public void Afisare()

{
System.out.println("\n\t*********************");
System.out.println("\t*AFISARE DATE BALAUR*");
System.out.println("\t*********************");
System.out.println(" Numele balaurului este " +nume);
System.out.println(" Are " +nr_cap+ " capuri");
System.out.println(" Are o greutate de " +greutatea+ " kg");
System.out.println(" Virsta lui este de " +virsta+ " ani");
System.out.println(" Forta fiind de " +forta+ " cai putere");
System.out.println(" Intelectul fiecarui cap al balaurului:");
for (int i = 0; i < nr_cap; i++)
System.out.print(" " +intelect[i]+ " ");
}

/////////////// FUNCTIA CARE CALCULEAZA INTELECTULUI BALAURULUI //////////

public double media_capului()

{
int suma=0;
for (int i = 0; i < nr_cap; i++)
suma += intelect[i];
return (suma/nr_cap);
}

////////////// FUCTIA STATICA CARE COMPARA 2 BALAURI DUPA INTELECTUL FIECARUIA

public static void comparare(Balaur b1, Balaur b2)

{
if (b1.media_capului() > b2.media_capului())
System.out.println(b1.nume + " este mai destept decit " + b2.nume);
if (b2.media_capului() > b1.media_capului())
System.out.println(b2.nume + " este mai destept decit " + b1.nume);
else
System.out.println(b2.nume + " este la fel de destept ca si " + b1.nume);
}

///////////// FUNCTIA LUPTA INTRE 2 BALAURI/////////////////////////////

/////////(daca un balaur pierde i se taie cite un cap pina cind unul din ei moare)/////////////

public void lupta(Balaur Ivanici)

{
System.out.println("\n\t*********************");
System.out.println("\t*LUPTA INTRE BALAURI*");
System.out.println("\t*********************");
System.out.println(this.nume+ " cu " +this.nr_cap +" capuri " +" VS "+ Ivanici.nume + " cu " + Ivanici.nr_cap + " capuri ");
if (this.nr_cap > 0 && Ivanici.nr_cap >0)
{
do
{
if ((this.media_capului() < Ivanici.media_capului()))
{
this.set_nr_cap((byte)(nr_cap-1));
System.out.println(Ivanici.nume + " i-a taiat un cap lui "+ this.nume);
}
else
 {
Ivanici.set_nr_cap((byte)(Ivanici.nr_cap-1));
System.out.println(this.nume + " i-a taiat un cap lui "+ Ivanici.nume);
}
}
while(this.nr_cap > 0 && Ivanici.nr_cap >0);
}

else if (this.nr_cap > 0 && Ivanici.nr_cap >0)

{
do
{
if ((this.forta < Ivanici.forta))
{
this.set_nr_cap((byte)(nr_cap-1));
System.out.println(Ivanici.nume + " i-a taiat un cap lui "+ this.nume);
}
else
{
Ivanici.set_nr_cap((byte)(Ivanici.nr_cap-1));
System.out.println(this.nume + " i-a taiat un cap lui "+ Ivanici.nume);
}
}
while(this.nr_cap > 0 && Ivanici.nr_cap >0);
}

else if (this.nr_cap > 0 && Ivanici.nr_cap >0)

{
do
{
if ((this.virsta < Ivanici.virsta))
{
this.set_nr_cap((byte)(nr_cap-1));
System.out.println(Ivanici.nume + " i-a taiat un cap lui "+ this.nume);
}
else
{
Ivanici.set_nr_cap((byte)(Ivanici.nr_cap-1));
System.out.println(this.nume + " i-a taiat un cap lui "+ Ivanici.nume);
}
}
while(this.nr_cap > 0 && Ivanici.nr_cap >0);
}
System.out.println("\n\t********************");
System.out.println("\t*REZULTATELE LUPTEI*");
System.out.println("\t********************");
System.out.println(this.nume+ " a ramas cu " +this.nr_cap +" capuri " +" VS "+ Ivanici.nume + "a ramas cu " + Ivanici.nr_cap + " capuri ");
}

////////////// SCIEREA OBIECTULUI IN FISIER ////////////////

public void scrie_fisier()

{
try
{
FileOutputStream fOut = new FileOutputStream("balaur.txt");
PrintStream flux = new PrintStream(fOut);
flux.print(" Nume:");
flux.println(nume);
flux.print(" Nr de capuri:");
flux.println(nr_cap);
flux.print(" Greutatea:");
flux.println(greutatea);
flux.print(" Vista:");
flux.println(virsta);
flux.print(" Forta:");
flux.println(forta);
 flux.println(" IQ-ul la fiecare cap:");
for (int i = 0; i < nr_cap; i++)
{
flux.print(" IQ capului " +(i+1)+": ");
flux.println(intelect[i]);
}
flux.close();
fOut.close();
} catch (IOException ex)
{
System.out.println("Fisierul nnu a fost creat");
System.exit(1);
}
}

////////////////// FUNCTIA PRINCIPALA MAIN()////////////////

public static void main(String args[])
{
//crearea a 4 balauri cu diferiti constructori
Balaur Petrovici = new Balaur();
Petrovici.Afisare();
Balaur Vasilici = new Balaur(200f, 20);
Vasilici.Afisare();
Balaur Garinici = new Balaur((byte)4, 150f);
Garinici.Afisare();
Balaur Clon = new Balaur(Vasilici);
Clon.Afisare();

try {
System.out.println("\nApasa orice cifra pentru a continua ...");
Thread.sleep(readInt());}
catch(InterruptedException ex)
{Thread.currentThread().interrupt();}

//crearea a unui tablou de balauri cu diferiti constructori

System.out.println("\n");
int nrBalauriFamilie = 8;
Balaur familie[] = new Balaur[nrBalauriFamilie];
for (int i = 0; i < nrBalauriFamilie; i+=4)
{
familie[i] = new Balaur();
familie[i+1] = new Balaur(150f, 27);
familie[i+2] = new Balaur((byte)5, 189f);
familie[i+3] = new Balaur(Garinici);
}
for (int i = 0; i < nrBalauriFamilie; i++)
{
familie[i].set_nume("Balaur nr"+(i+1));
familie[i].Afisare();
}

try {
System.out.println("\nApasa orice cifra pentru a continua ...");
Thread.sleep(readInt());}
catch(InterruptedException ex)
{Thread.currentThread().interrupt();}

//4 perechi de balauri isi compara intelectul

System.out.println("\n\t******************************************");
System.out.println("\t*REZULTATELE COMPARARII INTELECTUALITATII*");
System.out.println("\t******************************************");
comparare(Vasilici, Garinici);
comparare(familie[3], familie[5]);
comparare(Petrovici, Clon);
comparare(Garinici, familie[7]);
 try {
System.out.println("\nApasa orice cifra pentru a continua ...");
Thread.sleep(readInt());}
catch(InterruptedException ex)
{Thread.currentThread().interrupt();}

//3 perechi de balauri se lupta

Garinici.lupta(Petrovici);
Vasilici.lupta(familie[3]);
familie[7].lupta(familie[2]);

//balaurul Vasilici se scrie in fisierul balaur.txt

Vasilici.scrie_fisier();

try {
System.out.println("\nApasa orice cifra pentru a continua ...");
Thread.sleep(readInt());}
catch(InterruptedException ex)
{Thread.currentThread().interrupt();}

//afisam citi balauri am crat in total

System.out.println("\nIn tolal au fost creati "+nr+" balauri");
System.out.println("\nURRRAAA!!! Nu mai am de furca cu fiare foc-rasuflatoare");
}
//SFIRSIT
}
Rezultatele rulării programului (testingul programului)
Concluzii.

În această lucrare de laborator am început să învăț limbajul de programare Java. Am ales clasa
balaur cu cîmpurile: nume, numarul de capuri, greutate, forța, vîrsta și un vector dinamic intelect,
în care se păstra IQ – ul fiecărui cap al balaurului. Am mai adăugat un cîmp static unde se va păstra
numărul de bălauri creați. Apoi am creat trei tipuri de constructori: unul fără parametri cu
introducere de tastatură, doi cu parametric și unul de copiere. Dar mai întîi de aceasta am creat
funcțiile de citire de la tastatură, care le – am folosit în constructorul fără parametri. Am scris
metodele de acces la toate cîmpurile clasei și metodele de setare a cîmpurilor clasei cu verificări.
Pe urmă funcția de afișare, funcția de calculare a intelectului balaurului (media aritmetică a
capurilor balaurului), funcția statică de comparare a doi balauri după intelectul fiecăruia, funcția
de luptă intre perechi de balauri (se luptă pînă cînd unul nu mai are capuri de tăiat), functia de
scriere a obiectului în fișier și funcția principală main().
În main() am creat diferite obiecte (balauri) cu toți constructorii decriși în clasă, am creat un
tablou de obieste, de asemenea cu toți constructorii și i-am afișat modificîndu – le numele
fiecăruia în Balaur nr.1, nr2, ș.a.m.d, am ales patru perechi de balauri și i-am comparat intelectul,
trei perechi au luptat și am afișat rezultatele luptelor, am înscris un obiect în fișier și la urmă am
afișat numarul de obiecte create.
În acest laborator am lucrat cu Java Development Kit (JDK) unde am executat toate fucțiile
clasei. Am învățat clasele și obiectele în Java, care seamană foarte mult cu cele din C++.
Sper că nu voi mai avea de furcă cu animalele foc – răsuflătoare.