Java.

Clasa 0 pregtitoare
Instalare JDK (JAR nu este suficient, nu are compilator)
Verificarea versiunii de java n fereastra cmd:
java -version
Stabilire cale n enviromental settings (PATH = cale unde
este instalat jdk/bin)
Comenzi de compilare i executare n linie de comand:
- javac numefisier.java pentru a crea fiierul class
- java numefisier(.class) pentru a rula n mod
consol programul

Exemplu Hello world
Folosind un editor de texte ASCII se creaz
fiierul HelloWorld.java cu urm coninut:
!!! Numele clasei este identic cu numele
fierului. Atenie la litere mari i mici
public class HelloWorld
{
public static void main(String[] args)
{
System.out.println("Hello World");
}
}
Compilare i rulare
Pentru compilare n mod consola (cmd) n folderul care
conine fiierul HelloWorld.java se introduce comanda:
javac HelloWorld.java
Dac compilarea se execut fr erori vom regsi n folder un nou fiier
cu extensia class. Pentru a rula efectiv programul se tasteaz comanda
java HelloWorld Fr extensia .class !!!
Rezultatul ar trebuii s fie executarea programului i afiarea mesajului dorit.
NetBeans
Declararea variabilelor !!!
Variabilele pot fi globale sau locale. Cele globale
se declar nainte de void main cele locale n
interiorul void main. Variabilele globale sunt
iniializate pe cnd cele locale NU !
public class testvar {
public static int a; //variabil global
public static void main(String[] args)
{
int b; // variabil local
System.out.println("a : "+a);
System.out.println("b : "+b); //Compilation error
}
}
NetBeans - aplicatie noua
Meniul File - New Project
Categoria Java proiect Java Application
NetBeans - aplicatie noua
Stabilim numele proiectului si calea unde se va salva
proiectul (clasa)
Fereastra de lucru NetBeans
Fereastra de editare
Fereastra de mesaje
Fereastra
proiect
Fereastra
navigare
Zone de cod la editare
Alte pachete si librarii (import)
variabile globale
corpul programului
Iniializare variabil local
public class testvar {
public static int a;
public static void
main(String[] args)
{
int b=1; //initializam
ca e local
System.out.println("a :
"+a);
System.out.println("b :
"+b);
}
}
idem in NetBeans
Compilare
Executare
Socotitoare
public class testvar {
public static int a;
public static void main(String[] args)
{
int b=1; //initializam ca e local
a=7 ;
System.out.println("a : "+a);
System.out.println("b : "+b);
System.out.println(a+" + "+b+" = "+(a+b));
}
}
Modificai i pentru celelalte operaii de baz. Atenie la mprire !!!
Citirea unor valori de la tastatur.
Things go Ugly !
Limbajul java nu are o cale directa (o
comand) pentru citirea unor valori de la
tastatur. HUH !
Avem nevoie de o bibliotec i de nite
funcii speciale de citire a valorilor de la
tastatura n memoria tampon (buffer) ca
string, apoi conversia lor n numr urmat
de stocarea lor n variabile.
import java.io.*;

public class input
{
public static float real;
public static int intreg;
public static String sir="";

public static void main(String[] args) throws IOException
{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String temp;
System.out.println("Introduceti un numar real");
temp=br.readLine();
real=Float.parseFloat(temp);

System.out.println("Introduceti un numar intreg");
temp=br.readLine();
intreg=Integer.parseInt(temp);

System.out.println("Introduceti un text");
temp=br.readLine();
sir=temp;

System.out.println();
System.out.println("Ati introdus sirul "+sir+" numarul intreg "+intreg+"
si numarul real "+real);

}
}
Tipuri de valori n Java
Tip Valoare implicit Domeniu
byte 0 -127 to +128
short 0 -32768 to +32767
int 0
long 0L
float 0.0f
double 0.0d
char \u0000 0 to 65535
String (object) null
boolean false True, false
Instructiuni de decizie
if-else
if (exp_booleana) { /*...*/} if (exp_booleana) {
/*...*/} else { /*...*/}
switch-case
switch (variabila) { case val1 : /* ... */ break; case
val2 : /* ... */ break; /*...*/ default : /*...*/ }
Instructiuni de salt
for
for(initializare; exp_booleana; pas_iteratie)
Ex: for(int i=0, j=100 ; i<100 && j>0; i++, j--
) {/* ... /*} Obs: att la initializare ct si n pasul de
iteratie pot fi mai multe instructiuni despartite prin virgula.
while while (exp_booleana) { /*...*/ }
do-while do { /*...*/ } while (exp_booleana) ;
Instruciunea If
public class IfDemo
{
public static void main(String[] args)
{
int a = 10, b = 20;
if (a > b) System.out.println("a > b");
if (a < b) System.out.println("b > a");
}
}
public class IfElseDemo
{
public static void main(String[] args)
{
int a = 10, b = 20;
if (a > b)
{ System.out.println("a > b"); }
else
{ System.out.println("b > a"); }
}
}
Instr. Case- switch
public class
SwitchCaseDemo {

public static void
main(String[] args) {
int a = 10, b = 20, c = 30;
int status = -1;
if (a > b && a > c) {
status = 1;
}
else if (b > c) {
status = 2;
}
else {
status = 3;
}
.

switch (status) {
case 1:
System.out.println("a este mai mare");
break;
case 2:
System.out.println("b este mai mare");
break;
case 3:
System.out.println("c este mai mare");
break;
default:
System.out.println(nedeterminat");
}
}
}
Instr. For()
public class ForLoop{
public static void main(String[] args){
for(int i = 1;i <= 5;i++){
for(int j = 1;j <= i;j++){
System.out.print(i);
}
System.out.println();
}
}
}
Obs: variabilele declarate ntr-un for pentru controlul ciclului, rmn locale corpului
ciclului.
for(int i=0; i<100; i++) { .. }
int i; //ok n Java, eroare n C++
While Loop(true)
public class table{
public static void main(String[] args){
int n = 2, i = 1;
System.out.println("The table of "+n+" = ");
while(i<=10)
{
int t = n * i++;
System.out.println(t);
}
}
}
do-while(true) Loop
public class DoWhile{
public static void main(String[] args){
int n = 12345;
int t,r = 0;
System.out.println("The original number : " + n);
do{
t = n % 10;
r = r * 10 + t;
n = n / 10;
}while (n > 0);
System.out.println("The reverse number : " + r);
}
}
Have fun. Appleturi java
import java.awt.* ;
import java.applet.* ;
public class FirstApplet extends Applet {
Image img;
public void init() {
img = getImage(getCodeBase(), "taz.jpg");
}
public void paint (Graphics g) {
g.drawImage(img, 0, 0, this);
g.drawOval(100,0,150,50);
g.drawString("Hello! My name is Taz!", 110, 25);
}
}
Have fun. Appleturi java
<html>
<head> <title>First Java Applet</title> </head>
<body>
<applet code=FirstApplet.class width=400 height=400></applet>
</body>
</html>
Hello! My name is Taz!
If (?) altfel !
variable x = (expression) ? value if true :
value if false
public class Test
{
public static void main(String args[]){
int a , b;
a = 10;
b = (a == 1) ? 20: 30;
System.out.println( "Value of b is : " + b );

b = (a == 10) ? 20: 30;
System.out.println( "Value of b is : " + b );
}
}
If else If . Else If .. else

public class Test {
public static void main(String args[]){
int x = 30;

if( x == 10 ){
System.out.print("Value of X is 10");
}else if( x == 20 ){
System.out.print("Value of X is 20");
}else if( x == 30 ){
System.out.print("Value of X is 30");
}else{
System.out.print("This is else statement");
}
}
}
Operatori compui/prescurtri
public class OpCompusDemo
{
public OpCompusDemo() {
int x = 0, y = 5;
x += 3;
System.out.println("x : " + x);
y *= x;
System.out.println("y : " + y);
/*Similar i ali operatori se pot scrie n acest mod. */
}
public static void main(String args[]) {
new OpCompusDemo();
}
}
Grupa mic. Clase
Clase
O clas nu este altceva dect un ablon, o schi,
un plan, al obiectelor pe care le vom crea
ulterior. n clas sunt definite (declarate)
variabilele noului obiect, proprietile acestor
variabile precum i uneltele cu care operam
aceste variabile adic funciile, metodele clasei
Un obiect (o instan) a clasei nu este altceva
dect punerea n practic a planului iar obiectul
creat fiind fcut dup specificaiile din plan
(clas) va moteni toate caracteristice clasei
(toate funciile i toate variabilele)
nainte de clase
n limbajul C (i nu numai) putem declara funcii
i variabile sau grup de variabile numite structuri.
DAR le declarm separat !
Clasele sunt pasul urmtor n sensul c o clasa
este o aduntur de declaraii de variabile
structuri i funcii cu diferena c spaiul de
memorie necesar variabilelor i funciilor nu este
alocat dect n momentul instanierii clasei
adic atunci cnd pe baza planului (clasei) se
creeaz o instan (un obiect)
Clase
Obiect (instan a clasei) este obectul creat efectiv cu
specificaiile descrise n clas

IF clas = tipar /blueprint
THEN
obiect = obiectul creat cf. tiparului

Crearea obiectelor se face cu operatorul new
Ex. clasa Bird (are aripi, face ou i zboar)
Obiectul (instana) vrabie = new Bird
Variabile i funcii
Variabilele i funciile definite n clas devin
cmpuri (field) i metode (methodes) n
obiectele create din clas
cmp + metode = membrii instanei
Dac se creeaz mai multe instane ale unei
clase TOATE instanele vor avea propriul
set de cmpuri i metode cum sunt ele
definite n clas.(excepie STATIC)
vrabie = new bird (aripi, ou, zboar)
papagal = new bird (aripi, ou, zboar)
Membrii statici
Membrii statici (variabile i funcii) declarai ca
atare n definiia clasei sunt globale, adic toate
obiectele create (instaniate) ale clasei vor avea
doar un singur set de metode i cmpuri
STATIC ! Altfel spus membrii statici aparin
tuturor instaelor n acelai timp.

Metodele i cmpurile STATIC se pot apela i din
obiect i din clas iar metodele i cmpurile
declarate n obiect numai din acel obiect.
public class claseDemo
{
String mesaj = "";
static claseDemo obiect_afisare; //Line 1

public claseDemo()
{
mesaj = "Lucram cu clase";
}

public String printMessage()
{
return mesaj;
}

public static void main (String args[])
{
obiect_afisare = new claseDemo(); //Line 2
System.out.println(obiect_afisare.printMessage());
}
}
Nume clasa: claseDemo
referin obiect: obiect_afisare (Line 1)
Obiect Creat: obiect_afisare (Line 2)
Functie Membru : printMessage
cmp(variabil): mesaj (String)
Static Member: obiect_afisare
Instance Member : mesaj (String)
Cu sau fr clase
public class op_relational {
public op_relational( ) {

int x = 10, y = 5;
System.out.println("x > y : "+(x > y));
System.out.println("x < y : "+(x < y));
System.out.println("x >= y : "+(x >= y));
System.out.println("x <= y : "+(x <= y));
System.out.println("x == y : "+(x == y));
System.out.println("x != y : "+(x != y));
}

public static void main(String args[]){
System.out.println("x = "+x+" : y = "+ y);
new op_relational();
}
}
public class op_relational
{
static int x = 10, y = 5;
public static void main(String args[])
{
System.out.println("x = "+x+" : y = "+
y);
System.out.println("x > y : "+(x > y));
System.out.println("x < y : "+(x < y));
System.out.println("x >= y : "+(x >= y));
System.out.println("x <= y : "+(x <= y));
System.out.println("x == y : "+(x == y));
System.out.println("x != y : "+(x != y));
}
}
Operatori logici folosind clase
public class op_logici
{
public op_logici() {
boolean x = true;
boolean y = false;
System.out.println("x & y : " + (x & y));
System.out.println("x && y : " + (x && y));
System.out.println("x | y : " + (x | y));
System.out.println("x || y: " + (x || y));
System.out.println("x ^ y : " + (x ^ y));
System.out.println("!x : " + (!x));
}
public static void main(String args[]) {
new op_logici();
}
}
class Demo{
int value1; // Static ???
int value2;// Static ???
Demo(){
value1 = 10;
value2 = 20;
System.out.println("Inside Constructor");
System.out.println("Value1 === "+(value1++));
System.out.println("Value2 === "+(value2++));
}
public void display(){
System.out.println("metoda dysplay");
System.out.println("Value1 === "+(value1++));
System.out.println("Value2 === "+(value2++));
}
public static void main(String args[]){
Demo d1 = new Demo();
d1.display();
System.out.println("din main");
System.out.println("Value1 === "+value1);//eroare value1,2 static
System.out.println("Value2 === "+value2);
}
}
Instane. Constructori
public class instante
{
public static int x,y;

public instante(){
System.out.println("x = "+x+ " : y = "+y);
}

public static void main(String args[]){
System.out.println("Prima instanta");
instante instnata1= new instante();
System.out.println("initializam variabilele");
x=5; y=12;
instante instanta2=new instante();
}
}
Terminarea forat a buclelor
n buclele for i while avem posibilitatea de a
termina forat bucla sau n anumite condiii
s nu se execute comenzile sau o parte
din comenzi din bucl.
break are ca efect terminarea buclei
continue va rmne n bucl dar comenzile
situate sub comanda continue nu se
execut.
Cele dou comenzi sunt folosite de obicei cu
if (cond) break/continue;
public class continueDemo
{
public static void main(String[] args)
{
int i,j;
System.out.println("Acesta este un exemplu pentru
comenzile continue si break" );
for (i=1 ;i<=10;i++) {
if (i>=4&&i<8) continue;
System.out.println("Contorul i este "+i);
}// nu va afisa valorie intre 5 si 7
for (j=1;j<=10;j++) {
if (j==7) break;
System.out.println("Contorul j este +j);
}// va intrerupe bucla cand contorul j ajunge la 7
}
}
Vectori (iruri)
Declararea vectorului
Tip[ ] numeVector; sau Tip numeVector[ ];
Ex: int[ ] v; String adrese[ ];

Instantierea (creerea efcetiva in memorie a spatiului pentru
elementele sirului ) se realizeaz prin intermediul
operatorului new si are ca efect alocarea memoriei pentru
vector, mai precis specificarea numrului maxim de
elemente pe care l va avea vectorul;
numeVector = new Tip[dimensiune];
Ex: v = new int[10]; adrese = new String[100];

Declararea si instantierea unui vector pot fi fcute simultan
astfel:
Tip[ ] numeVector = new Tip[dimensiune];
float[ ] nr_real=new float[100]
public class DemoVectori
{
static int sir_nr[];
public void afisare(){ // sa mai exersam si clasele
for(int i=0;i<10;i++) {
System.out.println("sir["+i+"]="+sir_nr[i]);
}
}
public static void main(String[] args) {
sir_nr=new int[10];
for (int i=0;i<10;) sir_nr[i++]=2*i;
DemoVectori instanta_clasa=new DemoVectori();
instanta_clasa.afisare();
}
}
Caractere, iruri de caractere
Declararea unui sir
Daca un sir de caractere este constant atunci el va
fi declarat de tipul String, altfel va fi declarat cu
StringBuffer.
String str = "abc";
char data[] = {'a', 'b', 'c'};
String str = new String(data);
String str = new String("abc");

Concatenarea sirurilor prin intermediul op. +
String str1 = "abc" + "xyz";
String str2 = "123";
String str3 = str1 + str2;
public class DemoString {

static String mesaj;
public static void main(String[] args) {
mesaj="primul text";
System.out.println(mesaj);
mesaj="al doilea text";
System.out.println(mesaj);
mesaj=mesaj+" si un text oarecare.";
System.out.println(mesaj);
}
}
public class CharDemo {

public static String mesaj="Un text oarecare";
public static char[] litere;
public static int lungime;
public static void main(String[] args) {
lungime=mesaj.length();
System.out.println("Lungimea sirului "+ mesaj+" este
de "+lungime);
char litere[]=new char[lungime];
for(int i=0;i<lungime;i++){
litere[i]=mesaj.charAt(i);}//citeste caracterul din poz. i
for(int i=(lungime-1);i>=0;i--){
System.out.print(litere[i]);}
}
}
Manipularea irurilor text
Sir.substring(poz start, poz stop)
Sau Sir.substring(poz start)
public class SubstringDemo {
public static String mesaj, mesaj_trunchiat1,
mesaj_trunchiat2;
public static void main(String[] args) {
mesaj="Acesta este un exemplu pt substring";
mesaj_trunchiat1=mesaj.substring(7, 22);
mesaj_trunchiat2=mesaj.substring(23);
System.out.println(mesaj);
System.out.println(mesaj_trunchiat1);
System.out.println(mesaj_trunchiat2);
}
}
Clasa StringBuffer. Manipulare text
avansat
String Vs StringBuffer o libertate mai
mare n ceea ce privete tratarea
variabilelor tip ir de caractere. Se
lucreaz ntr-o zon de memorie alocat
dinamic (nu de o dimensiune fix)
Funcii:append, insert, reverse, setCharAt,
charAt, length, deleteCharAt, substring,
delete, capacity

Studiati aplicatia trimisa pe grup !!!!
import java.io.*;
.
StringBuffer strbuf = new StringBuffer();

strbuf.append(str); // concatenare sir1+sir2
strbuf.insert(5,"_Java "); // inserare text din poz specificata
strbuf.reverse(); // sirul in ordine inversa (de la dreapta la
stanga)
strbuf.setCharAt(5, '); // seteaza (schimba) caracterul din
pozitia specificata
Sir=strbuf.substring(3,7) ; // extrage un subsir
strbuf.deleteCharAt(3); // sterge caracterul din poz. specificata
Int i=strbuf.capacity(); // lungimea actuala a sirului
strbuf.delete(6,strbuf.length()); // sterge un subsir din poz
specificata pana la
Temaaaaaa !!
Scrieti un program in java care sa :
1. Citeasca un sir de caractere (text) de la
tastatura
2. Converteste fiecare litera din sir in codul ascii
corespunzator si stochaza numerele intr-un
vector
3. Converteste fiecare nr ascii in binar si-l
stocheaza intr-un sir de string
4. Afiseaza ceva de genul daca sir = papagal
P=105=110101
a=97=101101
Pachete/librarii
Un pachet este o colectie de clase si
interfete nrudite. Sunt folosite pentru
gasirea si utilizarea mai usoara a
claselor, pentru a evita conflictele de
nume si pentru a controla accesul la
anumite clase. In alte limbaje de
programare pachetele se numesc
librarii.
Toate clasele si interfetele Java
apartin la diverse pachete,
grupate dupa functionalitatea lor:
clasele de baza se gasesc n
pachetul java.lang, clasele pentru
intrari/iesiri sunt n java.io, clasele
pentru grafica n java.awt, cele
pentru construirea applet-urile n
java.applet
Crearea unui pachet se
realizeaza prin scriere la
nceputul fisierelor sursa ce
contin clasele si interfetele pe
care dorim sa le grupam ntr-un
pachet a instructiunii:
package NumePachet
De asemenea, se poate ca una din clasele unei
aplicatii sa aiba acelasi nume cu o clasa a mediului
Java. Acest lucru este posibil att timp ct
clasele cu acelasi nume se gasesc n pachte
diferite, ele fiind diferentiate prin prefixarea lor cu
numele pachetelor. Asadar numele complet al unei
clase este format din numele pachetului la care
apartine + numele sau:
numePachet.NumeClasa
Ex:
java.lang.String (java.lang=pachet, String=clasa)
Pachetul_meu.String aceasta clasa String difera
de clasa String din Java
Importul unui pachet
Se poate importa doar o clasa sau un
pachet intreg:
import java.awt.Rectangle;
import java.awt.Circle;
import java.awt.Line;
..
Sau
import java.awt.*
daca folosim toate sau majoritatea claselor
pachetului.
In cazul n care sunt importate doua pachete
care contin o clasa cu acelasi nume atunci
referirea la ea trebuie facuta folosind
numele complet al clasei respective.
//Stack.java package my_package;
class Stack { ... } //alt fisier sursa
import java.util.*;
import my_package.*;
...
Stack s = new Stack(); //ilegal -> conflict de nume
java.util.Stack s1 = new java.util.Stack(); //corect
y_package.Stack s2 = new y_package.Stack();//corect
java.applet suport pt scrierea de appleturi
java.awt suportul pentru grafica(Abstract Windowing Toolkit)
java.beans suport pentru scrierea de componente reutilizabile
java.io intrari/iesiri, acces la fisiere
java.lang clasele de baza ale limbajului (implicit)
java.math operatii matematice
java.net acces la retea
java.rmi executie la distanta (Remote Message Interface)
java.security mecanisme de securitate : criptare, autentificare
java.sql interogari SQL
java.text suport pentru formatarea textelor
java.util clase utile : Vector, Stack, Random, etc
Pachete JDK
Exemplu calculator care foloseste
clase compilate separat dar unite
intr-un pachet
Creati un folder cu numele pachetului socotitoare
In folderul creat creati fisierele java ale pachetului
Compilati fiecare fisier pt a obtine fisierul class
Creati programul principal si compilati pt a obtine
fiserul class
Rulati programul
Pt portabilitatea programului se copiaza si fiserul
class si folderul cu clasele pachet
package socotitoare;
public class adunare{
public float adunare(float x, float y){
return x+y; }
}
package socotitoare;
public class scadere{
public float scadere(float x, float y){
return x-y;}
}
package socotitoare;
public class inmultire{
public float inmultire(float x, float y){
return x*y;}
}
package socotitoare;
public class impartire{
public float impartire(float x, float y){
return x/y;}
}
import socotitoare.*;
import java.io.*;

public class calculatoravansat{
public static float a,b,c=0;
public static String operator, eroare="OOOps ceva nu e in regula";
public static void main(String args[]) throws IOException {
BufferedReader input=new BufferedReader(new -
- InputStreamReader(System.in));
String temp;
do {
operator=null;
System.out.println("Acesta este o socotitoare . ");
System.out.print("Introduceti primul numar a=");
temp=input.readLine();
a=Float.parseFloat(temp);
System.out.print("Introduceti al doilea numar b=");
temp=input.readLine();
b=Float.parseFloat(temp);
switch(operator){
case "+":
socotitoare.adunare aduna=new socotitoare.adunare();
c=aduna.adunare(a,b);
break;
case"-":
socotitoare.scadere scade=new socotitoare.scadere();
c=scade.scadere(a,b);
break;
case "/":
socotitoare.impartire imparte=new socotitoare.impartire();
if(b!=0) c=imparte.impartire(a,b);
else
System.out.println("Divizor zero");
break;
case "*":
socotitoare.inmultire multi=new socotitoare.inmultire();
c=multi.inmultire(a,b);
break;
default: System.exit(0);}
System.out.println("Introduceti operatorul (+,-,/,*,) sau null
pentru terminare");
operator=input.readLine();

System.out.println(a+" "+operator+" "+b+" = "+c);
} while (operator!=null);
}
}
Spor la lucru.
Excepii. (tratarea erorilor)
O exceptie este un eveniment ce se
produce n timpul executiei unui
program si care provoaca ntreruperea
cursului normal al executiei.
Exceptiile pot aparea din diverse cauze si pot avea
nivele diferite de gravitate: de la erori fatale
cauzate de echipamentul hardware pna la erori
ce tin strict de codul programului, cum ar fi
accesarea unui element din afara spatiului
alocat unui vector. In momentul cnd o
asemenea eroare se produce n timpul executiei
sistemul genereaza automat un obiect de tip
exceptie
public class Exceptii
{
public static void main(String argsst)
{
int v[] = new int[10];
v[10] = 0; //exceptie, vectorul are elementele v[0]...v[9]
System.out.println("Aici nu se mai ajunge...");
}
}
La rularea programului va fi generata o exceptie si se
va afisa mesajul : Exception in thread "main"
java.lang.ArrayIndexOutOfBoundsException :10 at
Exceptii.main (Exceptii.java:4 )
Throws
Crearea unui obiect de tip exceptie se
numeste aruncarea unei exceptii
("throwing an exception"). In momentul n
care o metoda genereaz o excepie
(arunca o excepie) sistemul de execuie
este responsabil cu gsirea unei secvene
de cod dintr-o metoda care sa trateze
acea excepie. Cutarea se face recursiv,
ncepnd cu metoda care a generat
excepia si mergnd napoi pe linia
apelurilor ctre acea metoda.
Catch & handle
Secvena de cod dintr-o metoda care
trateaz o anumita excepie se
numete analizor de excepie
("exception handler") iar interceptarea
si tratarea exceptie se numete
prinderea excepiei ("catch the
exception").
Handlerul este cod scris de utilizator !!!!
Cu alte cuvinte la aparitia unei erori este
"aruncata" o exceptie iar cineva trebuie sa o
"prinda" pentru a o trata. Daca sistemul nu
gaseste nici un analizor pentru o anumita
exceptie atunci programul Java se opreste
cu un mesaj de eroare (n cazul exemplului
de mai sus mesajul "Aici nu se mai ajunge..."
nu va fi tiparit).
Atentie: In Java tratarea erorilor nu mai este o
optiune ci o constrngere. Orice cod care
poate provoca excepii trebui sa specifice
modalitatea de tratare a acestora.
Avantajele exceptiilor
Prin modalitatea sa de tratare a exceptiilor
Java are urmatoarele avantaje fata de
mecanismul traditional de tratare a
erorilor:
Separarea codului pentru tratarea unei
erori de codul n care ea poate sa apara
Propagarea unei erori pna la un
analizor de exceptii corespunzator
Gruparea erorilor dupa tipul lor
Separarea codului pentru tratarea unei erori de
codul n care ea poate sa apara
In programarea tradiionala tratarea erorilor se
combina cu codul ce poate produce apariia lor
conducnd la asa numitul "cod spaghetti". Sa
consideram urmtorul exemplu: o funcie care
ncarca un fiier n memorie:

citesteFisier {
deschide fisierul;
determina dimensiunea fisierului;
aloca memorie;
citeste fisierul in memorie;
inchide fisierul;
}
Problemele care pot aparea la aceasta
functie, aparent simpla sunt de genul:
"Ce se ntmpla daca: ... ?

fisierul nu poate fi deschis
nu se poate determina dimensiunea fisierului
nu poate fi alocata suficienta memorie
nu se poate face citirea din fisier
fisierul nu poate fi nchis
int citesteFisier {
int codEroare = 0;
deschide fisier;
if (fisierul s-a deschis) {
determina dimensiunea fisierului;
if (s-a determinat dimensiunea) { aloca memorie;
if (s-a alocat memorie) { citeste fisierul in memorie;
if (nu se poate citi din fisier) { codEroare = -1; }
} else { codEroare = -2; }
} else { codEroare = -3; }
inchide fisierul;
if (fisierul nu s-a inchis && codEroare == 0)
{ codEroare = -4; }
else { codEroare = codEroare & -4; }
} else { codEroare = -5; }
return codEroare;
}//cod "spaghetti"
int citesteFisier {
try {
deschide fisierul;
determina dimensiunea fisierului;
aloca memorie;
citeste fisierul in memorie;
inchide fisierul;
}
catch (fisierul nu s-a deschis) {trateaza eroarea;}
catch (nu s-a determinat dimensiunea) {trateaza
eroarea;}
catch (nu s-a alocat memorie) {trateaza eroarea }
catch (nu se poate citi dun fisier) {trateaza eroarea;}
catch (nu se poate inchide fisierul) {trateaza eroarea;}
}
Java permite unei metode sa arunce excepiile
aprute n cadrul ei la un nivel superior, adic
funciilor care o apeleaz sau sistemului. Cu alte
cuvinte o metoda poate sa nu si asume responsa-
bilitatea tratrii excepiilor aprute n cadrul ei:
metoda1 {
try {
apel metoda2;
}
catch (exceptie) {
proceseazaEroare;
} . . .
}
metoda2 throws exceptie{
apel metoda3;
. . .
}
metoda3 throws exceptie{
apel citesteFisier;
. . .
}
Gruparea erorilor dupa tipul lor
In Java exista clase corespunzatoare tuturor
exceptiilor care pot aparea la executia
unui program. Acestea sunt grupate n
functie de similaritatile lor ntr-o ierarhie
de clase. De exemplu, clasa IOException
se ocupa cu exceptiile ce pot aparea la
operatii de intrare/iesire si diferentiaza la
rndul ei alte tipuri de exceptii, cum ar fi
FileNotFoundException, EOFException,
etc.
try {
FileReader f = new FileReader("input.dat");
//acest apel poate genera exceptie de tipul
FileNotFoundException
//tratarea ei poate fi facuta in unul din modurile de
mai jos
}
catch (FileNotFoundException e) {
//exceptie specifica provocata de absenta fisierului
'input.dat'
} //sau
catch (IOException e) {
//exceptie generica provocata de o operatie de
intrare/iesire
} //sau
catch (Exception e) {
//cea mai generica exceptie - NERECOMANDATA!
}
"Prinderea" si tratarea excepiilor
Tratarea exceptiilor se realizeaza prin intermediul blocurilor de
instructiuni try, catch si finally. O secventa de cod care
trateaza anumite exceptii trebuie sa arate astfel:

try {
Instructiuni care pot genera o exceptie
}
catch (TipExceptie1 ) {
Prelucrarea exceptiei de tipul 1
}
catch (TipExceptie2 ) {
Prelucrarea exceptiei de tipul 2
} . . .
finally {
Cod care se executa indiferent daca apar sau nu
exceptii
}
//ERONAT!
import java.io.*;
public class CitireFisier {

public static void citesteFisier() {
FileInputStream sursa = null; //s este flux de intrare
int octet;
sursa = new FileInputStream("fisier.txt");
octet = 0;
//citesc fisierul caracter cu caracter
while (octet != -1) {
octet = sursa.read();
System.out.print((char)octet);
}
sursa.close();
}

public static void main(String args[]) {
citesteFisier();
}
}
Vezi exemplu citire fisier1 corect!!!!
"Aruncarea" excepiilor
In cazul n care o metoda nu si asuma
responsabilitatea tratrii uneia sau mai multor
excepii pe care le pot provoca anumite
instruciuni din codul sau atunci ea poate sa
"arunce" aceste excepii ctre metodele care o
apeleaza, urmnd ca acestea sa implementeze
tratarea lor sau, la rndul lor, sa "arunce" mai
departe excepiile respective.
Acet lucru se realizeaza prin specificarea n
declaratia metodei a clauzei throws:
metoda throws TipExceptie1, TipExceptie2, ... { . .
. } vezi exemplu citire fiser 2
Atentie:
Obligatoriu un bloc de instruciuni "try" trebuie sa
fie urmat de unul sau mai multe blocuri "catch",
n funcie de excepiile provocate de acele
instruciuni sau (optional) de un bloc "finally"
O metoda care nu trateaz o anumita exceptie
trebuie obligatoriu sa o "arunce". Daca nu facem
tratarea excepiilor n cadrul metodei atunci
metoda apelanta (main) va trebui sa faca acest
lucru:
Fire de execuie
Firele de executie fac trecerea de la programarea secventiala la
programarea concurenta. Un program secvential reprezinta
modelul clasic de program : are un nceput, o secventa de
executie a instructiunilor sale si un sfrsit. Cu alte cuvinte, la un
moment dat programul are un singur punct de executie. Un
program aflat n executie se numeste proces. Un sistem de
operare monotasking (MS-DOS) nu este capabil sa execute dect
un singur proces la un moment dat n timp ce un sistem de
operare multitasking (UNIX, Windows) poate rula oricte procese
n acelasi timp (concurent), alocnd periodic cuante din timpul de
lucru al CPU fiecarui proces. Am reamintit acest lucru deoarece
notiunea de fir de executie nu are sens dect n cadrul unui
sistem de operare multitasking.
Un fir de executie este similar unui proces secvential n sensul ca
are un nceput, o secventa de executie si un sfrsit. Diferenta
ntre un fir de executie si un proces consta n faptul ca un fir de
executie nu poate rula independent ci trebuie sa ruleze n cadrul
unui proces.

Definitie
Un fir de executie este o succesiune sceventiala de instructiuni care se
executa n cadrul unui proces.
Firele de executie sunt utile n multe privinte, nsa uzual ele sunt folosite pentru
executarea unor operatii consumatoare de timp fara a bloca procesul
principal : calcule matematice, asteptarea eliberarii unei resurse, acestea
realizndu-se de obicei n fundal.
Crearea unui fir de executie

Ca orice alt obiect Java, un fir de executie este o
instanta a unei clase. Firele de executie definite de o
clasa vor avea acelasi cod si, prin urmare, aceeasi
secventa de instructiuni. Crearea unei clase care sa
defineasca fire de excutie poate fi facuta prin doua
modalitati:

prin extinderea clasei Thread
prin implementarea interfetei Runnable

Orice clasa ale carei instante vor fi executate ntr-un fir de
executie trebuie declarata ca fiind Runnable.
Extinderea clasei Thread
Cea mai simpla metoda de a crea un fir de executie care
sa realizeze ceva este prin extinderea clasei Thread si
supradefinirea metodei run a acesteia. Formatul general
al unei astfel de clase este:
public class NumeThread extends Thread
{
public NumeThread(String nume)
{
super(nume); //apelez constructorul superclasei Thread
}
public void run()
{
//codul executat de firul de executie
}
}
Prima metoda a clasei este constructorul, care
primeste ca argument un sir ce va reprezenta
numele firului de executie creat n momentul cnd
constructorul este apelat iar lansarea sa n
executie se realizeaza prin metoda start

SimpleThread t = new SimpleThread("Java")
//creeaza un fir de executie cu numele Java
t.start()
//creeaza si lanseaza un fir de executie
public class PrimulFir{
public static void main (String args[]) {
System.out.println("Crearea firului de executie");
FirExecutie fir=new FirExecutie();
System.out.println("Pornim firul");
fir.start();
System.out.println("Revenim la main");
}
}
class FirExecutie extends Thread {
public void run() {
int numarPasi=5;
System.out.println("numar pasi se executa de
"+numarPasi+" ori");
for(int i=1;i<=numarPasi;i++)
System.out.println("Pasul "+i);
System.out.println("Aici se termina metoda run");
} }
class Counter extends Thread { //clasa care defineste firul de executie
private int from, to, step;
public Counter(int from, int to, int step) {
this.from = from;
this.to = to;
this.step = step; }
public void run() {
for(int i = from; i <= to; i += step)
System.out.print(i + " " ); }
}
public class TestCounter { //clasa principala
public static void main(String args[]) {
Counter cnt1, cnt2; //doua fire ..
cnt1 = new Counter(0, 10,5);
//numara de la 0 la 100 cu pasul 5
cnt2 = new Counter(100, 200, 10);
//numara de la 100 la 200 cu pasul 10
cnt1.start();
cnt2.start();
//pornim firele de executie
//ele vor fi distruse automat la terminarea lor }
}
Ce se va afisa pe ecran ?!!!?
Orice clasa ale carei instante vor fi executate ntr-un fir de
executie trebuie declarata ca fiind Runnable. Aceasta este o
interfata care contine o singura metoda, si anume metoda
run. Asadar, orice clasa ce descrie fire de executie va
contine o metoda run n care este implementat codul ce va fi
executat de firul de executie. Interfata Runnable este
conceputa ca fiind un protocol comun pentru obiectele care
doresc sa execute un cod pe durata existentei lor (care
reprezinta fire de executie).

Cea mai importanta clasa care implementeaza interfata
Runnable este clasa Thread. Clasa Thread implementeaza
un fir de executie generic care, implicit, nu face nimic. Cu
alte cuvinte metoda run nu contine nici un cod.

Orice fir de executie este o instanta a clasei Thread sau a
unei subclase a sa.
Implementarea interfetei Runnable
Ce facem nsa cnd dorim sa cream o clasa care instantiaza fire
de executie dar aceasta are deja o superclasa, stiind ca n Java
nu este permisa mostenirea multipla ?

class FirExecutie extends Parinte, Thread // ilegal !

In acest caz nu mai putem extinde clasa Thread ci trebuie sa
implementam direct n clasa noastra interfata Runnable. Clasa
Thread implementeaza ea nsasi interfata Runnable si, din acest
motiv, la extinderea ei obtineam o implementare implicita a
interfetei. Asadar, interfata Runnable permite unei clase sa fie
active, fara a extinde clasa Thread.
Interfata Runnable se gaseste n pachetul
java.lang si este definita astfel:

public interface Runnable {
pulic abstract void run( );
}

Prin urmare, o clasa care instantiaza fire de
executie prin implementarea interfetei Runnable
trebuie obligatoriu sa implementeze metoda run.
Formatul general al unei clase care implementeaza interfata
Runnable este:
public class SimpleThread implements Runnable {
private Thread simpleThread = null;
public SimpleThread() {
if (simpleThread == null) {
simpleThread = new Thread(this);
simpleThread.start();
}
public void run() {
//codul executat de firul de executie
}
}
Spre deosebire de modalitatea anterioara, se pierde
tot suportul oferit de clasa Thread pentu crearea unui
fir de executie.
Simpla instantiere a unei clase care implemeneaza
interfata Runnable nu creeaza nici un fir de
executie. Din acest motiv crearea firelor de
executie prin instantierea unei astfel de clase
trebuie facuta explicit.
In primul rnd trebuie declarat un obiect de tip Thread
ca variabila membra a clasei respective. Acest obiect
va reprezenta firul de executie propriu zis al carui cod
se gaseste n clasa noastra.
private Thread simpleThread = null;
Urmatorul pas este instantierea si initializarea firului de
executie. Acest lucru se realizeaza ca pentru orice alt
obiect prin instructiunea new, urmata de un apel la un
constructor al clasei Thread, nsa nu la oricare dintre
acestia. Trebuie apelat constructorul care sa primeasca
drept argument o instanta a clasei noastre. Dupa creare,
firul de executie poate fi lansat printr-un apel la metoda
start.(Aceste operatiuni sunt scrise de obicei n
constructorul clasei noastre pentru a fi executate la
initializarea unei instante, dar pot fi scrise oriunde n
corpul clasei sau chiar n afara ei)
simpleThread = new Thread( this );
simpleThread.start();
Specificarea argumentului this n
constructorul clasei Thread determina
crearea unui fir de executie care la lansarea
sa va cauta n clasa noastra metoda run si o
va executa. Acest constructor accepta ca
argument orice instanta a unei clase
"Runnable". Asadar metoda run nu trebuie
apelata explicit, acest lucru realizndu-se
automat la apelul metodei start.
Apelul explicit al metodei run nu va furniza
nici o eroare, nsa aceasta va fi executata ca
orice alta metoda, deci nu ntr-un fir de
executie
class Counter implements Runnable {
private Thread counterThread = null;
private int from, to, step;
public Counter(int from, int to, int step) {
this.from = from;
this.to = to;
this.step = step;
if (counterThread == null) {
counterThread = new Thread(this);
counterThread.start(); }
}
public void run() {
for(int i = from; i <= to; i += step)
System.out.print(i + " " );
}
}
//Crearea firului de executie se realizeaza n constructorul clasei Counter
public class TestThread2 {
public static void main(String args[]) {
Counter cnt1, cnt2;
cnt1 = new Counter(0, 100, 5);
cnt2 = new Counter(100, 200, 10);
}
}
class Counter implements Runnable {
private int from, to, step;
public Counter(int from, int to, int step) {
this.from = from;
this.to = to;
this.step = step;
}
public void run() {
for(int i = from; i <= to; i += step)
System.out.print(i + " " );
}
}
//Crearea firului de executie se realizeaza n main, in afara clasei Counter:
public class TestThread22 {
public static void main(String args[]) {
Counter cnt1, cnt2;
cnt1 = new Counter(0, 100, 5);
cnt2 = new Counter(100, 200, 10);
new Thread( cnt1 ).start(); //lansez primul fir de executie
new Thread( cnt2 ).start(); //lansez al doilea fir de executie
}
}