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

Clasa: „Student”

Efectuat: studentul (-a) grupei _________

numele, prenumele___________

Verificat: lect.univers., magistru in inform.

Epifanova Irina .

- Chişinău 2021 -
Formularea priblemei:

De creat clasa “Student” cu câteva câmpuri.

Cîmpurile obligatorii:
- cîmpul de tip șir de caractere, care păstrează numele studentului.
- 2 cîmpuri fracționale (float, double), ce păstrează coeficienții lenii (0 - 1) și IQ (100 - 200) ai studentului.
- cîmp de tip număr intreg (byte), care păstrează informația despre numărul de examene ai studentului.
- vector dinamic (int), care păstrează informația despre notele studentului la fiecare examen (de la 0 la 10)
- cîmp static de tip întreg, care păstrează informația despre numărul studenților creați.

Cîmpurile neobligatorii: grupa, numărul pașaportului, nocivitatea, sexul ș.a.m.d.

De creat trei tipuri de constructori pentru această clasă (cu alocare dinamică a memoriei):
- constructor standard (implicit - fără parametri) – toate datele de introdus de la tăstatură
- 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 student.

De scris o funcţie care va calcula media aritmetică a notelor studentului.

De scris o funcţie ce calculеаză bursa studentului (luînd în considerație IQ și lenea lui).

De scris o funcţie ”eminent”care compară 2 studenți(unu care apelează și altul primit ca parametru) dupa media
aritmetica a notelor, folosind funcția descrisă mai sus. De afișat la ecran numele celui care învață mai bine.

De scris o funcţie static ”desteptu”, care primeşte ca parametri doi studenți, şi care calculează cu cît primul
student e mai deștept ca al doilea(în lei – după bursă) sau mai prost ca acesta (rezultatul de afișat la ecran).

În funcţia main() de creat o gașcă de studenți, folosind toţi constructorii descrişi. După crearea fiecărui obiect
al clasei „Student”, de afişat la ecran cîmpurile lui folosind metoda clasei. De creat un vector dinamic de
studenți -"grupa". Vectorul să fie iniţializat pe bucăţi, folosind constructori diferiţi. În ciclu de afişat toată
informaţia despre fiecare student din grupă. De comparat cîțiva perechi de studenți după ”eminență” și
”deșteptăciune”. De găsit și de afișat numele celui mai lenos student din grupă. Ultimul rînd afişat să conţină
numărul studenților creați, folosind variabila statică a clasei.

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.

După ce totul a fost terminat fără greşele — de spus “URRRRRRRRRAAAAAAAAAA ! ! ! !” şi de prezentat

primul laborator profesorului. :)
 Codul sursa (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…”);
}
}

Rezultatele rulării programului (testingul programului)

D:\JDK\bin>javac StudentTest.java Students name is Nicorici Galina Students marks are :

Students lazyness is 0.8 8 8 8 8 8 8
D:\JDK\bin>java Student Students IQ is 180.9 --------------------------------------
Student has 4 exams Students name is Student nr 2
Students name is Michidutsa Ionescu Students marks are : Students lazyness is 0.7
Students lazyness is 0.5 10 10 10 10 Students IQ is 180.0
Students IQ is 120.7 -------------------------------------- Student has 3 exams
Student has 6 exams Students name is Ion Strengaru Students marks are :
Students marks are : Students lazyness is 0.5 9 9 9
8 8 8 8 8 8 Students IQ is 120.7 --------------------------------------
-------------------------------------- Student has 6 exams Students name is Student nr 3
Students name is Ion Strengaru Students marks are : Students lazyness is 0.8
Students lazyness is 0.4 8 8 8 8 8 8 Students IQ is 145.9
Students IQ is 130.8 -------------------------------------- Student has 4 exams
Student has 5 exams Students name is Student nr 1 Students marks are :
Students marks are : Students lazyness is 0.5 10 10 10 10
9 9 9 9 9 Students IQ is 120.7 --------------------------------------
-------------------------------------- Student has 6 exams Students name is Student nr 4
Students lazyness is 0.5 -------------------------------------- equally
Students IQ is 120.7 Students name is Student nr 7 Michidutsa Ionescu and Student nr 1 learn
Student has 6 exams Students lazyness is 0.8 equally
Students marks are : Students IQ is 145.9 Student nr 6 learns better, than Student
8 8 8 8 8 8 Student has 4 exams nr 8
-------------------------------------- Students marks are :
Students name is Student nr 5 10 10 10 10 Ion Strengaru and Michidutsa Ionescu are
Students lazyness is 0.5 -------------------------------------- equally intelligent
Students IQ is 120.7 Students name is Student nr 8 Nicorici Galina and Student nr 7 are equally
Student has 6 exams Students lazyness is 0.5 intelligent
Students marks are : Students IQ is 120.7 Student nr 6 and Student nr 4 are equally
8 8 8 8 8 8 Student has 6 exams intelligent
-------------------------------------- Students marks are :
Students name is Student nr 6 8 8 8 8 8 8 The champion in Lazyness is Student nr
Students lazyness is 0.7 -------------------------------------- 3!!!
Students IQ is 180.0
Student has 3 exams Ion Strengaru and Ion Strengaru learn We created 12 students
Students marks are : equally
9 9 9 Student nr 3 and Nicorici Galina learn D:\JDK\bin>

Concluzii.

Este o parte, unde trebuie să fie descrisă cu ce ati lucrat, care mecanizme noi ati invatat in lucrarea data ... In
general — descrieti plusuri si minusuri lucrarii.

Vreau sa comentez niste momente. Varianta 00 a lucrării de laborator numărul 1 este realizată pe nota 7.
Deoarece în constructorul implicit nu este descrisă introducerea datelor de la tastatură pentru cîmpurile clasei
(-1 bal), nu este descris algoritmul salvării valorilor vechi ai notelor în metoda set_exams (-1 bal) și nu este
descris lucrul cu fișier textual (-1 bal).
Condiția obligatorie (testarea în funcție a TUTUROR parametrilor de intrare (de tipuri elementare) la
corectitudine, înaintea utilizării lor) este îndeplinită. În exemplu este prezentată doar o variantă de lucru a
programului, deoarece în cod nu este realizată citirea de la tastatură și de aceea programul nu presupune nici o
variație dinamică.
 Criteriile notei pentru lucrarea de laborator №1
Lab1 "Realizarea claselor în limbajul Java" puncte
1 Descrierea a 3 tipuri de constructori +1
2 Lucrul cu vector dinamic ca cîmp al clasei (crearea, alocarea memoriei, inițializarea lui) +1
Metodele set_*(), get_*(), prelucrarea TUTUROR parametrilor de intrare, salvarea datelor
3 +1
vechi în cazul înlocuirii lor.
4 Folosirea corecta cuvîntului cheie this +1
5 Descrierea și apelul variabilei statice și funcției statice clasei. +1
6 Descrierea funcției main și crearea obiectelor individuale ale clasei. +1
7 Apelul metodelor clasei de la numele obiectelor clasei. +1
8 Lucrul cu vectorul dinamic de obiecte ale clasei (crearea, alocarea memoriei, inițializarea lui) +1
9 Introducerea datelor de la tastatură +1
10 Lucrul cu fișier textual +1
Total: + 10

Schema de calcul a notei generale la obiectul Java

Notația convenționala a notei, formula de calcul a ei.
Lucrarea de lab. №1 nota L1se pune conform punctajului lucrării de laborator № 1
Lucrarea de lab. №2 nota L2se pune conform punctajului lucrării de laborator № 2
Lucrarea de lab. №3 nota L3 se pune conform punctajului lucrării de laborator № 3
Lucrarea de lab. №4 nota L4se pune conform punctajului lucrării de laborator № 4
Lucrarea de lab. №5 nota L5se pune conform punctajului lucrării de laborator № 5
Atestarea №1 nota А1 nota pentru lucrarea de atestare scrisă №1
Atestarea №2 nota А2 nota pentru lucrarea de atestare scrisă №2
Nota pentru semestru nota Sem = (L1 + L2 + L3 + L4 + L5 + A1 + A2) / 7
Nota pentru examen nota Test
Nota generală nota Rez = (Sem + Test) /2, unde 60% - din Sem si 40% - din Test

Observații (generale):
1) Prezentarea lucrării de laborator constă în apărarea ei(prezentarea lucrării profesorului)și darea de seamă.
2) Dacă studentul nu a prezentat lucrarea la timp, ea nu se mai acceptă și pentru lucrare se pune nota 4.
3) Dacă studentul a prezentat lucrarea, dar nu a trimis darea de seamă, lucrarea nu se mai acceptă și pentru ea se pune
nota 4.
4) Dacă studentul nu a prezentat lucrarea profesorului, dar numai a transmis darea de seamă, pentru ea se pune nota 4.
5) Dările de seamă pentru lucrările de laborator NU se scot la printer, ci se trimit în forma electronică (în una dintre
variantele *.doc, *.docx, *.odt, *.pdf) pe adresa e-mail epifanova.irina@gmail.com
6) Atestarea – lucrare scrisă, care se scrie în timpul perechii de prelegere.
7) În cazul cînd nota pentru examen e mai mică ca cinci ( Test < 5 ) atunci nota generală se pune 4 ( Final = 4 ). În cazul
dat nota pe semestru nu se ia în considerare.
8) La examen NU sunt admiși toți studenții, care au nota pe semestru < 5.
9) În cazul cînd toate lucrările de laborator sunt date(Li >= 5, i=1, .., 5) și nota semestrială e mai mare ca 8 (Sem>=9 ),
atunci nota pentru examen nu va fi mai mică ca nota semestrială.
10) Prezența la examen pentru efectuarea lucrării scrise este obligatorie pentru toți.
Termenii limită și datele (luînd în considerație că semestrul durează 15 săptămîni)
La efectuarea, apărarea și prezentarea ei se dau 4 săptămîni (săpt. 1 – 4 de la începutul
Lab №1
semestrului)
La efectuarea, apărarea și prezentarea ei se dau 3 săptămîni (săpt. 5 – 7 de la
Lab №2
începutulsemestrului)
Atestarea №1 Lucrarea scrisă se dă la perechea de prelegeri a săptămînii 6 de la începutul semestrului.
La efectuarea, apărarea și prezentarea ei se dau 3 săptămîni (săpt. 8 – 9 de la
Lab №3
începutulsemestrului)
La efectuarea, apărarea și prezentarea ei se dau 2 săptămîni (săpt. 10 – 11 de la începutul
Lab №4
semestrului)
La efectuarea, apărarea și prezentarea ei se dau 3 săptămîni (săpt. 12 – 13 de la începutul
Lab №5
semestrului)
Atestarea №2 Lucrarea scrisă se dă la perechea de prelegeri a săptămînii 12 de la începutul semestrului.
11) Codul sursă trebuie sa fie structurat conform standartului lui Olman:
http://ru.wikipedia.org/wiki/Отступ_(программирование) / http://en.wikipedia.org/wiki/Indent_style
... nameFunction(<...>) if (<…>) for (<…>) else while (<…>) switch ( <...> )
{ { { { { {
········<body> ······<body> ······<body> ······<body> ······<body> case <...> : <...>;
} } } } } }
Dacă codul sursă este scris în mediul NetBeans – de apăsat Alt+Shift+F pentru structurarea (formatarea) automatică,
iar dacă lucrarea este scrisă în Eclipse – de apăsat Ctrl+Shift+F