Laboratorul 1

Laboratorul 1
Introducere – Utilitare şi mediul de execuţie

1. Regulament de disciplină
 Prezenţa la orele de laborator este obligatorie.
 Studenţii sunt obligaţi să respecte orarul laboratorului, grupele/semigrupele din care fac
parte.
 Recuperarea orelor de laborator se face în conformitate cu regulamentul universităţii.
 În urma activităţilor de laborator, fiecare student va fi evaluat. Nota minimă de trecere
este 5. Studenţii cu situaţia neîncheiată sau cu nota sub 5 nu vor putea susţine examenul de
disciplină.

2. Obiectivele laboratorului
 prezentarea obligaţiilor ce revin studenţilor pentru a putea susţine examenul de disciplină;
 prezentarea uneltelor necesare pentru orele de laborator ale disciplinei Sisteme de Timp
Real;
 scurtă recapitulare ale unor noţiuni fundamentale ale limbajului de programare Java.

3.Unelte necesare pentru laborator

În prima parte a laboratorului se vor dezvolta aplicaţii Java folosind Java 2 SE 1.6
(J2SE). Pentru a putea scrie prima aplicaţie Java, primul pas este descărcarea şi instalarea
kitului de dezvoltare Java. Paşii ce trebuiesc urmaţi sunt următorii:

 De pe pagina http://www.java.com/en/download/manual_v6.jsp se selectează platforma

dorită, în conformitate cu sistemul de operare pe care aceasta va trebui să ruleze.

 După descărcarea JDK-ului (Java Development Kit), instalarea se realizează prin simpla
execuţie a fişierului executabil.

 Pe lângă componentele J2SE este util să se download-eze şi să se dezarhiveze în directorul

jdk1.6.x_<version>/docs, documentaţia html corespunzătoare platformei J2SE instalate.

Teoretic după instalarea J2SE pot fi construite, compilate şi rulate aplicaţii Java fără a
mai fi nevoie de alte unelte suplimentare. Pentru aceasta trebuiesc realizaţi următorii paşi:

PAS 1. Editare fişier sursă şi salvarea acestuia cu extensia .java (folosind Notepad, de
exemplu).

PAS 2. Compilarea fişierului sursă utilizând utilitarul javac.exe. În urma compilării se va

genera fişierul executabil Java (byte code) având extensia: .class.

PAS 3. Executarea aplicaţiei utilizând programul java.exe .

1
Introducere – Utilitare şi mediul de execuţie
Dezvoltarea de aplicaţii complexe Java, care de obicei conţin mai multe fişiere sursă,
poate deveni foarte dificilă în condiţiile utilizării unui editor de text simplu. Este recomandat
ca programatorul să îşi aleagă şi să îşi instaleze pe lângă platforma J2SE, o aplicaţie care să îl
ajute în dezvoltarea aplicaţiilor. O astfel de aplicaţie poartă numele de IDE (Integrated
Development Environment). În prezent, există pe piaţă o mare varietate de medii de dezvoltare
dintre care programatorul poate să aleagă. Câteva exemple sunt:
- Borland Jbuilder www.borland.com/jbuilder;
- Java CodeGuide www.omnicore.com ;
- JCreator www.jcreator.com;
- NetBeand www.netbeans.org;
- Eclipse www.eclipse.org;
- IntelliJ IDEA www.jetbrains.com;
- etc.

În cadrul laboratorului va fi utilizat mediul integrat de dezvoltare Eclipse. Acesta este

gratuit şi se poate descărca de pe pagina http://www.eclipse.org/downloads/index.php (se
recomandă descărcarea versiunii Eclipse IDE for Java Developers). Instalarea constă în
dezarhivarea mediului Eclipse în locaţia dorită, după care se execută programul eclipse.exe.
Este recomandat ca înainte de instalarea mediului Eclipse să se instaleze J2SE.

Observaţie:
Instalarea unor unelte suplimentare, necesare dezvoltării aplicaţiilor Java de timp-real,
va fi prezentată în cadrul Laboratorului 8.

5. Recapitularea principalelor noţiuni ale limbajului de programare Java

Java este un limbaj de programare de nivel înalt, iniţial dezvoltat de JavaSoft,

companie în cadrul firmei Sun Microsystems (preluată ulterior de firma Oracle). Dintre
caracteristicile principale ale limbajului merită amintite următoarele:
 simplitate, elimină supraîncarcarea operatorilor, moştenirea multiplă şi toate
"facilităţile" ce pot provoca scrierea unui cod confuz;
 robusteţe, elimină sursele frecvente de erori ce apar în programare prin eliminarea
pointerilor, administrarea automată a memoriei şi eliminarea fisurilor de memorie
printr-o procedură de eliberare automată a memoriei de obiectele care nu mai sunt
folosite;
 complet orientat pe obiecte, elimină complet stilul de programare procedural;
 uşurinţă în ceea ce priveşte programarea în reţea;
 securitate, asigurând mecanisme stricte de securitate a programelor concretizate prin:
verificarea dinamică a codului pentru detectarea secvenţelor periculoase, impunerea
unor reguli stricte pentru rularea programelor lansate pe calculatoare aflate la distanţă,
etc.
 este neutru din punct de vedere arhitectural;
 portabililtate, cu alte cuvinte Java este un limbaj independent de platforma de lucru,
aceeaşi aplicaţie rulând, fără nici o modificare, pe sisteme diferite cum ar fi Windows,
UNIX sau Macintosh;
 compilat şi interpretat;
 asigură o performanţă ridicată;
 permite programarea cu fire de execuţie (multitheaded).

2
 Laboratorul 1

5.1. Java : un limbaj compilat şi interpretat

În funcţie de modul de execuţie al programelor, limbajele de programare se împart în
două categorii :
 interpretate : instrucţiunile sunt citite linie cu linie de un program numit interpretor şi
traduse în instrucţiuni maşină; avantaj : simplitate; dezavantaje : viteza de execuţie
redusă
 compilate : codul sursă al programelor este transformat de compilator într-un cod ce
poate fi executat direct de procesor; avantaj : execuţie rapidă; dezavantaj : lipsa
portabilităţii, codul compilat într-un format de nivel scăzut nu poate fi rulat decât pe
platforma pe care a fost compilat.

În urma compilării unui program Java rezultă un set de fişiere speciale numite cod de
octeţi (eng. byte code). Aceste fişiere nu sunt executabile pe nici un sistem de operare. Pentru
a putea fi rulate este nevoie de o Maşină Virtuală Java care va interpreta codul de octeţi şi va
executa instrucţiuni specifice sistemului de operare pe care rulează. In acest fel se asigură
independenţa faţă de platformă şi portabilitatea aplicaţiilor Java.

5.2. Despre maşina virtuală Java

O aplicaţie de sine stătătoare, scrisă în Java, este compilată şi rulează pe o aşa numită
Maşină Virtuală Java. Acest lucru face posibil ca aplicaţiile Java să poată fi rulate pe diferite
platforme (Sun, MacOS, Win32, Linus) fără a fi nevoie să se recompileze aceste aplicaţii
pentru fiecare dintre acestea în parte. Astfel aplicaţiile Java sunt independente de platformă.
Implementarea practică a conceptului independenţei de platformă s-a realizat prin
folosirea unui calculator virtual pe care rulează de fapt aplicaţiile compilate Java. În urma
compilării fişierelor sursă Java nu se va genera cod executabil, pentru o platformă anume, ci
se va genera un cod intermediar numit cod de octeţi (eng. byte code). Acest cod de octeţi este
asemănător cu limbajul de asamblare dar nu va putea fi rulat direct pe nici un sistem de
operare.
Pentru a rula un cod executabil Java (aşa numitul cod de octeţi) este nevoie de un
program special care va interpreta acest cod de octeţi şi va executa instrucţiuni specifice
sistemului de operare pe care se află. Acest program care interpretează codul de octeţi se
numeşte Maşina Virtuală Java. Maşina Virtuală Java reprezintă un calculator abstract. Ca şi
calculatoarele reale, aceasta dispune de un set de instrucţiuni, un set de regiştri şi utilizează
diferite zone de memorie.
Principalele componente ale JVM sunt:
- Class Loader Subsystem – acest modul este responsabil cu încărcarea claselor în
memorie.

- Execution Engine – mecanismul responsabil cu executarea instrucţiunilor din cadrul

claselor încărcate în cadrul JVM.

- Runtime Data Area – zona în care sunt memorate componente necesare pe parcursul
rulării unui program. În această zonă sunt stocate clasele încărcate, obiectele
construite, informaţii despre apelul metodelor, parametrii variabilelor, valorile
returnate de metode, date despre firele de execuţie etc.

3
Introducere – Utilitare şi mediul de execuţie

5.3. Eliberarea memoriei de obiectele nefolositoare

Toate obiectele create în cadrul maşinii virtuale pe parcursul rulării unui program sunt
plasate în zona de memorie numită Heap. Ştergerea acestora din memorie este realizată
automat de către o componentă a JVM numita Garbage Collector (GC).
Mecanismul GC de eliberare a memorie de obiectele care nu mai sunt folositoare oferă
două avantaje importante. În primul rând programatorul nu trebuie să se îngrijească în mod
explicit de eliberarea obiectelor nefolositoare. Datorită unor erori de implementare care duc la
situaţii de supraîncărcare a memorie programatorul poate să îşi piardă multe ore pentru a găsi
şi repara defectul. Un al doilea avantaj este acela că GC asigură integritatea programelor – nu
permite ştergerea accidentală a unor obiecte sau zone de memorie care ar duce la pierderea
integrităţii programului sau a maşinii virtuale.
Încărcare suplimentară a procesorului dată de componenta GC este un dezavantaj al
acestei abordări de eliberare automată a memoriei. Această problemă este rezolvată într-o
măsură destul de mare prin dezvoltarea unor algoritmi performanţi implementaţi la nivelul
GC.
Este important de reţinut faptul că, nu poate fi prezis în avans momentul în care un
obiect urmează să fie eliberat din memorie. Programatorul nu trebuie să îşi bazeze arhitectura
programului plecând de la anumite presupuneri asupra momentului în care un anumit obiect
va fi eliberat din memorie.

Observaţie:
Deşi mecanismul GC asigură eliberarea memoriei de obiectele care nu mai sunt
referite, există pericolul ca un program prost gândit şi implementat să aibă probleme de
alocare a memoriei şi să se ajungă la situaţia de depăşire a memoriei, fapt care duce la
întreruperea programului. Acest lucru se poate întâmpla deoarece GC şterge din zona Heap
doar acele obiectele care nu sunt referite de către nici o variabilă.
Deşi nu se poate şti în avans exact momentul în care un obiect este eliberat din
memorie, obiectele care urmează să fie şterse sunt anunţate prin apelarea metodei finalize().
Metoda finalize() se regăseşte în cadrul oricărui obiect Java (fiind moştenită din cadrul clasei
de bază Object) şi este apelată de către GC în momentul în care obiectul urmează să fie şters.
În Secvenţa de cod 1 este prezentat un program care demonstrează faptul că la
eliberarea fiecărui obiect din memorie este apelată metoda finalize() a acestuia.

Observaţie:
Intrarea în acţiune a GC şi eliberarea memoriei de obiecte (deci implicit apelarea
metodei finalize() ) nu este garantată de către Maşina Virtuală Java. Ca urmare a acestui fapt,
toate operaţiile de eliberarea de resurse care trebuiesc realizate în cadrul unei aplicaţii (de
exemplu închiderea unor conexiuni de reţea, unor fişiere, închiderea unor conexiuni la baze de
date etc.) trebuie să fie realizate de către programator în mod manual prin construirea unor
metode care sunt apelate în mod explicit la momentul potrivit.

4
 Laboratorul 1

Secvenţa de cod 1
public class GarbageCollectorTest {
static int removedObjects;

public static class Car {

String name;

Car(String name) {
this.name = name;
}

public void finalize() {

removedObjects++;
System.out.println("The car " + name
+ " is removed. Number of removed cars is "
+ removedObjects);
}
}

public static void main(String[] args) {

Car myC = null;
for (int i = 1; i < 10; i++) {
myC = new Car(" Car " + i);
myC.finalize();
}
}
}

5.4 Structura lexicală a limbajului

5.4.1. Setul de caractere

Limbajului Java lucrează în mod nativ folosind setul de caractere Unicode. Acesta
este un standard internaţional care înlocuieşte vechiul set de caractere ASCII şi care foloseşte
pentru reprezentarea caracterelor 2 octeţi, ceea ce înseamnă că se pot reprezenta 65536 de
semne, spre deosebire de ASCII, unde era posibilă reprezentarea a 256 de caractere. Primele
256 caractere Unicode corespund celor din ASCII, referirea la celelalte făcându-se prin \
uxxxx, unde xxxx reprezintă codul caracterului.
Exemplu:
 \u0030 - \u0039 : cifre ISO-Latin 0 - 9
 \u0660 - \u0669 : cifre arabic-indic 0 - 9
 \u4e00 - \u9fff : litere din alfabetul Han (Chinez, Japonez, Coreean)

5.4.2. Cuvinte cheie

Cuvintele rezervate în Java sunt cele din C++, cu câteva excepţii.

5.4.3. Identificatorii
Sunt secvenţe nelimitate de litere şi cifre Unicode, începând cu o literă. Identificatorii
nu au voie să fie identici cu alte cuvinte rezervate.

5
Introducere – Utilitare şi mediul de execuţie

5.4.4. Literalii (constantele)

- Literali întregi:
Sunt acceptate 3 baze de numeraţie : baza 10, baza 16 (începând cu caracterele 0x) şi
baza 8 (începând cu cifra 0) şi pot fi de două tipuri:
o normali, (se reprezintă pe 4 octeţi - 32 biţi);
o lungi (8 octeţi - 64 biţi) : se termină cu caracterul L (sau l).

- Literali flotanţi:
Pentru ca un literal să fie considerat flotant el trebuie să aibă cel puţin o zecimală după
virgulă, să fie în notaţie exponenţială sau să aibă sufixul F sau f pentru valorile normale
(reprezentate pe 32 biţi), respectiv D sau d pentru valorile duble (reprezentate pe 64 biţi).

- Literali logici:
o true : valoarea booleană de adevăr;
o false : valoarea booleană de fals.
Spre deosebire de C++, literalii întregi 1 şi 0 nu au rolul de adevărat şi fals.

- Literali caracter:
Un literal de tip caracter este utilizat pentru a exprima caracterele codului Unicode.
Reprezentarea se face fie folosind o literă, fie o secvenţă escape scrisă între apostrofuri.
Secvenţele escape permit reprezentarea caracterelor care nu au reprezentare grafică şi
reprezentarea unor caractere speciale precum “backslash“, caracterul apostrof etc. Secvenţe
escape predefinite în Java sunt prezentate în Tabelul 1.

Tabelul 1. Secvenţe escape predefinite

Cod Secventa Escape Caracter
\u0008 '\b' Backspace(BS)
\u0009 '\t' Tab orizontal (HT)
\u000a '\n' Linie nouă - linefeed (LF)
\u000c '\f' Pagină nouă - formfeed (FF)
\u000d '\r' Inceput de rând (CR)
\u0022 '\"' Ghilimele
\u0027 '\'' Apostrof
\u005c '\\' Backslash

- Literali şiruri de caractere

Un literal şir de caractere este format din zero sau mai multe caractere între ghilimele.
Caracterele care formează şirul de caractere pot fi caractere grafice sau secvenţe escape ca
cele definite la literalii caracter. Sirul vid este "". Dacă şirul este prea lung el poate fi scris ca
o concatenare de subşiruri de dimensiune mai mică. Concatenarea şirurilor se face cu
operatorul “+”, exemplu: "alfa " + " beta " + " gama ". Orice şir este de fapt o instanţă a
clasei String, definită în pachetul java.lang. Obiectele String sunt imutabile (orice modificare
a şirului de caractere determină crearea unui nou obiect) [ECK, 2006].

5.4.5. Separatori
Un separator este un caracter care indică sfârşitul unei unităţi lexicale şi începutul
alteia. În Java separatorii sunt următorii: ( ) { } [ ] ; , . Instrucţiunile unui program se separă
cu punct şi virgulă.

6
 Laboratorul 1

5.4.6. Operatori
 atribuirea: =
 operatori matematici: +, -, *, /, %

Există operatorii pentru autoincrementare şi autodecrementare (post şi pre).

Exemplu:
x++, ++x, n--, --n.

Observaţie:
Evaluarea expresiilor logice se face prin metoda scurtcircuitului, evaluarea se opreşte în
momentul în care valoarea de adevăr a expresiei este sigur determinată.

 operatori logici: &&(and), ||(or), !(not) ;

 operatori relaţionali: <, <=, >, <=, ==, != ;
 operatori pe biţi: & (and), |(or), ^(xor), ~(not) ;
 operatori de translaţie <<, >>, >>> (shift la dreapta fără semn) ;
 operatorul if-else: expresie_logica ? val_pt_true : val_pt_false;
 operatorul , (virgulă) folosit pentru evaluarea secvenţială a operaţiilor: int x=0, y=1,
z=2;
 operatorul “+” pentru concatenarea şirurilor, exemplu:
String s="abcd";
int x=100;
System.out.println(s + " - " + x);
 operatori pentru conversii (cast) : (tip_de_data), exemplu:
int i = 200;
long l = (long)i; //widening conversion - conversie prin extensie
long l2 = (long)200;
int i2 = (int)l2; //narrowing conversion - conversie prin contracţie.

5.4.7. Comentarii
În Java există trei feluri de comentarii:
 comentarii pe mai multe linii, închise între /* şi */.
 comentarii pe mai multe linii care ţin de documentaţie, închise între /** şi */. Textul
dintre cele două secvenţe este automat mutat în documentaţia aplicaţiei de către
generatorul automat de documentaţie javadoc.
 comentarii pe o singură linie care încep cu //.

Observaţii:
1. nu putem să scriem comentarii în interiorul altor comentarii.
2. nu putem introduce comentarii în interiorul literalilor caracter sau şir de caractere.
3. secvenţele /* şi */ pot să apară pe o linie după secvenţa // dar îşi pierd semnificaţia; la
fel se întâmplă cu secvenţa // în comentarii care încep cu /* sau /**.

5.5. Tipuri de date

În Java tipurile de date se împart în două categorii: tipuri primitive şi tipuri referinţă.
Java porneşte de la premisa că "orice este un obiect". Aşadar tipurile de date ar trebui să fie
de fapt definite de clase şi toate variabilele ar trebui să memoreze de fapt instanţe ale acestor

7
Introducere – Utilitare şi mediul de execuţie
clase (obiecte). În principiu acest lucru este adevărat, însă, pentru uşurinţa programării, mai
există şi tipurile primitive de date, care sunt cele uzuale :
 aritmetice
o întregi: byte (1 octet), short (2), int (4), long (8)
o reale: float (4 octeţi), double (8)
 caracter : char (2 octeţi)
 logic : boolean (true şi false)

În alte limbaje formatul şi dimensiunea tipurilor primitive de date folosite într-un

program pot depinde de platforma pe care rulează programul. În Java acest lucru nu mai este
valabil, orice dependenţă de o anumită platformă specifică fiind eliminată.
Vectorii, clasele şi interfeţele sunt tipuri referinţă. Valoarea unei variabile de acest tip
este, în contrast cu tipurile primitive, o referinţă (adresă de memorie) către valoarea sau
mulţimea de valori reprezentată de variabilă respectivă.
Există trei tipuri de date în C care nu sunt suportate de limbajul Java. Acestea sunt:
pointer, struct şi union. Point-erii au fost eliminaţi din cauză că erau o sursă constantă de
erori, locul lor fiind luat de tipul referinţă, iar struct şi union nu îşi mai au rostul atât timp cât
tipurile compuse de date sunt formate în Java prin intermediul claselor.

5.6. Variabile
Variabilele pot avea ca tip fie un tip primitiv de dată, fie o referinţă la un obiect.
Convenţia de notare a variabilelor în Java este dată de următoarele criterii:
1. variabilele finale (constantele) se scriu cu majuscule;
2. variabilele normale se scriu astfel: prima literă este mică; dacă numele variabilei este
format din mai mulţi atomi lexicali, atunci primele litere ale celorlalţi atomi se scriu cu
majuscule, de exemplu:
final double PI = 3.14;
int valoare = 100;
long numarElemente = 12345678L;
String bauturaMeaPreferata = "apa";

În funcţie de locul în care sunt declarate variabile acestea se împart în următoarele

categorii:
1. variabile membre, declarate în interiorul unei clase, vizibile pentru toate metodele
clasei respective şi pentru alte clase în funcţie de nivelul lor de acces (vezi "Declararea
variabilelor membre");
2. variabile locale, declarate într-o metodă sau într-un bloc de cod, vizibile doar în
metoda/blocul respectiv;
3. parametrii metodelor, vizibili doar în metoda respectivă;
4. parametrii de la tratarea excepţiilor.

Observaţie:
Variabilele declarate într-un for pentru controlul ciclului, rămân locale corpului
ciclului.
Spre deosebire de C++ nu este permisă ascunderea unei variabile:
int x = 12;
{
int x = 96; // ilegal
}

8
 Laboratorul 1

5.7. Controlul execuţiei

Instrucţiunile Java pentru controlul execuţiei sunt asemănătoare celor din C (vezi
Tabelul 2).
În Java nu există instrucţiunea goto. Se pot însă defini etichete de forma
nume_eticheta folosite în expresii de genul: break nume_etichetă sau continue nume_etichetă
(vezi Secvenţa de cod 2).

Tabelul 2. Controlul execuţiei în Java

Instrucţiuni de decizie
if (exp_booleană) { /*...*/}
if-else
if (exp_booleană) { /*...*/} else { /*...*/}
switch (variabilă) {
case val1 : /* ... */ break;
case val2 : /* ... */ break;
switch-case
/*...*/
default : /*...*/
}
Instrucţiuni de salt
for(iniţializare; exp_booleană; pas_iteraţie)
Ex: for(int i=0, j=100 ; i<100 && j>0; i++, j--)
for {/* ... /*}
Obs: atât la iniţializare cât şi în pasul de iteraţie pot fi mai multe
instrucţiuni despărţite prin virgulă.
while (exp_booleană) {
while /*...*/
}
do {
/*...*/
do-while
}
while (exp_booleană) ;
Instrucţiuni pentru tratarea excepţiilor
try-catch-finally,
(vezi "Tratarea excepţiilor")
throw
Alte instrucţiuni
break părăseşte forţat corpul iteraţiei curente
continue termină forţat iteraţia curentă
return [valoare];
return
termină o metodă
Label defineşte o etichetă

9
Introducere – Utilitare şi mediul de execuţie

Secvenţa de cod 2
int i = 0;
eticheta: while (i < 10) {
System.out.println("i=" + i);
int j = 0;
while (j < 10) {
j++;
if (j == 5)
continue eticheta;
if (j == 7)
break eticheta;
System.out.println("j=" + j);
}
i++;
}
5.8. Vectori
Declararea vectorului se face astfel:
Tip[ ] numeVector; sau
Tip numeVector[ ];

Exemplu:
int[ ] intregi;
String adrese[ ];

Instanţierea se realizează prin intermediul operatorului new şi are ca efect alocarea

memoriei pentru vector, mai precis specificarea numărului maxim de elemente pe care îl va
avea vectorul:
numeVector = new Tip[dimensiune];

Exemplu:
int v[] = new int[10]; // se alocă spaţiu pentru 10 întregi
String[] adrese = new String[100];

După declararea unui vector, acesta poate fi iniţializat, adică elementele sale pot primi
nişte valori iniţiale, evident dacă este cazul pentru aşa ceva. In acest caz instanţierea lipseşte,
alocarea memoriei făcându-se automat în funcţie de numărul de elemente cu care se
iniţializează vectorul.

Exemplu:
String culori[ ] = {"Rosu", "Galben", "Verde"};
int [ ]factorial = {1, 1, 2, 6, 24, 120};

Primul indice al unui vector este 0, deci poziţiile unui vector cu n elemente vor fi
cuprinse între 0 şi n-1.
Nu sunt permise construcţii de genul Tip numeVector[dimensiune], alocarea memoriei
făcându-se doar prin intermediul operatorului new.
În Java tablourile multidimensionale sunt de fapt vectori de vectori.
Exemplu:
int m[][]; // declararea unei matrici
m = new int[5][10]; // cu 5 linii, 10 coloane
int l[] = m[1]; // m[1] este un vector cu 10 elemente

Cu ajutorul cuvântului cheie length se poate afla dimensiunea unui vector.

10
 Laboratorul 1

Exemplu:
int []a = new int[5];
int la = a.length; //are valoarea 5
int m[][] = new int[5][10];
int lm = m[0].length; //are valoarea 10

Copierea unui vector într-un alt vector se face cu ajutorul metodei System.arraycopy():

Exemplu:
int x[] = {1, 2, 3, 4};
int y[] = new int[4];
System.arraycopy(x,0,y,0,x.length);

Implementarea vectorilor cu număr variabil de elemente este oferită de clasa Vector

din pachetul java.util. Un obiect de tip Vector conţine numai elemente de tip Object.

5.9. Siruri de caractere

Un şir de caractere poate fi reprezentat printr-un vector format din elemente de tip
char, un obiect de tip String, un obiect de tip StringBuffer sau StringBuilder.
Dacă un şir de caractere este constant atunci el va fi declarat de tipul String, altfel va fi
declarat cu StringBuffer.
Concatenarea şirurilor de caractere se face prin intermediul operatorului “+”.
În Java, operatorul de concatenare “+” este extrem de flexibil în sensul că permite
concatenarea şirurilor cu obiecte de orice tip care au o reprezentare de tip şir de caractere.

5.10. Folosirea argumentelor din linia de comandă

O aplicaţie Java poate primi oricâte argumente din linia de comandă în momentul
lansării ei în execuţie. Aceste argumente sunt utile pentru a permite utilizatorului să specifice
diverse opţiuni legate de funcţionarea aplicaţiei sau să furnizeze anumite date iniţiale
programului.
Programele care folosesc argumente din linia de comanda nu sunt 100% Java pure,
deoarece unele sisteme de operare cum ar fi Mac OS nu au în mod normal linie de comandă.
Argumentele de la linia de comandă sunt introduse la lansarea unei aplicaţii, fiind
specificate după numele aplicaţiei şi separate prin spaţiu. De exemplu, să presupunem că
aplicaţia Sort ordonează lexicografic liniile unui fişier şi primeşte ca argument numele
fişierului pe care să îl sorteze. Pentru a ordona fişierul "persoane.txt" lansarea aplicaţiei se va
face astfel:
java Sort persoane.txt
Aşadar, formatul general pentru lansarea unei aplicaţii care primeşte argumente de la
linia de comandă este:
java NumeAplicatie [arg1 arg2 . . . argn]
În cazul în care sunt mai multe, argumentele trebuie separate prin spaţii, iar dacă unul
dintre argumente conţine spaţii, atunci el trebuie pus între ghilimele.

11
Introducere – Utilitare şi mediul de execuţie
6. Verificarea cunoştinţelor

1. Se dau două numere complexe: 2+5i şi 4-i. Să se realizeze o aplicaţie care calculează suma
respectiv produsul celor două numere, să se verifice rezultatul.

2. Se dau două matrice de 3X3,

- prima matrice: R1=[2 3 1], R2=[7 1 6], R3=[9 2 4],
- a doua matrice: R1=[8 5 3], R2=[3 9 2], R3=[2 7 3],
Să se calculeze suma respectiv produsul celor două matrice. Să se verifice rezultatul.

3. Ce este o clasă şi din ce este alcătuită?

4 .Ce este un constructor?

5. Câte tipuri de modificatori de acces sunt în Java?

12
Capitolul 1