Exemplul lucrării practice (listingul programului)

class Student

{

String name; // numele studentului

float lazy; //coeficientul lenii studentului

double IQ; //coeficientul intelectului

byte exams; //numărul de examene ale studentului

int marks[]; //vectorul dinamic cu notele studentului

static int nr; //numărul de studenți creați(obiectelor clasei)

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

Student () // constructor implicit (fără arametri ) fără introducerea datelor de la tastatură (-1bal)

{

name = "Michidutsa Ionescu";

lazy = 0.5f;

IQ = 120.7;

exams = 6;

marks = new int[exams]; //alocăm memorie pentru vectorul de note – tipul elementelor este int, numărul lor = exams

for (int y=0; y<exams; y++) //prin ciclu umplem vectorul cu opturi. Variabila ciclului - y

marks[y] = 8;

nr ++; //dacă este chemat constructorul => a fost creat un obiect => numărul obiectelor (nr) crește

}

Student (float new_lazy, double IQ, byte new_exams) // constructor cu 3 parametri

{

name = "Ion Strengaru";

if ( (new_lazy >= 0) && (new_lazy <= 1) ) //înainte de a folosi parametrul new_lazy, îi controlăm corectitudinea lazy = new_lazy; //daca este corect, introducem valoarea lui în lazy

if ( (IQ >= 100) && (IQ <= 200) ) // înainte de a folosi parametrul IQ, îi controlăm corectitudinea

this.IQ = IQ; // daca este corect, introducem valoarea lui în this.IQ

if ( (new_exams >= 0) && (new_exams < 20) ) // înainte de a folosi parametrul new_exams, îi controlăm corectitudinea

exams = new_exams; // daca este corect, introducem valoarea lui în exams

marks = new int[exams]; // alocăm memorie pentru vectorul de note – tipul elementelor este int, numărul lor = exams

for (int i=0; i<exams; i++) // prin ciclu umplem vectorul cu nouri. Variabila ciclului - i

marks[i] = 9;

nr ++; // dacă este chemat constructorul => a fost creat un obiect => numărul obiectelor (nr) crește

}

Student (String name, double iq) //constructor cu alți parametri

{

this.name = name; //pentru a face diferența dintre numele parametrului și cîmpul clasei, folosim this

lazy = 0.8f;

if ( (iq >= 100) && (iq <= 200) ) // controlăm corectitudinea parametrului IQ

IQ = iq;

exams = 4;

marks = new int[exams]; // alocăm memorie pentru vectorul de note – tipul elementelor este int, numărul lor = exams

for (int i=0; i<exams; i++) // prin ciclu umplem vectorul cu note de zece. Variabila ciclului - i

marks[i] = 10;

nr ++; // dacă este chemat constructorul => a fost creat un obiect => numărul obiectelor (nr) crește

}

Student (Student Clon) //constructorul de copiere este obligat să copie TOATE cîmpurile obiectului-parametru Clon

{

name = Clon.name;

lazy = Clon.lazy;

IQ = Clon.IQ;

exams = Clon.exams;

marks = new int[exams]; // alocăm memorie pentru vectorul de note – tipul elementelor este int, numărul lor = exams

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

marks[i] = Clon.marks[i];

nr ++; // dacă este chemat constructorul => a fost creat un obiect => numărul obiectelor (nr) crește

}

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

public String get_name() // accesul la cîmpul clasei name – returnează copia valorii cîmpului dat

{

return name; // return this.name

}

public float get_lazy() // accesul la cîmul clasei lazy – returnează copia valorii cîmpului dat

{

return lazy; //return this.lazy

}

public double get_IQ() // accesul la cîmul clasei IQ – returnează copia valorii cîmpului dat

{

return IQ; //return this.IQ

}

public byte get_exams() // accesul la cîmul clasei exams – returnează copia valorii cîmpului dat

{

return exams; //return this.exams

}

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;

}

}

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

public void set_name(String new_name) //setează în cîmpului clasei name valoarea nouă a parametrului new_name

{

name = new_name; // this.name = new_name;

}

public void set_lazy(float new_lazy) // setează în cîmpului clasei lazy valoarea nouă a parametrului new_lazy

{

if ( (new_lazy >= 0) && (new_lazy <= 1) ) // înainte de a folosi parametrul new_lazy, îi controlăm corectitudinea

lazy = new_lazy; // daca este corect, introducem valoarea lui în lazy

}

public void set_IQ( double new_IQ) // setează în cîmpului clasei IQ valoarea nouă a parametrului new_IQ

{

if ( (new_IQ >= 100) && (new_IQ <= 200) ) // înainte de a folosi parametrul IQ, îi controlăm corectitudinea

IQ = new_IQ; // daca este corect, introducem valoarea lui în this.IQ

}

public void set_exams(byte new_exams) // setează în cîmpului clasei exams valoarea nouă a parametrului new_exams

{

if ( (new_exams >= 0) && (new_exams <= 20) && (new_exams != exams) ) //controlăm corectitudine lui new_exams

{

exams = new_exams; // daca este corect, introducem valoarea lui în exams

marks = new int[new_exams]; //deoarece s-a schimbat numărul examenelor, trebuie să se schimbe și numărul notelor =>

} //realocăm memoria pentru marks, pierzînd valorile vechi ale vectorului.(-1bal)

} //În caz ideal le-ar trebui de salvat în vectorul temporar, și de acolo de a le copia în vectorul nou marks cu memorie realocată.

public void set_mark(int index, int new_mark) //setează nota (sub indicele = index) din marks cu new_mark

{

if ( (index >= 0) && (index < exams) && (new_mark >= 0) && (new_mark <= 10) ) //controlăm corectitudinea parametrilor

marks[index] = new_mark; //dacă sunt corecte, introducem nota new_mark în poziția cu indicile index

}

//////////////////////////////////////metoda afisării la ecran a tuturor cîmpurilor clasei /////////////////////////////////////////

public void printInfo()

{

System.out.println (" Student’s name is " + name );

System.out.println (" Student’s laziness is " + lazy );

System.out.println (" Student’s IQ is " + IQ );

System.out.println (" Student has " + exams + " exams" );

System.out.println (" Student’s marks are : " );

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

System.out.print (" " + marks[i] + " "); //afișăm toate notele studentului intr-o linie, separîndu-le prin spațiu

System.out.println (" \n ----------------------------------------------------------- " );

}

//////////////////////////////////////metoda de calculare a mediei aritmetice notelor studentului/////////////////////////////////////////

public double averageMark()

{

int sum = 0;

for (int i=0; i<exams; i++) //aflăm suma tuturor notelor studentului

sum += marks[i]; //adăugînd în variabila sum cîte un element din vector(cîte o notă, începînd cu poziția 0, pînă la ultima)

return (sum/exams); //returnăm media aritmetica a notelor studentului, adică suma/numărul notelor.

}

/////////////////////////////////////////metoda de calculare a bursei studentului///////////////////////////////////////////

public double bursary()

{

return ( 500 + IQ / lazy ); //cu cît e mai mare IQ și cu cît e mai mică lenea, cu atît e mai mare bursa :)

}

////////////////////////////////////////////////metoda «eminent»/////////////////////////////////////////////////////

public void eminent (Student Petrica)

{

if ( this.averageMark() > Petrica.averageMark() ) //dacă studentul-apel invață mai bine ca studentul-parametru Petrica

System.out.println ( this.name + " learns better, than " + Petrica.name );

if ( this.averageMark() < Petrica.averageMark() ) // dacă studentul-apel invață mai rău ca studentul-parametru Petrica

System.out.println (Petrica.name + " learns better, than " + name );

else

System.out.println (Petrica.name + " and " + name + " learn equally" );

} // dacă studentul-apel invață la fel ca studentul-parametru Petric a

////////////////////////////////////////////////metoda «desteptu»/////////////////////////////////////////////////////

public static void desteptu (Student Ionica, Student Petrica)

{

if ( Ionica.bursary() > Petrica.bursary() ) // dacă primul student Ionica este mai deștept ca Petrica (primește bursă mai mare)

System.out.println ( Ionica.name + " is smarter, than " + Petrica.name );

if ( Ionica.IQ > Petrica.IQ ) // dacă primul student Ionica este mai prost (bursa mai mică) ca Petrica

System.out.println ( Petrica.name + " is smarter, than " + Ionica.name );

else

System.out.println ( Petrica.name + " and " + Ionica.name + " are equally intelligent " );

} // dacă ambii sunt la fel de deștepți (de proști) (bursele egale)

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

public static void main (String args[])

{

System.out.println("\n");

Student Alex = new Student (); //creăm obiectul – pe studentul Alex - cu constructorul implicit(fără parametri)

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

Student Dima = new Student (0.4f, 130.8, (byte)5); //îl creăm pe Dima, folosind constructorul cu 3 parametri.

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

Student Galea = new Student ( “Nicorici Galina”, 180.9 ); // Pe Galea am creat-o cu constructorul cu 2 parametri.

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

Student Dolly = new Student (Dima); //studenta Dolly a fost clonată (creată cu constructorul de copiere) de la Dima

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

int nrStudGrupa = 8;

Student grupa[] = new Student[nrStudGrupa] ; //creăm și alocăm memorie pentru grupa de studenți – vector dinamic din 12 elemente for (int i=0; i< nrStudGrupa; i+=4) // umplem elementele vectorului cu obiectele clasei student

{

grupa[i] = new Student(); //elementele 0, 4 le umplem cu studenti creați cu constructor implicit grupa[i+1] = new Student(0.7f, 180.0, (byte)3); // elementele 1, 5 le umplem cu studenti creați cu constructor cu 3 parametri grupa[i+2] = new Student(“Student”+(i+2), 145.9); // elementele 2, 6 – constructor cu 2 parametri

grupa[i+3] = new Student(Alex); // sau grupa[i+3] = new Student(grupa[i]); // elementele 3, 7 – le copiem de pe Alex.

}

for (int i=0; i< nrStudGrupa; i++) //prin ciclu afisăm informația despre toți studenții grupei

{

grupa[i].set_name("Student nr "+ (i+1)); //schimbăm numele fiecărui student cu Student nr 1, Student nr 2, ș.a.m.d.

grupa[i].printInfo(); // grupa[0], grupa[1], ș.a.m.d.– numele obiectelor care se află pe pozițiile concrete 0,1 ș.a.m.d. }

Dolly.eminent(Dima); // comparăm cine mai bine invață: Dolly(obiectul care apelează(curent)) sau Dima

Galea.eminent(grupa[2]); // comparăm cine mai bine invață:: Галя (obiectul care apelează(curent)) sau grupa[2].

grupa[0].eminent(Alex); // comparăm cine mai bine invață: grupa[0] (obiectul care apelează(curent)) sau Alex.

grupa[7].eminent(grupa[5]); // comparăm cine mai bine invață: grupa[7] (obiectul care apelează(curent)) sau grupa[5].

System.out.println("\n");

desteptu(Alex, Dolly); //vedem cine e mai deștept: Alex sau Dolly

desteptu(grupa[6], Galea); // vedem cine e mai deștept: al zecelea student din grupă ( grupa[6] ) sau Galea

desteptu(grupa[3], grupa[5]); // vedem cine e mai deștept al patrulea sau al saselea student din grupă

System.out.println("\n");

float maxLazy = 0; //în variabila maxLazy vom salva coeficientul maximal al lenii studentului

int indexMaxLazy = 0; // în variabila indexMaxLazy vom salva numărul studentului din grupă cu cea mai mare lene

for (int i=0; i< nrStudGrupa; i++) //parcurgem toți studenții grupei

if (grupa[i].lazy > maxLazy) // daca lenea celui curent (i dupa poziție) e mai mare ca maxLazy,

{

maxLazy = grupa[i].lazy; // atunci memorizăm lenea curentă în maxLazy

indexMaxLazy = i; // și memorizăm № celui mai lenos student la moment în indexMaxLazy

}

System.out.println (“\n\n The champion in Lazyness is ” + grupa[indexMaxLazy].name + “ ! ! ! ”); //afișăm pe cel mai lenos :)

// afișăm numărul stundeților creați, adică variabila statică nr (poate fi apelata de la numele clasei: Student.nr)

System.out.println (“\n We created ” + nr + “ students…”); //sau System.out.println (“\n We created ” + Student.nr + “ students…”);

}

}