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: № 14

Clasa: „Sultan”

Efectuat: studentul (-a) grupei IA1602

numele, prenumele Jura Mihaela

Verificat: lect.univers., magistru in inform.

Epifanova Irina .

- Chişinău 2018 -
 (listingul programului)

import java.io.*;
import java.util.*;

class Sultan
{
String Name; //numele Sultanului
double bani; //numărul banilor
int sotii; //numărul de soții
int frumusete[]; //vectorul dinamic cu frumusetea sotiilor
int rautate[]; //vectorul dinamic cu rautatea sotiilor
byte stres; //coeficientul stresului
static int nr_sultan=0; //numărul de sultani creați(obiectelor clasei)

////////////////////////////////////// constructori ////////////////////////////////////////

Sultan() //Constructorul impicit(fără parametri)

{
Name="Suleiman";
bani=10000.25;
sotii=12;
frumusete=new int[sotii]; //alocăm memorie pentru vectorul de frumusere- tipul elementelor este int, numarul lor=soții
for (int i=0; i<sotii; i++) //prin ciclu umplem vectorul cu 9. Variabila ciclului – i.
frumusete[i]=9;
rautate=new int[sotii]; //alocăm memorie pentru vectorul de rautate- tipul elementelor este int, numarul lor=soții
for (int i=0; i<sotii; i++) //prin ciclu umplem vectorul cu 9. Variabila ciclului – i.
rautate[i]=7;
stres=(byte)100;
nr_sultan++; //încrementarea numărului de obiecte
}

Sultan(double bani, byte stress) //constructorul cu 2 parametri

{
Name="Ahmed";
this.bani=bani; //pentru a face diferența dintre numele parametrului și cîmpul clasei, folosim this
sotii=5;
frumusete=new int[sotii]; //alocăm memorie pentru vectorul de frumusere- tipul elementelor este int, numarul lor=soții
for (int i=0; i<sotii; i++) //prin ciclu umplem vectorul cu 9. Variabila ciclului – i.
frumusete[i]=9;
rautate=new int[sotii]; //alocăm memorie pentru vectorul de rautate- tipul elementelor este int, numarul lor=soții
for (int i=0; i<sotii; i++) //prin ciclu umplem vectorul cu 6. Variabila ciclului – i.
rautate[i]=6;
stres=stress;
nr_sultan++; //încrementarea numărului de obiecte
}

Sultan(String nick, byte stres, int sotiile) //constructorul cu 3 parametri

{
Name=nick;
bani=13600;
this.stres=stres; //pentru a face diferența dintre numele parametrului și cîmpul clasei, folosim this
sotii=sotiile;
frumusete=new int[sotii]; //alocăm memorie pentru vectorul de frumusere- tipul elementelor este int, numarul lor=soții
for (int i=0; i<sotii; i++) //prin ciclu umplem vectorul cu 10. Variabila ciclului – i.
frumusete[i]=10;
rautate=new int[sotii]; //alocăm memorie pentru vectorul de rautate- tipul elementelor este int, numarul lor=soții
for (int i=0; i<sotii; i++) //prin ciclu umplem vectorul cu 5. Variabila ciclului – i.
rautate[i]=5;
nr_sultan++; //încrementarea numărului de obiecte
}

Sultan(String nick)
{
Name=nick;
bani=10045.25;
sotii=10;
frumusete=new int[sotii]; //alocăm memorie pentru vectorul de frumusere- tipul elementelor este int, numarul lor=soții
for (int i=0; i<sotii; i++) //prin ciclu umplem vectorul cu 7. Variabila ciclului – i.
frumusete[i]=7;
rautate=new int[sotii]; //alocăm memorie pentru vectorul de rautate- tipul elementelor este int, numarul lor=soții
for (int i=0; i<sotii; i++) //prin ciclu umplem vectorul cu 3. Variabila ciclului – i.
rautate[i]=3;
stres=(byte)65;
nr_sultan++; //încrementarea numărului de obiecte
}

Sultan(byte stres, double bani)

{
Name="Baiazin";
this.bani=bani; //pentru a face diferența dintre numele parametrului și cîmpul clasei, folosim this
sotii=9;
frumusete=new int[sotii]; //alocăm memorie pentru vectorul de frumusere- tipul elementelor este int, numarul lor=soții
for (int i=0; i<sotii; i++) //prin ciclu umplem vectorul cu 7. Variabila ciclului – i.
frumusete[i]=7;
rautate=new int[sotii]; //alocăm memorie pentru vectorul de rautate- tipul elementelor este int, numarul lor=soții
for (int i=0; i<sotii; i++) //prin ciclu umplem vectorul cu 9. Variabila ciclului – i.
rautate[i]=9;
this.stres=stres;
nr_sultan++; //încrementarea numărului de obiecte
}

Sultan(String nick, int sotiile)

{
Name=nick;
bani=10945.25;
sotii=sotiile;
frumusete=new int[sotii]; //alocăm memorie pentru vectorul de frumusere- tipul elementelor este int, numarul lor=soții
for (int i=0; i<sotii; i++) //prin ciclu umplem vectorul cu 7. Variabila ciclului – i.
frumusete[i]=7;
rautate=new int[sotii]; //alocăm memorie pentru vectorul de rautate- tipul elementelor este int, numarul lor=soții
for (int i=0; i<sotii; i++) //prin ciclu umplem vectorul cu 7. Variabila ciclului – i.
rautate[i]=7;
stres=(byte)65;
nr_sultan++; //încrementarea numărului de obiecte
}

Sultan(Sultan Prototype) //constructorul de copiere este obligat să copie TOATE cîmpurile obiectului-parametru Prototype
{
Name=Prototype.Name;
bani=Prototype.bani;
stres=Prototype.stres;
sotii=Prototype.sotii;
frumusete=new int[sotii]; //alocăm memorie pentru vectorul de frumusere- tipul elementelor este int, numarul lor=soții
for (int i=0; i<sotii; i++)
frumusete[i]=Prototype.frumusete[i];
rautate=new int[sotii]; //alocăm memorie pentru vectorul de rautate- tipul elementelor este int, numarul lor=soții
for (int i=0; i<sotii; i++)
rautate[i]=Prototype.rautate[i];
nr_sultan++; // dacă este chemat constructorul => a fost creat un obiect => numărul obiectelor (nr) crește
}

////////////////////////////////////// metodele de acces la cîmpurile clasei (get_*) ////////////////////////////////////////

public int get_mark(int index) //acces la elementul vectorului marks cu indicele index, adică la notă concretă
{
if ( (index >= 0) && (index < exams) ) //controlăm dacă in genere există notă cu indicele introdus (index)
return marks[index]; //dacă da, returnăm nota cu indicile dat
else //dacă nu – afișăm mesajul ca așa examen nu există
{
System.out.println("such exam doesn’t exist");
return -1;
}
}

public String getName() // accesul la cîmpul clasei name – returnează copia valorii cîmpului dat
{
return Name; // return this.name
}

public byte getstres() // accesul la cîmpul clasei stres – returnează copia valorii cîmpului dat
{
return stres; // return this.stres
}

public double getbani() // accesul la cîmpul clasei bani – returnează copia valorii cîmpului dat
{
return bani; // return this.bani
}

public int getsotii() // accesul la cîmpul clasei sotii – returnează copia valorii cîmpului dat
{
return sotii; // return this.sotii
}

public int getrautate(int id) //acces la elementul vectorului rautate cu indicele id, adică la rautatea concretă
{
if (id>=0 && id<sotii) //controlăm dacă in genere există rautate cu indicele introdus (id)
return rautate[id];
else //dacă nu – afișăm mesajul ca nu există
{
System.out.println("such exam doesn’t exist");
return -1;
}
}

public int getfrumusete(int id) //acces la elementul vectorului frumusete cu indicele id, adică la frumusetea concretă
{
if (id>=0 && id<sotii) //controlăm dacă in genere există frumusete cu indicele introdus (id)
return frumusete[id]; //dacă da, returnăm frumusetea cu indicile dat
else //dacă nu – afișăm mesajul ca nu există
{
 System.out.println("such exam doesn’t exist");
return -1;
}
}

////////////////////////////////////// metodele de setare a cîmpurilor clasei (set_*) ////////////////////////////////////////

public void setName(int id, String Name1) //setează în cîmpului clasei name valoarea nouă a parametrului new_name
{
if(id >= 0 && id < nr_sultan && Name1!=Name && && Name1.length() != 0) //verificam daca id exista si lungimea stringului >0
Name=Name1;} // daca este corect, introducem valoarea lui în this.Name

public void setstres(byte stres1)

{
if( stres1<=100) // înainte de a folosi parametrul stres1, îi controlăm corectitudinea
stres=stres1;} // daca este corect, introducem valoarea lui în this.stres

public void setbani(double bani1)

{
if(bani1>10000) // înainte de a folosi parametrul bani1, îi controlăm corectitudinea
bani=bani1;} // daca este corect, introducem valoarea lui în this.bani

public void setfrumusete(int frumusete1, int id)

{
if(frumusete1>0 && frumusete1<11 && id>=0 && id<sotii)
frumusete[id]=frumusete1; // daca este corect, introducem valoarea lui în this.frumusete
}

public void setrautate(int rautate1, int id)

{
if(rautate1>0 && rautate1<11 && id>=0 && id<sotii)
rautate[id]=rautate1; // daca este corect, introducem valoarea lui în this.rautate
}

public void setsotii(int nousotii) // setează în cîmpului clasei sotii valoarea nouă a parametrului nnousotii
{if(nousotii>0 && nousotii!=sotii && nousotii<100) //controlăm corectitudine lui nousotii
{int tmp[]=new int[sotii];
int tmp1[]=new int[sotii];
for (int i=0; i<sotii; i++)
{tmp[i]=frumusete[i];
tmp1[i]=rautate[i];}
frumusete= new int[nousotii]; //deoarece s-a schimbat numărul sotiilor, trebuie să se schimbe și frumusetea =>
rautate = new int[nousotii]; //deoarece s-a schimbat numărul sotiilor, trebuie să se schimbe și rautatea =>

int min =(sotii<nousotii)?sotii:nousotii;

for(int i=0;i<min; i++){
frumusete[i]=tmp[i]; //înlocuim dinvectorul creat in frumusete
rautate[i]=tmp1[i];}
sotii=nousotii; // introducem valoarea lui în sotii
}
}
/////////////////////////////////////metoda afisării la ecran a tuturor cîmpurilor clasei /////////////////////////////////////////

void afisare()
{
System.out.println("==================================");
System.out.println("Sultan's name is: "+Name);
System.out.println("Sultan's bani is: "+bani);
System.out.println("Sultan's sotii is: "+sotii);
System.out.println("Sotii's frumusete are: ");
for (int i=0; i<sotii; i++)
System.out.print(frumusete[i]+" ");System.out.println(" ");
System.out.println("Sotii's rautate are: ");
for (int i=0; i<sotii; i++)
System.out.print(rautate[i]+" ");System.out.println(" ");
System.out.println("Sultan's stres is: "+stres);
}

////////////////////////////////////////////metoda creare sultan_aleator////////////////////////////////////////////////

void Sultan_aleator()
{
String denumires[]={"Kerem","Mahmut","Onur","Krasavchik"};
Name=denumires[(new Random()).nextInt(denumires.length)];
bani=(double)(new Random()).nextInt(10000);
stres=(byte)(new Random()).nextInt(126);
sotii=(int)(new Random()).nextInt(10);
frumusete=new int[sotii];
for (int i=0; i<sotii; i++)
frumusete[i]=(int)(new Random()).nextInt(10);
rautate=new int[sotii];
for (int i=0; i<sotii; i++)
rautate[i]=(int)(new Random()).nextInt(10);
nr_sultan++;
}

////////////////////////////////////////metoda introducerea de la tastatura/////////////////////////////////////////////////

public void introducere_tast(){
Scanner sc = new Scanner(System.in);
do{System.out.print("\nSultan's name is: "); //verificam dacă lungimea stringului întrodus e mai mare decât 0.
String Name = sc.nextLine();} while (Name.length()<0);
do {System.out.print("\nSultan's bani are: ");
bani = sc.nextDouble();} while(bani<0); //verificăm dacă valoarea întrodusă mai mare ca 0
do{System.out.print("\nSultan's sotii is: ");
sotii = sc.nextInt();} while (sotii<0);
System.out.println("Sotii's frumusete are: ");
frumusete=new int[sotii];
for (int i=0; i<sotii; i++)
frumusete[i]=sc.nextInt();
System.out.println("Sotii's rautate are: ");
rautate=new int[sotii];
for (int i=0; i<sotii; i++)
rautate[i]=sc.nextInt();
do {System.out.print("\nSultan's stres is: "); //verificăm daca valoarea întrodusa mai mare ca 0 și mai mică ca 126
stres = (byte)sc.nextByte();} while(stres<0 &&stres>126);
nr_sultan++; //încrementarea numărului de obiecte create
}
////////////////////////////////////////////////metoda «ComparSotii»/////////////////////////////////////////////////////
{
if (Ion.sotii>Jora.sotii) //daca primul sultan are mai multe sotii se afiseaza mesajul de mai jos
System.out.println(Ion.Name+" are mai multe sotii decat "+Jora.Name);
if (Ion.sotii<Jora.sotii) //dacă al doi-lea sultan are mai multe sotii se afiseaza mesajul de mai jos
System.out.println(Ion.Name+" are mai putine sotii decat "+Jora.Name);
if (Ion.sotii==Jora.sotii) //daca au acelasi numar de sotii
System.out.println(Ion.Name+" are acelasi numar de sotii ca "+Jora.Name);
}

//////////////////////////////////////Metoda «coeficientul de sanatate al sultanului»////////////////////////////////////////

float sanatatea(){int fsotii=0,rsotii=0; //initalizare variabile
float mf=0,mr=0,sanatate=0;
for(int i = 0; i < sotii; i++)
{fsotii+= frumusete[i]; // se sumează frumusetea
rsotii+=rautate[i];} //se sumează rautatea
mf=fsotii/sotii; //media aritmetica a frumusetei
mr=rsotii/sotii; //media aritmetică a răutații
sanatate=mf/mr; //calculare coeficientul de sănătate
return sanatate;}

//////////////////////////////////////////// funcția principală main //////////////////////////////////////////////////

public static void main (String[] args)

{
System.out.println("Sultan aleator");
Sultan Murad=new Sultan();
Murad.Sultan_aleator();
Murad.afisare();

Sultan Daniel1= new Sultan();

Daniel1.introducere_tast();
Sultan Daniel=new Sultan();
Sultan Clon=new Sultan(Daniel);
Sultan Andrei=new Sultan(1234,(byte)76);
Sultan Alex=new Sultan("Baiazid",(byte)50, 4);
Sultan Mihai=new Sultan("Ibrahim");
Sultan Adam=new Sultan((byte)110, 45623.3);
Sultan Victor=new Sultan("Mustafa", 24);
//creăm obicetul-Daniel1-cu introducere de la tastatura
//creăm obiectul – pe sultanul Daniel- cu constructorul implicit(fără parametri)
//creăm obiectul-Clon- cu constructorul de copiere
//creăm obiectul – pe sultanul Andrei- cu constructorul cu 2 parametri
//creăm obiectul – pe sultanul Alex- cu constructorul cu 3 parametri
//creăm obiectul – pe sultanul Mihai- cu constructorul cu 1 parametri
//creăm obiectul – pe sultanul Adam- cu constructorul cu 2 parametri
//creăm obiectul – pe sultanul Victor- cu constructorul cu 2 parametri

Daniel.afisare(); //afișăm la ecran toată informația despre Daniel

Clon.afisare(); //afișăm la ecran toată informația despre Clon
Andrei.afisare(); //afișăm la ecran toată informația despre Andrei
Alex.afisare(); //afișăm la ecran toată informația despre Alex
Mihai.afisare(); //afișăm la ecran toată informația despre Mihai
Adam.afisare(); //afișăm la ecran toată informația despre Adam
Victor.afisare(); //afișăm la ecran toată informația despre Victor

System.out.println("=====================================");
System.out.println("Metodele set");
Clon.setstres((byte)80); //setăm la obiectul Clon- stres=80
Clon.setbani(15642); //setăm la obiectul Clon- bani=15642
Clon.setsotii(10); //setăm la obiectul Clon- sotii=10
Clon.afisare(); //afișăm la ecran toată informația despre Clon
System.out.println("\n_____________________________________");
System.out.println(" ");
System.out.println("Au fost creati sultani in numar de:"+ nr_sultan); //afișăm numărul de sultani creați

Sultan[] retea; //crearea vectorului cu Sultani

retea = new Sultan[nr_sultan];

retea[0] = new Sultan("Daniel"); // Ititializarea vectorului

retea[1] = new Sultan(1234,(byte)76);
retea[2] = new Sultan("Baiazid",(byte)50, 4);
retea[3] = new Sultan("Ibrahim");
retea[4] = new Sultan((byte)110, 45623.3);
retea[5] = new Sultan("Mustafa", 24);

int sum=0; //inițializarea variabilei sum

for(int i = 0; i < nr_sultan; i++) //parcurgerea vectorului de nr_sultani ori
sum+=retea[i].getsotii(); //calcularea sumei totală de soții utilizând metoda get

double sanatate = 0; //inițializarea variabilei

int winnerIndex = 0; //inițializarea variabilei
for(int i = 0; i < nr_sultan; i++){ //parcurgerea vectorului de nr_sultani ori
if(retea[i].sanatatea() > sanatate){ //verificare daca elementul din vector e mai mare decat variabila data
sanatate = retea[i].sanatatea();
winnerIndex = i; //indexul celui mai sănătos sultan
}
}

System.out.println("=====================================");
System.out.println(" ");
ComparSotii(Daniel,Andrei); //afișarea comparării soțiilor a lui Daniel și Andrei
ComparSotii(Alex,Mihai); //afișarea comparării soțiilor a lui Alex și Miahi
System.out.println("_____________________________________");
System.out.println(" ");
System.out.print("Sultanul cel mai sanatos este " + retea[winnerIndex].getName() + ". Coeficientul sanatatii este: " +
retea[winnerIndex].sanatatea());
System.out.println("\n_____________________________________");
System.out.println("In total sunt sotii in numar de:"+ sum); //afișarea numarului total de soții
}

Rezultatele rulării programului (testingul programului)

D:\1111\Java\jdk1.8.0_161\bin> javac Sultan.java

Sultan's name is: Murad
D:\1111\Java\jdk1.8.0_161\bin>java Sultan
Sultan's bani are: 12356
Sultan aleator
================================== Sultan's sotii is: 1
Sultan's name is: Mahmut Sotii's frumusete are:
Sultan's bani is: 8379.0 9
Sultan's sotii is: 4 Sotii's rautate are:
Sotii's frumusete are: 9
6995
Sotii's rautate are: Sultan's stres is: 120
9614 ==================================
Sultan's stres is: 3 Sultan's name is: Suleiman
Sultan's bani is: 10000.25 Sultan's name is: Baiazin
Sultan's sotii is: 12 Sultan's bani is: 45623.3
Sotii's frumusete are: Sultan's sotii is: 9
999999999999 Sotii's frumusete are:
Sotii's rautate are: 777777777
777777777777 Sotii's rautate are:
Sultan's stres is: 100 999999999
================================== Sultan's stres is: 110
Sultan's name is: Suleiman ==================================
Sultan's bani is: 10000.25 Sultan's name is: Mustafa
Sultan's sotii is: 12 Sultan's bani is: 10945.25
Sotii's frumusete are: Sultan's sotii is: 24
999999999999 Sotii's frumusete are:
Sotii's rautate are: 777777777777777777777777
777777777777 Sotii's rautate are:
Sultan's stres is: 100 777777777777777777777777
================================== Sultan's stres is: 65
Sultan's name is: Ahmed =====================================
Sultan's bani is: 1234.0 Metodele set
Sultan's sotii is: 5 ==================================
Sotii's frumusete are: Sultan's name is: Suleiman
99999 Sultan's bani is: 15642.0
Sotii's rautate are: Sultan's sotii is: 10
66666 Sotii's frumusete are:
Sultan's stres is: 76 9999999999
================================== Sotii's rautate are:
Sultan's name is: Baiazid 7777777777
Sultan's bani is: 13600.0 Sultan's stres is: 80
Sultan's sotii is: 4
Sotii's frumusete are: _____________________________________
10 10 10 10
Sotii's rautate are: Au fost creati sultani in numar de:11
5555 =====================================
Sultan's stres is: 50
================================== Suleiman are mai multe sotii decat Ahmed
Sultan's name is: Ibrahim Baiazid are mai putine sotii decat Ibrahim
Sultan's bani is: 10045.25 _____________________________________
Sultan's sotii is: 10
Sotii's frumusete are: Sultanul cel mai sanatos este Daniel. Coeficientul sanatatii este:
7777777777 2.3333333
Sotii's rautate are:
3333333333 _____________________________________
Sultan's stres is: 65
================================== In total sunt sotii in numar de:62

Concluzie:

În această lucrare de laborator am învățat crearea constructorilor(implicit, cu parametri, de

copiere), folosirea metodelor get și set, cât și alocarea memoriei unui vector dinamic. Am studiat două
metode de întroducere de la tastatură și prin ce diferă una de alta, la fel și metota Random folosită
penntru crearea unui obiect cu date aleatoare. Lucrarea de laborator nr 1 constituie un exercițiu, o
bază pentru următoarele laboratoare, cât și primul pas spre studierea limbajului Java.