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

Clasa: „Strutz”

Efectuat: studentul (-a) grupei I2101

numele, prenumele Sofiischi Victor

Verificat: lect.univers., magistru in inform.

Epifanova Irina .

- Chişinău 2020 -

Formularea problemei:
De creat clasa “Strutz” cu câteva câmpuri.

Câmpurile obligatorii:
- un câmp de tip intreg (int), pentru păstrarea numărul de pui ai strutzului;
− un vector dinamic, în care se păstrează informaţia despre fiecare pui al strutzului (sunt posibile 3 variante:
genul feminin cu valoare: -1, genul masculin: +1, şi necunoscut: 0 :) adicâ acest ou a fost mâncat :))
− un câmp de tip intreg, static, in care se păstrează numărul de obiecte create.

Câmpuri opţionale: densitatea pufului, viteza de alergare, forţa aplicată la introducerea capului în pământ :),
vârsta etc…

De creat trei tipuri de constructori pentru această clasă (cu alocare dinamică a memoriei):
- constructor standard (implicit - fără parametri)
- câteva constructori cu parametri
- constructor de copiere

● De creat metodele pentru acces la toate câmpurile clasei şi de modificare a lor (set() si get()).

● De creat metoda pentru a afişa la ecran toată informaţia despre strutz, adică toate câmpurile din
această clasă.
● De descries metoda, care completeaza toate campurile obiectului cu valori citite de la tastatura.

● De descries metoda, care completeaza toate campurile obiectului cu valori aleatoare.

● De creat metoda statică, ce compară doi strutzi (două instanţe (obiecte) a clasei – ambele obiecte
primim ca parametrii) în baza numărului de pui
● De creat metoda, care calculează numărul sumar de ouă, care a fost mâncat la strutz :)

În metoda main() de creat nişte strutzi, utilizând toţi constructorii declaraţi. După creerea fiecărei instantze a
clasei “strutz”, de afişat la ecran câmpurile lui cu ajutorul metodei respective (set() şi get()). De creat un
vector dinamic din obiectele clasei şi de initializat vectorul creat, folosind 3 tipuri de constructor. De afişat la
ecran (in ciclu) informatia a tuturor strutzi in vector. De comparat câteva perechi de strutzi în baza numărului
de pui cu ajutorul metodei respective. Rezultatele comparării de afişat la ecran. De calculat numărul de ouă,
care au fost mâncate la toţi strutzii creaţi, de asemenea cu ajutorulmetodei corăspunzătoare precum şi cu
metodele de acces la câmpurile clasei. Rezultatele de afişat la ecran.
De afişat la ecran numarul general de strutzi creaţi, folosind câmpul static clasei.
Codul sursa (listingul programului)

import java.io.*;
import java.util.Scanner;
import java.util.Random;
import java.util.ArrayList;

public class Straus {

/*
Definim campurile clasei
*/
String numeStrutz;
int numarCopii;
 int despreCopii[];
String vitezaDeAlergare;
int varsta;
static int nrObiecte;

/*
Constructorul de baza fara argumenti
*/
Straus()
{
numeStrutz = "Domenic";
numarCopii = 4;
despreCopii = new int[numarCopii];
for(int i=0;i<numarCopii;i++)
{
despreCopii[i] = 1;
}
vitezaDeAlergare = "50 Km/h";
varsta = 20;
nrObiecte++;
}

/*
Constructorul cu numar anumit de parametri ... in cazul dat 4 parametri
*/
Straus(String name, int nrCop, int[] despreCop, int age)
{
if(name != "")
{
numeStrutz = name;
}else {
System.out.println("Nume null");
}
if(numarCopii >= 0) {
numarCopii = nrCop;
} else {
System.out.println("Nume negativ pentru numarul de copii");
}
if(despreCop.length == numarCopii) {
despreCopii = despreCop;
}else {
System.out.println("Error ... Nu toti copii sunt definiti pentru " + numeStrutz);
}
varsta = age;
vitezaDeAlergare = "X Km/h";
nrObiecte++;
}

/*
Constructorul de copiere, care primeste ca argument un obiect a acestei clase, si copie fiecare
camp a obiectului primit in *this
*/
Straus(Straus altObiect)
{
numeStrutz = altObiect.numeStrutz;
numarCopii = altObiect.numarCopii;
despreCopii = new int[numarCopii];
for(int i=0;i<numarCopii;i++)
{
despreCopii[i] = altObiect.despreCopii[i];
}
vitezaDeAlergare = altObiect.vitezaDeAlergare;
varsta = altObiect.varsta;
nrObiecte++;
}
 /*
Constructorul ce citeste din fisier toate datele necesare pentru crearea obiectului ...
primeste un string, si intelege separarea dupa separatorul ','
*/
Straus(String fileName)
{
String name = "";
int numCop = 0;
int[] dC = new int[10];
String viteza = "";
int age = 0;
try(BufferedReader br = new BufferedReader(new FileReader(fileName)))
{
String line;
while( (line = br.readLine()) != null )
{
String[] fields = line.split(",");
name = fields[0];
numCop = Integer.parseInt(fields[1]);
dC = new int[numCop];
for(int i=0;i<numCop;i++)
{
dC[i] = Integer.parseInt(fields[2+i]);
}
viteza = fields[numCop+2];
age = Integer.parseInt(fields[numCop+3]);
}
}catch(IOException e)
{
System.err.format("IOException: %s%n", e);
}
this.numeStrutz = name;
this.numarCopii = numCop;
this.despreCopii = new int[numCop];
for(int i=0;i<this.numarCopii;i++)
{
this.despreCopii[i] = dC[i];
}
this.varsta = age;
this.vitezaDeAlergare = viteza;
nrObiecte++;
}

/*################################ Geterii ###################################### */

public String getNumeStrutz()
{
return numeStrutz;
}
public int getNumarCopii()
{
return numarCopii;
}
public int[] getDespreCopii()
{
return despreCopii;
}
public int getCopil(int index)
{
if( (index >=0) && (index<=numarCopii))
{
return despreCopii[index];
}else {
System.out.println("Inexistent index in method getCopil");
return -100;
}
}
 public String getVitezaDeAlergare()
{
return vitezaDeAlergare;
}
public int getVarsta()
{
return varsta;
}
/*############################# Seteri #####################################*/
public void setNumeStrutz(String numeNou)
{
numeStrutz = numeNou;
}
public void setNumarCopii(int altNumar)
{
if(altNumar >= 0) {
numarCopii = altNumar;
}else{
System.out.println("Numar negativ pentru setter este imposibil");
}
}
public void setDespreCopii(int[] despre)
{
if(despre.length > despreCopii.length)
{
despreCopii = new int[despre.length];
for(int i=0;i<despre.length;i++)
{
despreCopii[i] = despre[i];
}
}
else {
for(int i=0;i<despre.length;i++)
{
despreCopii[i]=despre[i];
}
}
}

public void setCopil(int info, int index)

{
if((index >= 0) && (index <=numarCopii))
{
despreCopii[index] = info;
}else {
System.out.println("Nu exista asa index in care doriti sa schimbati copilul");
}
}

public void setVarsta(int age)

{
varsta = age;
}

public void setVitezaDeAlergare(String newViteza) {

vitezaDeAlergare = newViteza;
}
/* #################### Metoda de afisare pe ecran a tuturor campurilor
#########################*/
public void getInfoAboutOneObject()
{
int b = 0;
System.out.println("\n");
System.out.println("\n");
System.out.println(" Numele strutzului este -> "+ numeStrutz);
System.out.println(" Acest strutz are acest numar de copii -> "+ numarCopii);
 if(numarCopii > 0) {
System.out.println(" Informatie despre copii acestuia sunt ");
for(int i=0;i<numarCopii;i++)
{
b = i +1;
if(despreCopii[i] == -1) {
System.out.println(" Copilul numarul " + b + " este genul feminin");
} else if (despreCopii[i]==1) {
System.out.println(" Copilul numarul " + b + " este genul masculin");
}else {
System.out.println(" Acest copil a fost mincat ca Ou ;( ... trist");
}
}
}else {
System.out.println(" Acest strutz nu are copii, pentru el e totul inainte ;)");
}
System.out.println(" Viteza de alergat a acestui strutz este -> "+ vitezaDeAlergare);
System.out.println(" Varsta acestui strutz este -> "+ varsta);
}
public void getInfoAboutOneObject(Straus obj)
{
System.out.println(" Numele strutzului este -> "+ obj.numeStrutz);
System.out.println(" Acest strutz are acest numar de copii -> "+ obj.numarCopii);
if(obj.numarCopii > 0) {
System.out.println(" Informatie despre copii acestuia sunt ");
for(int i=0;i<obj.numarCopii;i++)
{
if(obj.despreCopii[i] == -1) {
System.out.println(" Copilul numarul" + i+1 + " este genul feminin");
} else if (obj.despreCopii[i]==1) {
System.out.println(" Copilul numarul" + i+1 + " este genul masculin");
}else {
System.out.println(" Acest copil a fost mincat ca Ou ;( ... trist");
}
}
}else {
System.out.println(" Acest strutz nu are copii, pentru el e totul inainte ;)");
}
System.out.println(" Viteza de alergat a acestui strutz este -> "+
obj.vitezaDeAlergare);
System.out.println(" Varsta acestui strutz este -> "+ obj.varsta);
}
/* ################################## Metoda ce creaza obiectul de la tastatura
################################## */
public void createObjectFromKeyboard()
{
System.out.println("\n");
System.out.println("\n");
Scanner scan = new Scanner(System.in);
System.out.print(" Dati numele strutzului -> ");
numeStrutz = scan.nextLine();
System.out.print(" Dati numarul copiilor strutului -> ");
numarCopii = scan.nextInt();
if(numarCopii > 0) {
System.out.println("Dati informatie despre fiecare copil :");
for (int i = 0; i < numarCopii; i++) {
System.out.print("Informatie despre copilul " + i + " ->");
despreCopii[i] = scan.nextInt();
}
}
scan.nextLine(); // In buffer ramine tasta enter dupa citirea ultimului copil, astfel o
citim pentru a nu provoca eroari

System.out.print("Dati viteza de alergat -> ");

vitezaDeAlergare = scan.nextLine();
System.out.print("Dati varsta strutzului -> ");
 varsta = scan.nextInt();
}
/* ################################## Metode ce umple clasul cu date aleatoare (Random)
##################################### */
public void fillRandom()
{
Random rand = new Random();
int nameLength = rand.nextInt(15);
String upperCharSet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
String lowerCharSet = "abcdefghijklmnopqrstuvwxyz";

StringBuilder sb = new StringBuilder();

char randomUpperChar = upperCharSet.charAt(rand.nextInt(upperCharSet.length()));
sb.append(randomUpperChar);

for(int i=0;i<nameLength-1;i++)
{
char randomLowerChar = lowerCharSet.charAt(rand.nextInt(lowerCharSet.length()));
sb.append(randomLowerChar);
}
numeStrutz = sb.toString();
numarCopii = rand.nextInt(0,10);
despreCopii = new int[numarCopii];
for(int i=0;i<numarCopii;i++)
{
despreCopii[i] = rand.nextInt(-1,2);
}
int speed = rand.nextInt(100);
vitezaDeAlergare = Integer.toString(speed) + " Km/h";
varsta = rand.nextInt(100);
}
/* ################################## Metode comparare intre doua obiecte
##################################### */
public void MulteOua(Straus alt)
{
System.out.println("\n\n");
if(this.numarCopii > alt.numarCopii)
{
System.out.println(this.numeStrutz + " are mai multi copii ca "+ alt.numeStrutz);
} else if (this.numarCopii < alt.numarCopii) {
System.out.println(this.numeStrutz + " are mai putini copii ca "+ alt.numeStrutz);
} else if (this.numarCopii == alt.numarCopii) {
System.out.println(this.numeStrutz + " are exact tot atiti copii ca si "+
alt.numeStrutz);
}
}
/* ################################## Metoda ce calculeaza cate oua cu valoarea 0 are
obiectul ############### */
public int getAllEatenEggs()
{
int count = 0;
for(int i=0;i<numarCopii;i++)
{
if(despreCopii[i] == 0)
{
count++;
}
}
return count;
}
/* ################################## Metode ce scrie in file toate campurile obiectului
################### */
public void writeToFile(String fileName)
{
try{
BufferedWriter printer = new BufferedWriter (new FileWriter(fileName));
 printer.write("Numele -> " + numeStrutz);
printer.newLine();
printer.write("Numarul copiilor este -> " + Integer.toString(numarCopii));
printer.newLine();
if(numarCopii > 0)
{
for(int i=0;i<numarCopii;i++) {
if(despreCopii[i]==1)
{
printer.write("[Mascul:" + Integer.toString(i) + "] ");
} else if (despreCopii[i]==-1) {
printer.write("[Femela:" + Integer.toString(i) +"] ");
} else{
printer.write("[Acest ou a fost mincat :" + Integer.toString(i) + "] ");
}
}
printer.newLine();
}else {
printer.write("Acest strutz nu are copii");
printer.newLine();

}
printer.write("Viteza de alergare este ->" + vitezaDeAlergare);
printer.newLine();
printer.write("Varsta strudzului este -> "+ Integer.toString(varsta));
printer.newLine();

printer.close();

}catch(Exception e) {
e.printStackTrace();
}
}

public static void main(String[] args) {

ArrayList<Straus> javaVector = new ArrayList<Straus>();

System.out.println("\n");
Straus strutz1 = new Straus();
strutz1.getInfoAboutOneObject(); //Creem obiect cu constructor default fara argumenti
javaVector.add(strutz1);

int[] despreCopiiLaObiect = new int[4];

despreCopiiLaObiect[0]=1;
despreCopiiLaObiect[1]=0;
despreCopiiLaObiect[2]=-1;
despreCopiiLaObiect[3]=-1; //Creem obiect cu constructorul cu argumenti
Straus strutz2 = new Straus("Coliseum",4,despreCopiiLaObiect,15);
strutz2.getInfoAboutOneObject();
javaVector.add(strutz2);

strutz2.MulteOua(strutz1); // Comparam dupa numarul de oua

Straus copyStrutz = new Straus(strutz1);

copyStrutz.getInfoAboutOneObject(); //Copiem un obiect in alt obiect
javaVector.add(copyStrutz);

Straus randomStrutz = new Straus();

randomStrutz.fillRandom(); //Creem un obiect aleator cu date Random
randomStrutz.getInfoAboutOneObject();
javaVector.add(randomStrutz);

//Calculam numarul de valori 0 in tabelul de copii(oua)

 System.out.println("\n\n" + Integer.toString(randomStrutz.getAllEatenEggs()) + "\n\n");

//Creem un strutz din file txt

Straus fileStrutz = new Straus("fileStrutz.txt");
fileStrutz.getInfoAboutOneObject();
javaVector.add(fileStrutz);

//Creem un strutz de la tastatura

Straus keyboardStrutz = new Straus();
keyboardStrutz.createObjectFromKeyboard();
keyboardStrutz.getInfoAboutOneObject();
javaVector.add(keyboardStrutz);

//Scriem toate campurile unui strutz in fisier

randomStrutz.writeToFile("randomStrutz.txt");

//Parcurgem toate obiectele create anterior si le scriem campurile in fisiere

//cu numele object.numestrutz.txt
for( Straus obj : javaVector)
{
obj.writeToFile(obj.getNumeStrutz() + ".txt");
}

System.out.println("\n\nIn total au fost creati -> " + Integer.toString(nrObiecte) + "

obiecte ... strutzi");
}
}

Rezultatele rularii programului

Numele strutzului este -> Domenic
Acest strutz are acest numar de copii -> 4
Informatie despre copii acestuia sunt
Copilul numarul 1 este genul masculin
Copilul numarul 2 este genul masculin
Copilul numarul 3 este genul masculin
Copilul numarul 4 este genul masculin
Viteza de alergat a acestui strutz este -> 50 Km/h
Varsta acestui strutz este -> 20

Numele strutzului este -> Coliseum

Acest strutz are acest numar de copii -> 4
Informatie despre copii acestuia sunt
Copilul numarul 1 este genul masculin
Acest copil a fost mincat ca Ou ;( ... trist
Copilul numarul 3 este genul feminin
Copilul numarul 4 este genul feminin
Viteza de alergat a acestui strutz este -> X Km/h
Varsta acestui strutz este -> 15

Coliseum are exact tot atiti copii ca si Domenic

 Numele strutzului este -> Domenic
Acest strutz are acest numar de copii -> 4
Informatie despre copii acestuia sunt
Copilul numarul 1 este genul masculin
Copilul numarul 2 este genul masculin
Copilul numarul 3 este genul masculin
Copilul numarul 4 este genul masculin
Viteza de alergat a acestui strutz este -> 50 Km/h
Varsta acestui strutz este -> 20

Numele strutzului este -> Gie

Acest strutz are acest numar de copii -> 6
Informatie despre copii acestuia sunt
Copilul numarul 1 este genul masculin
Copilul numarul 2 este genul masculin
Copilul numarul 3 este genul feminin
Copilul numarul 4 este genul masculin
Copilul numarul 5 este genul masculin
Copilul numarul 6 este genul feminin
Viteza de alergat a acestui strutz este -> 43 Km/h
Varsta acestui strutz este -> 80

Numele strutzului este -> Ion

Acest strutz are acest numar de copii -> 2
Informatie despre copii acestuia sunt
Copilul numarul 1 este genul masculin
Copilul numarul 2 este genul feminin
Viteza de alergat a acestui strutz este -> 20 KM/h
Varsta acestui strutz este -> 30

Dati numele strutzului -> Strudusus

Dati numarul copiilor strutului -> 3
Dati informatie despre fiecare copil :
Informatie despre copilul 0 ->1
Informatie despre copilul 1 ->-1
Informatie despre copilul 2 ->0
Dati viteza de alergat -> 26 KM/h
Dati varsta strutzului -> 34

Numele strutzului este -> Strudusus

Acest strutz are acest numar de copii -> 3
Informatie despre copii acestuia sunt
Copilul numarul 1 este genul masculin
Copilul numarul 2 este genul feminin
Acest copil a fost mincat ca Ou ;( ... trist
Viteza de alergat a acestui strutz este -> 26 KM/h
Varsta acestui strutz este -> 34

In total au fost creati -> 6 obiecte ... strutzi

Process finished with exit code 0

Concluzie
In concluzie pot afirma ca in urma acestei lucrari de laborator am invatat de a crea obiecte, prin foarte multe metode ce
de difera una de alta … la fel am invatat de a gestiona campurile unui obiect creat in urma a diferitor costructori. In
acelasi timp am invatat de a ma folosi de fisiere in cod, in ambele parti, cat citirea atat si scrierea.