http://www.jobsite.co.uk/job/lead-automotive-engineer-956442417?

jbe_click=1&jbe_appid=46235225&tmpl=sem&sctr=AU&utm_campaign=jbe-AU&utm_source=jbe-
oscar&utm_content=110916&utm_medium=email&cid=F-JaJob-11-2015_vacancy&cid=&intcid=jajob-
full-oscar

http://www.jobsite.co.uk/job/cad-engineer-956338654?
jbe_click=1&jbe_appid=46235225&tmpl=sem&sctr=AU&utm_campaign=jbe-AU&utm_source=jbe-
oscar&utm_content=110916&utm_medium=email&cid=F-JaJob-11-2015_vacancy&cid=&intcid=jajob-
full-oscar

http://www.jobsite.co.uk/job/956641176?src=apply-confirm&jobTile=listing-4&v96=ssr&noret=1

http://www.jobsite.co.uk/job/956566809?src=apply-confirm&jobTile=listing-4&v96=ssr&noret=1

Pentru import:

Import <nume pachet>.<nume clasa>

Exemplu : Import java.awt Minge

Public class Program {}

Modificatori :

 Public iti da access a vezi orice de oriunde

 Private : restrange accesul la un membru numai in interiorul clasei , nu poate fii accesat
din alta clasa (variabila , metoda etc)
 Protected:

Pentru a modifica de exemplu pe Private se foloseste un accesor si un mutator:

Accesorul preia valoarea variabilei protejate si o returneaza  se foloseste public int getX();

Mutatorul nu returneaza nici o valoare este de tip void  public void setX(int x) si are ca
parametru variabila pe care o muta.
Static  daca e zona de memorie e unica in clasa
Se poate folosii pt un membru al clasei , dar niciodata pentru ceva declarant local

Metode statice -- > bloc de instructiuni al clasei ce nu defineste comportament de instanta–

executia nu depinde de vreo instanta a clasei

Il putem apela cand nu avem o instant a clasei , nuu ii trebuie instanta

Dintro metoda static pot sa apelez oricare alt membru static , nu voi putea apela nimic care
este NON static

Zonele de memorie statice se creeaza la momentul declararii

Executie  este creeata in momentul in care masina virtuala incarca clasa

Atributul se rezerva in memorie la instantiere , iar zona de memorie static se rezerva in

memorie la declarare

Blocuri statice anonime :

Blocurile anonime non-statice se executa inainte de constructor

Ceea ce este static se exectuta inainte de non-static

OVERLOADING:

Rep posibilitatea de a definii in aceeasi clasa mai multe metode cu acelasi nume , cu conditia ca
parametrii sa difere (NUMARUL , TIPUL , ORDINEA LOR )

Constructori supraincarcare -- > parametric diferiti la fel ca la metode , ei iau numele clasei
prin definitia lor , adica trebuie sa ia numele clasei .

Indentificarori sa fie acelasi si parametri diferiti

this() – prima instructiune intr-un constructor !

Array:

 o structura de tip ARRAY reprezinta o coletie de zone de memorie variabile de acelasi tip
cu un numar constant de nuere
 un array in java este un obiect , deoarece se foloseste new
  nu putem sa modificam dimensiunea unui array odata ce l-am creat
 exista array doar cu o singura dimeniuse , dar care trimite la alte array-uri [] []
 la initializare se folosesc paranteze {} de exemplu int [] m = {4,2,3,5.5}

Pachetele – rep colectii de clase , au rol de organizre a claselor intr-un proiect dar si de domenii
de nume

 Intr-un proiect putem avea mai multe clase cu acelasi nume , cu conditia ca acestea sa
faca parte din pachete diferite
 nu putem avea mai multe clase cu acelasi nume intr-un pachet

/-----------------------------------------------------------------/

Public este accesibil de orice clasa

Privat doar pentru acea clasa care la definit

Default poate fi accesat doar in domeniul de vizibilitate , vizibilitatea este in interiorul

pachetului

Protected  la fel ca default dar uneori si in afara pachetului

ORDINEA DE LA PUBLIC LA PRIVAT : PUBLIC , PROTECTED, DEFAULT,PRIVAT

Rolul lor este de a obstruction vizibilitatea doar intre clase , nu si local de exemplu : metode ,
zone de memorie

/-----------------------------------------------------------------/

Encapsularea -- > rep ascunderea informatilor in interiorul instantei sau clasei si oferim acces
indirect prin intermediul unor metode

1. getter sau accesor (accesam valuarea ascunsa)

2. setter sau mutter (modificam valoarea ascunsa)

Getter trebuie sa fie intotdeauna publici , si intoarce valoarea atributului, NU ARE PARAMETRU

Setter este de tip VOID si nu intoarce o valoare , scopul lui este de a o modifica, ARE
PARAMETRU

 El primeste ca parametru valoarea pe care o modifica a atributului , de ex : String nume

Cand parametru este Boolean folosim is in loc de get , la scrierea getterului.

/-----------------------------------------------------------------/

IMUTABILITATEA

 Presupune definirea unei clase ale carei instante nu pot fi modif odata ce au fost
create ,valorile nu pot fi modificare , doar returnate.
 Odata create atributele ele nu pot fii modificate , la fel ca la encapsulare , doar ca aici se
va folosii doar getterul fara a mai folosii setter-ul !

/-----------------------------------------------------------------/

MOSTENIREA (Extends)

 Se refera la particularizarea protopilui definit de clasa , adica particularizam un obiect pe

care il mostenim. de exemplu o bicicleta , particularizam la o tricicleta care a o roata in
plus.
 Adaugarea de attribute, de noi comportamente ,modif atributelor , modif
comportamentelor. Modalitati de particularizare !
 Se poate mosteni doar o singura clasa
 Cand se mosteneste se va exclude tot ceea ce este STATIC in clasa
 Modifcatori care accepta mostenirea este public si protected
 Particularizarea unui atribut se face prin inlocuirea cu altul , adica ascunderea celui
vechi , inlocuirea in clasa care mosteneste alta clasa.
 Particularizarea c

This este instanta clasei , intr-un constructor este instanta care se creeaza , iar intr-un
comportament este instanta care se comporta

La supraincarcare this() este : putem sa apelam una dintre supraincarcarile constructorului

din aceeasi clasa

La supraincarcare super() este : il folosim atunci cand vrem sa specificam unui constructor pe
care dintre constructorul clasei superioare sa-l apeleze daca sunt mai multi , si mai ales ca
suntem obligati sa-l folosim pe super atunci cand constructorul clasei superioare nu-l are
deloc pe cel fara parametrii

/-----------------------------------------------------------------/

SUPRASCRIEREA (OVERRINDING )

Rep ce-a dea 4 particularizare la mostenire

Este echivalenta cu modificarea functionalitatii unui comportament mostenit,

Prin suprascriere o clasa poate sa modifice functionalitatea unui comportament pe care il
mosteneste , MODIFICAM COMPORTAMENTUL CARE IL MOSTENIM de la alta clasa !

PRIVATE NU SE MOSTENESTE SI NU SE SUPRASCRIE !

Reguli de suprascriere:

1. Metoda care suprascrie trebuie sa aiba acelasi identificator si aceeasi parametrii

2. Daca tipul returnat este void sau primitiv metoda care suprascrie trebuie sa aiba acelasi tip
ca metoda suprascrisa , daca tipul returnat este obiect trebuie sa respecte regurile
polimofirsmului

3. Modul de acces al metodei care suprascrie trebuie sa fie cel putin la fel de public ca si cel al
metodei suprascrise

4. Metoda care suprascie poate propaga un spectru mai ingust de exceptii decat metoda
suprascrisa

PRIVATE NU SE MOSTENESTE SI NU SE SUPRASCRIE !

@Override se aplica deasupra metodei pe care o suprascriem , ea ne foloseste atunci cand

compilam sa ne dam seama daca e o suprascriere corecta

SUPRAINCARCARE SUPRASCRIERE

Trebuie sa avem parametrii diferiti Trebuie sa avem aceeasi parametrii

Tipul returnat nu are importanta la
supraincarcare
Pentru supraincarcare putem avea sau nu
mostenire
Modul de acces NU conteaza in cazul
supraincarcarii
Putem supraincarca o metoda statica
Exceptiile NU au nici o importanta pentru
supraincarcare
Un constructor poate fi supraincarcat
Tipul returnat are importanta la suprascriere
Pentru sprascriere avem mostenire
Modul de acces conteaza in cazul suprascrierii
Nu putem suprascrie o metoda statica pentru
ca nu fac parte din prototip
Exceptiile au o importanta pentru
supraincarcare
Un constructor nu poate fi suprascris
MODIFICATORUL FINAL Poate fii folosit pentru clase si metode

 O metoda final este o metoda care nu mai poate fii suprascrisa

 O clasa final este o clasa ce nu poate fii mostenita

/-----------------------------------------------------------------/

PROTOTIPURI ABSTRACTE:

Reprezinta un prototip incomplet definit folosit doar in scop pentru a fii particularizat pentru a
generaliza caracteristici comune .

 Un prototip abstract nu poate avea instante , este conceput doar pentru a fii
particularizat , este ceva comun pentru toate clasele , il scriem doar odata
 Daca metoda este abstracta atunci si clasa este abstracta
 Dar o clasa abstracta poate sa aiba metode care nu sunt abstracte sau sa nu aiba deloc
 O clasa concreta adica obisnuita, care mosteneste o clasa abstracta , trebuiesc
suprascrise metodele abstracte din clasa mostenita
 O clasa abstracta poate mostenii alta clasa abstracta

/-----------------------------------------------------------------/

POLIMORFISM:

1 .Rep posibilitatea unei instante de a lua forma oricareia dintre prototipurile superioare celeui
cu care a fost create , daca instant ia o alta forma pot fi accesate doar caracteristicile(attribute
sau comportament) pe care le defineste acea forma ,chiar daca instanta ar putea avea mai
multe.

2.Daca unul dintre comportamente este suprascris de catre prototipul instantei se va apela
suprascrierea nu modul in care este descries comportamentul in forma.

3.Daca sunt ascunse campuri , atunci valoare accesata este cea din forma nu cea din instanta.

In cazul comportamentelor se exeuta suprascrierea , in cazul campurilor ascunse se ia

valoarea din forma !

Intru-un array putem avea mai multe instante diferite daca ne permite polimorfismul
/-----------------------------------------------------------------/

CONVERSIE EXPLICITA:

Compileaza dar la executie ne intampineaa cu CastException

v[1] = new Triunghi();

Triunghi t1 = (Triunghi) v[1];

Dreptunghi d1 = (Dreptunghi) v[1]  compileaza dar da exceptie la executie

/-----------------------------------------------------------------/

INTERFETE : (Interface)

Reprezinta de asemenea structuri folosite pentru declararea prototipurilor abstracte , au si

rolul de a implementa prototipuri abstracte , au niste mici diferente fata de clasa abstracta

Cand o clasa mosteneste o interfata se foloseste implements , interfetele se pot mostenii un

ape cealalta

Extends se folseste cand se mosteneste clasa cu clasa , sau interfata cu interfata

Implements se foloseste cand o clasa mosteneste o interfata .

O clasa poate sa mosteneasca una sau mai multe interfete , pe cand o clasa poate sa
mosteneasca doar o clasa !

Intotdeauna o interfata implementeaza un prototip abstract

In versiunea 7 de JAVA o interfata putea sa aiba doar METODE abstracte , insa incepand cu
versiunea 8 o interfata poate avea si metode concrete (cele obisnuite)  aici se va folosii in
fata metodei modificatorul Default , pentru ca ea e abstracta implicit si ca sa o facem concreta
ii punem default in fata metodei, insa putem avea si metode statice la v8.

Intr-o interfata putem avea doar zone de memorie constante(final) , statice si publice  nu

exista attribute ,variabile , zone de memorie private protejate package mode !

Orice metoda este implicit abstracta si publica.

Incepand cu versiunea 8 putem avea si metode static in interfete !

STATIC -- > REZERVARE LA MOMENTUL DECLARARII

FINAL -- > ZONA DE MEMORIE CARE TREBUIE SA PRIMEASCA O VAL PANA LA MOMENTUL
REZERVARII

Zone de memorie:

Exemplu : public static final int x=10; , modificatorii sunt impliciti , pot sa-i pun sau nu !

Metode:

Exemplu : public abstract void play(); modificatorii sunt impliciti

Ne permite abstractizarea si creste menta

O interfata care nu contine metode nici mostenite si nici declarate se numeste INTERFATA
MARKER !

ENUMERARI: (Enum)

Sunt structure asemanatoare unor clase care insa declara un numar constant de instante , in
program pot fi folosite doar acele instante pe care le-a declarant.

Nu poate fii mostenita , poate sa mosteneasca !

Instantiere se face doar in interiorul structurii si sunt private , comportamentele ei sunt publice
le putem apela din afara!

Nu are sens sa adaugam instante, pentru ca avem un numar finit , doar cu ele lucram

Intai se scriu instantele dupa punem constructor, comportamente , attribute

Are doar constructori PRIVATE , se poate pune in fata constructorului sau nu , e implicit.

Orice enumerare are o metoda statica numita “values”

Atunci cand declaram la inceput instantele , DACA nu urmeaza nimic dupa ele este obtionala
puneara “;” , iar DACA urmeaza atunci sunt obligatorii !
TIPURI IMBRICATE (Nestead)

Reprezinta o clasa , interfata sau enumerare declarata in interiorul unei altei clase sau unui
bloc de instructiuni.

Clase top level --> cele obisnuite

Clase neasted  inner si locale

inner  statice si non – statice

locale  context static si in context non-static

Inner  Tipurile inner reprezinta clase , interfete sau enumerarii declarate ca membrii ai
unei clase , adica intre acoladele clasei.

Poate fii declarat static sau non-static , static apartine clasei si non-static apartine instantei.

Cand declaram un atribut , acela apartine unei instante adica este non-static , nu exista atribut
static ,apartine mereu unei instante, ce este static este de clasa .

REGULI:

1. Daca x vine din clasa din care e declarata clasa inner vom putea sa ne referim la this
doar prin numele acestei clasa. Adica A1.this.x =10; Unde A1 este clasa outter.

A2 si A3 sunt membrii clasei A1 , adica pot fi static si non-statici.

Sunt 2 diferente daca clasa A3 o declam top-level si cum e declarata acum in interiorul lui A1:

 Are acces la membrii privati daca e declarata sub A1 , pe cand daca era toplevel nu avea
acces.
 Ea insasi se afla sub un mod de acces , adica putem sa o facem private .

! O clasa inner poate sa mosteneasca o alta clasa inner sau poate mostenii inclusive clasa
outter sau o alta clasa din afara acesteia , aici avem o singura restrictive , o clasa statica nu
poate mostenii o alta clasa non-statica .

 Orice clasa static sau non static poate mostenii clasa outter.

Locale:
Reprezinta o clasa sau o interfata (fara enumerari) declarata intr-un bloc de instructiuni, deci
poate fii o metoda sau un bloc anonim.

Se numeste tip local in context static atunci cand blocul de instructiuni care incadreaza
declararea este unul STATIC ! class C3

Se numeste tip local in context NON -static atunci cand blocul de instructiuni care incadreaza
declararea este unul NON -STATIC ! class C2

Desi putem folosii variabile globale x si y , nu putem folosii decat constante locale ! Incepand
cu Versiunea 8 , orice variabila locala folosita in context local devine constanta implicit.
TIPURI ANONIME :

Ele reprezinta tipuri neasted , are aceleasi caracteristici.

Putem face ca o instanta sa se comporte altfel , fata de celelalte , dar trebuie sa ii suprascriem
comportamentul ,chenarul de mai jos este considerat clasa anonima.

Pentru fiecare neasted type pe baza clasei se creaza un fisier . class

O interfata functionala are DOAR o metoda abstracta , pe care o inlocuieste LAMDA , si prin
anotarea @FuntionalInterface verificam daca o interfata este functionala , se pune deasupra
interfetei.

--> Ce este un predicat ? Este o regula care primeste o valoare si intoarce adevarat sau fals
despre acea valoare

Predicat p1 = Valoarea sageata regula ;

Predicat p2 = x -> x > 5; pentru ca am un singur parametru in comportament , parantezele sunt
obtionale, daca nu am parametrii sau am mai mult OBLIGATORIU pun paranteze.

Predicat p3 = Obligatoriu pun paranteze daca vreau sa specific tipul

Predicat p4 = Daca pun acolade , obligatoriu trebuie sa pun si return , NU trebuie sa pun return
atunci cand nu am acolade.

/---------------------------------------------------/

Expresiile LAMDA
Se bazeaza pe existenta unei interfete ,aceasta interfata trebuie sa fie neaparat functionala, ca
sa poata fii transformata intr-o expresie lamda. O interata functionala trebuie sa aiba o singura
metoda abstracta , nu mai putine nu mai multe !

Pentru a testa daca o interfata este FUNCTIONALA folosim anotarea @FunctionalInterface.

Functie -- > Primeste o valare si returneaza o valoare (function)

/---------------------------------------------------/

Singleton Patern
Design patern --> Reprezinta o solutie dovedita pentru o problema cunoscuta,adica o situatie
de scriere a codului in care vrei sa scrii codul curat si mentenabil.

Se creeaza o singura instanta pe care eu oriunde de acum in colo o pot obtine folosind
getInstance
Constructorul este Private pentru a nu da posibilitatea creeari instantelor din afara clasei.

In exemplu 2 de mai sus , p2.nume afiseaza numele TOM , pentru ca SINGLETON returneaza o
singura valoare a numelui , p2 este egala cu p1.

/---------------------------------------------------/
PACHETE si CLASA OBJECT

Pachetul Java.lang ,este pachetul fundamental al limbajului , este importat by default in limbaj ,
este implicit importat.

Clasa OBJECT --> este radacina arborelui de mosteniri in JAVA ! Este o clasa superioara oricarei
clase din limbaj , orice clasa mosteneste direct sau indirect pe OBJECT.

REGULA : Orice clasa nu mosteneste pe nimeni , mosteneste implicit pe object.

REGULA : Este singura clasa care nu mosteneste pe nimeni , este singura care este parinte
tuturor.

Documentatia metodelor se pot gasii aici : http://docs.oracle.com/javase/8/docs/api/

Metoda equals : Este metoda pe care o suprascriem in orice clasa pentru a definii
regula de egalitate intre 2 instante ale clasei.

In documentatie metodele care nu sunt marcate cu un modificator de acces in fata , sunt

publice ! Iar cele care

REGULA : Este standard ca nimic sa nu fie egal cu NULL; si trebuie verificat mereu daca
metodata intoarc mereu false, pentru null.

Cu operatorul instance of , testam ca o instanta este de un anumit tip !

Diferenta dintre equals si == :

== testam egalitatea referintelor

 equals este facut pentru a defini o regula si testeaza daca instantele sunt egale dupa
aceasta regula

Metoda toString() : Are rolul de a fii suprascrisa pentru a definii o reprezentare ca sir de
caractere a unei instante.

Metoda hashCode() , poate fii suprascrisa pentru a returna o valoare intreaga (int) , cu
scopul de eticheta in gruparea instantelor.
o REGULA : Oricare 2 instante egale , TREBUIE sa aiba aceeasi valoare de tipul
hashCode , dar nu neaparat 2 instante hashCode sunt egale , cand zic instante
egale ma refer la equals() sa returneze true; Se face dupa equals pentru scopul
de a grupa instantele si pentru eficientizarea cautarii lor.

Garbage Collector --> este un mecanism automat ce ruleaza si se ocupa de eliberarea

memoriei . El elibereaza din memorie instantele care catre nu mai exista nici o referinta. Out of
memory este o eroare cand procesul nu mai are memorie, garbich colector se executa cand
vrea , nu poate programatorul sa il execute.

Memoria se clasifica in 2 tipuri : HYP si Stuck

Memoria Hyp -- > e o zona de memorie cu alocare dinamica si este locul unde vor fi alocate
instantele de obiect. OutofMemoryError

Memoria Stuck --> Este memoria alocata executiei blocurilor de instructiuni. GC elibereaza
memoria cand se inchide executia metodei. StuckOverflowError

Metoda finalize() – se apeleaza inaintea Garbage Collector-ului .

/---------------------------------------------------/

EXCEPTII SI ERORI :
O exceptie reprezinta un obiect in prog nostru folosit pentru a marca o situatie din timpul
exeutiei.

Consideram exceptiile de 2 tipuri :

1. Exceptii de sistem
2. Exceptii de business (aplicatie )

Exceptii de sistem -- > intelegem probleme tehnice intampinate de program in timpul

executiei , aceste probleme pot fi cauzate de mediul in care aplicatia se executa, de Exemplu:
incercarea de dereferentiere a unui atribut/comportament dintr-o zona de memorie care
contine null , numita Nullpointerexception.

Classcasexception (apare la o forma care nu este de tipul instantei respective)

Arrayoutofboundexception (accesarea dintr-un array unui index care nu exista)

A trata o exceptie este atunci cand ii spunem aplicatiei ce sa faca cand se blocheaza din cauza
unei exceptii de mai sus.

Exceptii de business (aplicatie):

Este atunci cand programatorul creeaza o exceptie, semnalam o anumita situatie , cu scopul de
a o trata in alta parte.

Exceptiile sunt reprezentate de clasa exception din pachetul java.lang , este o clasa care
incadreaza ambele tipuri de exceptii si de sistem si de aplicatie.

ERORI:
Sunt reprezentate de clasa error pe care o mostenesc din pachetul java.lang

Exceptiile si erorile sunt foarte asemanatoare , sunt situatii din aplicatii care la momentul
executiei nu stie aplicatia implicit ce sa faca , doar ca erorile NU POT FII TRATATE.
(outofmemory si stuckoferror). Nosuchmethoderror ,este aruncata de masina virtuala atunci
cand programatorul incearca sa execute o aplicatie pentru care fie nu a fost definita metoda
main fie a fost gresit.

Clasa error si clasa exception , mostenesc o clasa mai generala : clasa throuble. Prin
aruncarea exceptiiei sau erori intelegem ca acolo s-a semnalat situatia respectiva.

Exceptii:
Clasificare :

1. Exceptii de RuntimeException (clasa runtimeExeption din java.lang)

2. Exceptii checkedExpetion sau propagabile

1 -- > Numim exceptii de runtime o exceptie ce poate ajunge la momentul executiei , trebuie sa
fie creata cu o clasa care mosteneste direct o clasa runtimeException. Doar clasele care se alfa
sub runtimeExeption reprezinta exceptii de runtime , oricare alta clasa reprezinta exceptii
check sau propagabile.

2 --> Exceptiile check nu ajung la executie pentru ca suntem obligatii de compilator sa le tratam,
compilarea esueaza. Exceptiile de aplicatie sunt exceptiI CHECKED!

Exceptiile de sistem --> sunt intotdeauna Exceptii RunTime

Exceptiile de aplicatie --> sunt intotdeauna Exceptii Checked

Intodeauna o metoda are 2 solutii : cuv cheie : throw

1. fie trateaza o exceptie , dar daca nu o poate trata atunci solutia 2.

2. fie o propaga catre cel care o apeleaza , pentru ca acela sa poate sa o trateze

O metoda si un constructor poate propaga mai multe exceptii separandule prin virgula !

Exceptiile check se propaga cele unckeck nu se propaga !

Exceptii -> Check si Uncheck

Uncheck --> mostestenesc clasa RuntimeException , sunt cele pe care compilatorul ne lasa sa
le aruncam pana la executie
TRATAREA EXCEPTIILOR:
Tratarea exceptiilor inseamna specificarea unui set de instructiuni care sa fie executat la
momentul intampanarii unei situatii de tip exceptii.

Pentru asta in Java folosim blocurile de instructiuni Try , Catch , Finally .

Try --> Apare intotdeauna si intodeauna este unul singur , acoladele pentru cele 3 nu pot lipsii
(sunt obligatorii), Try apare in toate cele 3 cazuri. El reprezinta blocul de instr in care ma astept
sa am exceptii care se arunca. Cea mai simpla scriere este blocul Try urmat de Finally.

Finally --> Este obtional , poate fii de asemenea singur , nu pot fii mai multe blocuri finally , rep
bl de inst care se executa intotdeauna indiferent daca am intampinat sau nu o exceptie.

Daca in blocul Try nu se executa nici o exceptie , blocul se va executa de la un capat la altul , si
imediat dupa el finally , DAR daca undeva in blocul try apare o exceptie se opreste , si trece
imediat in executia blocului finally.

Ambele clase Error si Exception , mostenesc o clasa si mai generala numita Throuble !

Pentru a propaga exceptia la apel se foloseste cuvantul throws , exemplu mai jos :

In blocul Catch se accepta si polimorfismele !

Mai jos vezi cum se declara blocul Try impreuna cu Catch si finally

Folosim propagarea exceptiei in vederea decuplarii codului.

Putem avea un singur Try , mai multe Catch-uri , si un singur finally.

MOSTENIREA EXCEPTIILOR:
Regula de mostenire este urmatoare : de la particular la mai general !

Unde Foo il mosteneste pe Baz si Exception este cea mai generala , de aceea este si ultima !
Multy Catch : Apare incepand cu versiun 7 si imi permite sa declar o exceptie in blocul catch
care poate fii de mai multe tipuri , adica isi va lua exceptia din (Myexception ,
AnotherException)

Intrebarile de certificare ar putea sa ma pacaleasca punand mai multi identificatori dupa

MyException de excemplu : MyExeption e1.

REGULA : Nu avem voie sa punem exceptii care se mostenesc una pe cealalta in Multy Catch

REGULA : Metoda care suprascrie trebuie sa aiba un spectru mai ingust de exceptii sau cel
mult egal !

Try Catch cu Resurse :

Necesitatea a venit pentru a eliminat codul redundant

Resursele - > sunt clase care definesc instante cu o initializare si o inchidere , sunt obiecte pe
care le obtinem de la cineva . O resursa o deschidem dar dupa trebuie sa si o inchidem.

Resursa se deschide la construire,

Clasa Resursa va implementa o interfata numita AutoCloseable si va suprascrie metotoda

close.
REGULA 1 : Resursele se inchid in ordinea inversa a declararii

REGULA 2 : finally implicit se exeuta intotdeauna inaintea oricarui catch sau finally explicit

REGULA : Daca se arunca o exceptie la creea resursei , se va executa direct finally implicit ,
dupa care catch – ul care trateaza exceptia care s-a aruncat , dupa care finally explicit.

REGULA : Orice instructiune din try sau la declarearea resursei trebuie tratata daca se
propaga checked exception , sunt acele exceptii pe care trebuie sa le tratam.

Daca se arunca o exceptie ,in blocul try sau la deschiderea resursei si se arunca o exceptie si
pe finally-ul implicit ,exceptia de pe finally implicit este stocata in interiorul instantei
exceptiei din try , intr-un vector de exceptie numit SupresException.

Vectorul Throwable [] --> Vectorul de exceptii ascunse !

Finally implicit se exectuta inaintea oricarui catch sau finally explicit !

Clase Fundamentale din JAVA:

Clasa Math : este o clasa utilitar ce contine metode ce definesc operatii matematice
fundamentale , este FINALA , contine metode statice , NU POATE FII MOSTENITA ,
constructorul este PRIVAT.

Metode :

E -- > Numarul lui Oleir , PI --> care este 3.14

abs --> absolut value , intoarce modulul unui numar.

cbrt --> radical de ordin 3

sqrt --> radical de ordin 2

floor --> aproximare in minus

ceil --> aproximare in adaos

random () --> este singura metoda care nu primeste parametrii , intoarce o valoare de tipul
double , intre valoarea 0 si 1 .

Clasa System : In clasa System exista 3 campuri statice , in , out si err

in --> putem sa citim din terminal

out--> flux de iesire in consola sistemului

err --> este un flux asemanator cu out , doar ca trimitem informatia in logul de error al
sistemului , este folosite pentru a loga errorile.

Metode :
arraycopy() --> copiaza o instanta de array intralta.

object src -- > array-ul sursa , int scrPos --> pozitia de la care incepe copierea

Array-ul poate fii copiat doar daca are acelasi numar de dimensiuni
 console() --> Intoarce o instanta a clasei care se numeste tot console si are rolul dea ne
da posibilatatea sa scriem si sa citim in si out din consola
 ReadPassword -- > ne ajuta sa citim parole din consola , tine de console.
 Intoarce un vector de caractere, nu un sir de caractere.
currentTimeMillis() --> intoarce time step-ul curent sub forma unui long , time step
inseamna nr de milisecunde care s-a scurs de la 1ian1970 , ne ajuta sa logam timpi , cat
a durat o metoda.
exit(int status) -- > este met care o putem apela pentru a inchide procesul curent ,
folosim 0 pentru a inchide. Atunci cand apelam system Exit , finally nu se mai executa.
 Sunt 2 cazuri in care finally nu se executa : cand apela Exit in try si atunci cand se
arunca o eroare nu o exceptie! Finally se executa si dupa return.
gc() --> apelul lui Garbage Collerctor , nu se recomanda apelarea lui gc.

Siruiri de caractere STRING:

Orice STRING este IMMUTABLE , nu mai poate fii modificata odata ce a fost creeata !

Orice pare ca o modifica , nu o modifica si ii creeaza o noua instanta.

O memorie HYP in Java , ascunde o zona de memorie String Pull , are rolul de a eficientiza
stocarea sirurilor de caractere.

StringPull --> atunci cand alocam fara sa folosim un constructor , atunci sirul de caractere va fii
cautat mai intai in stringpull , daca exista deja in stringpull nu va mai fii creat , se va trage o ref
catre acea refinta care exista, DECI StringPull este o zona de memorie in care instantele sunt
unice de siruri de caractere.

Intrebare de certificare : String s1 = “Hello” , String s2 = “new StringHello() ” , String s3= “new
StringHello() ”, String s4 = “Hello”; Cate instante de Hello se creeaza in memorie ? Rasp : 3 ,
Doar cand folosim constructor se aloca in stringpull. S4 si S1 --> creeaza doar 1 instanta ,
pentru ca daca folosim constructor se creeaza instanta de string. Daca se modifica S4 nu se
modifica S1 , pentru ca e IMMUTABLE !
METODE :
charAt() --> intoarce sub forma de char caracterul de la un index dat , un sir de caract este
indexat de la inceput cu valoare 0. Exemplu : HELLOWORLD --> H ESTE 0
compareTo() --> este mostenita dintro interfata comparable. Compara sirurile de caratere
lexigo grafic .Returneaza un boolean , compara S1 cu S2 . Returneaza negativ daca S1 <S2 ,
pozitiv daca S1>S2 , si 0 daca sunt egale. LITERELE MICI SUNT MAI MARI DECAT LITERE MARI.
compareToIgnoreCase() --> comparare 2 siruri considerand litera mica = litera mare.
concat() -- > echivalentul + , va incerca sa dereferentieze dintr-o valoare care este NULL ,
rezultatul va fii NULLPointerException (cand dereferentiem un comportament dintr-o valoare
care este null )
contains() --> returneaza true sau false , daca exista caractere trimis ca parametru.
parseInt() --> tr

! Daca folosim oricare metoda care se refera la indexsi dintr-un sir de caractere furnizand un
index care nu exista , SE VA ARUNCA O EXCEPTIE UNCHECKED (runtime).

trim() --> scoate spatiile de la stanga si de la dreapta dintr-un sir de caractere , nu si din
mijloc.

Operatii de modificare siruri de caractere:

StringBuffer si StringBuilder

Instatele acestor clase nu sunt Immutable !

StringBuffer si cu StringBuilder sunt echivalente functional.

StringBuilder:

METODE:
+ nu merge ca si concatenare intre cele 2. --> Se foloseste append()

detele() -- > sterge un subsir

replace() --> inlocuieste un subsir cu altul
reverse() --> inverseaza sirul de caractere
setCharAt() --> modifica un caracte de la o pozitie
Clasele Wrapper:
Au rolul de a trata tipurile primitive ca obiecte , instantele sunt IMMUTABLE .

byte --> Clasa wrapper Byte

short - > Short

int --> Interger

lng --> Long

float --> Float

double--> Double

char --> Character

boolean --> Boolean

Clasa Interger :

Metode :
Un tip wrapper se va creea atunci cand primeste primitiva ca valoare.

Tpurile Wrapper --> Notiunea boxing si unboxing , declar wrapper

intValues () --- > transforma din interger in int.

valuesOf() --> este o metoda STATICA
parsesInt () --> transforma sirul de caractere in primitava , daca nu poate arunca o
exceptie numita NumberFormatException

Overloading --> pot sa supraincarc daca am aceeasi parametrii , pentru sunt diferite in wrapper.

Stie sa faca doar o conversie , nu mai multe simultan !

Clasa Random : generam valorii aleatoare.

Clasa Scanner : citim valori din consola.

TIPURI GENERICE:
Pot sa nu declar tipul atributului de la declarare , precizam cand facem instanta tipul de data.Ne
dau o flexibilitate mai mare.

T -- > este numele tipului generic , se declara dupa clasa intre < >. Nu conteaza litera , putem
pune orice.
Putem declara atribute, putem declara tipul returnat al comporamentelor , parametrii
constructori , pentru orice tip de data in descrierea prototipului , nu-l putem folosim pentru
STATIC.

Avand in vedere ca tipul generic se precizarea la momentul creearii instantei , insemna ca

putem sa-l folosim doar pentru ceea ce presupune elemen NON-STATIC , orice zona de mem
statica se rezerva in memorie la momentul rularii clasei , nu la creearea instantei !

Putem folsii tipuri generice pentru metode statice doar daca declaram inainte tipului metodei ,
dupa cum urmeaza :

Tipul generic are o valoare implicita --- > OBJECT !

Pentru instantiere nu se pot folosii tipuri primitive , deoarece object aici nu le include , insa se
poate folosii clase Wrapper , adica Interger. ---> Exemplu : new A<Integer>();

DECLARAREA TIPURILOR DE DATA CU GENERICE:

A<?> a1; ---> Asa se foloseste in practica , pentru a se vedea ca acel tip de data este un tip
generic !

? -- > inseamna absenta oricarei constrangeri , in a1 se poate afla orice instanta de a

indiferent de tipul generic pe care il are, el accepta orice.

A<Integer> a2; --> Este cea mai restrictiva , permite doar Interger ! Indiferent daca se
mosteneste o clasa pe alta , restrictia tipul de data tot se pastreaza.
A<? extends Numeber>a4; --> Este restrictia pentru folosirea explictita doar pentru Number
sau orice mosteneste pe Number.

A<? super Integer>a5; --> este explicit Integer sau orice este superior lui Integer , cum ar fi
Objet.

REGULA : Clasa impreuna cu tipul ei generic , formeaza un alt tip referinta !

COLECTII :
Interfete care specifica tipurile fundamentale de colectii, toata sunt in java.util

Liste --> rep de interfata List cu un tip generic

Seturi --> rep de interfata Set cu un tip generic

Que --> rep de interfata q cu un tip generic

map -- >interfata map cu 2 tipuri generice.

Pentru Liste , seturi si q avem o interfata superioara collection. cu tipul generic E

Clasa ArrayList , linkeList mosteneste si pe QUE

LinkedList mosteneste interfata LIST si interfata QUE

q -- >deq interfata mostenita de ArrayDeq

map -- > HashMap,LinkedHashMap , Treemap

DEFINITIE : O colectie este o grupare de elemente ce respecta un set de reguli comune , dat
de tipul colectiei.

 Listele sunt colectii ce permit existenta duplicatelor ,intr-o lista putem avea demai multe
ori acelasi element , se folosete equals pentru a testa egalitatea.

ArrayList --> Se respecta aceleasi reguli ca la array-uri , ESTE INDEXATA , INCEP DE

LAVALOAREA 0.

Pentru obtinerea dimensiunii array-ului se va apela comportamentul size al acesteia. --->

list.size();
Comportamentul list.isEmpty -- > returneaza true atunci cand Size este 0.
Comportamentul list.get(3) -- > luam un element de pe pozita 3.
list.add() --> folosim comportamentul add pentru adaugarea elementelor in lista

Sintaxa de parcurgere a unei liste si de afisare.

(e -> System.out.println(e)); este un consumer. este o interfata cu o metoda, care primeste un

obiect si nu intoarce nimic .

Pachetul function --> import java.util.function.*; Are 3 interfete : Consumer , Predicate ,

ByConsumer.

In interfata Collection exista 2 metode collection.remove(2) care primeste ca parametru

elementul , cauta prima aparitie a elementului in colectie si o elimina , doar pe prima.

Insa List este interfata care o mosteneste pe collection , aici remove va elimina elementul care
se afla pe pozitia din lista , adica : list.remove(2); --> va elimina elementul de pe pozitia a 3.

list.remove(2); --> va elimina elementul de pe pozitia a 3.

list.remove(new Integer(2)); --> este supraincarcare si se refara la primul caz al lui remove cand
elimina primul element din lista, primul 2 care apare in lista.
Nu se pot adauga elemente sau da valori , atunci cand tipul generic este cu ? sau
extends,daca pune super in loc de extends va merge , pentru ca este superios si garanteaza.

list.stream() -- > este metoda care transforma o lista intr-un stream , permite
parcurgearea unor valori , dupa o regula sau fixe. Mai jos forEach este operatie
terminala !

e -> e % 2 == 0 ---> este un Predicate din java.util.function , primeste o valoare si intoarce

adevarat sau false, si foloseste un tip generic.

Mai sus se parcurge lista,transformo intr-un stream , dupa care se filtreaza doar elementele
care sunt pare. Cand restul impartiri la 2 este 0 , si pentru fiecare in parte afiseaza-le in consola
pe o linie separata.

Asta e pentru OCP :

LinkedList --> Are o stiva si o coada

Stiva -- > privim pe verticala , fiecare element este pus deasupra , eliminam doar ultimul , last
in first out

Coada --> first in – first out , adaug la sfarsit .

list.addLast() -- > pune elem la sfarsitul listei , list.addFirst() -- > la inceput ,list.removeFirst() --
> elimina pe primul , list.removeLast() -- > elimina pe ultimul
Clasa ArrayDeqeu inlocuieste functionalitatea lui LikendList , find considerata mai rapida.

deq.push --> insereaza un element la inceputul colectiei , sau in stiva colectiei.

deq.offer -- > adauga la coada colectiei

deq.peek --> ia primul element din stiva

deq.poll -> elimina primul element , il returneaza , iar daca nu exista --> returneaza NULL;

deq.pop -- > acelasi lucru cu poll , arunca o exceptie.

SETURI:
Sunt colectii asemanatoare listelor , dar care nu admit existenta duplicatelor , sunt colectii
neindexate , sunt folosite pentru a elimina duplicatele.

HashSet - >pentru ca foloseste hashcode() , este o colectie neordonata si nesortata. ESTE CEA
MAI RAPIDA LA CAUTARI.

LikedHashSet - > ordonat si nesortat , pastreaza ordinea in care adaugam elementele.

TreeSet - > ordonat si sortat in ordine crescatoare.

Compararea instantelor , sa presupunem ca avem 4 instante de pisica , si vrem sa le adaugam

intr-o colectie, pentru a le sorata trebuie sa le comparam mai intai .

 Interfata Comparable --> primeste tipul generic , de exemplu pisica in cazul nostru si are
o metoda -- > compareTo() , trebuie sa returneze o valoare negativa in cazul in care this
este parametru , sa returneze 0 in cazul in care this si parametru sunt egale () , mai mare
decat 0 daca this este mai mare decat parametru. Comparable cu compareTo() cu un
parametru. public int compareTo()
  Interfata Comparater -- > metode compare(), compara 2 parametrii intre ei, este facut
sa functioneze din afara clasei. Comparator cu compare () cu doi parametrii,
public int compare()

MAP:
Este o colectie de asocieri cheie valoare,pentru care cheile sunt intotdeauna unice.

map.put() – asociaza o cheie data cu o valoare

Pentru forEach (k,v) ---> este un BiConsumer !

Pachetul java.time avem 3 clase:

LocalDate ,

LocalTime,

LocalDateTime

LocalDate -- > este o clasa ale carei instante se refera strict la data, adica 10august2016

LocalTime --> este folosita cand ne referim la timp , ora minut secunda.

LocalDateTime --> si timp si data

METODE :

now() -- > este o metoda statica , obtinem momentul curent.

of() -- > este o metoda statica , primeste ca parametru sub forma de int , lunile si zilele
incep cu valoare 1. NU EXISTA UN CONSTRUCTOR PUBLIC .

LocalDateTime :

of(LocalDate , LocalTime )

FIRE DE EXECUTIE:
Este un set de instructiuni care se executa individual si independent de alte seturi de
instructiuni din aplicatie.

O aplicatie cu un singur fir de executie se numeste single threaded.

O aplicatie cu mai multe fire de executie se numeste multy threaded.

Firul principal de executie se numeste main.

Clasa thread este cea care implementeaza mecanismul firelor de executie , orice instanta a
clasei thread este considerata un fir de executie, cu ajutorul acesteaia putem sa pornim un
set de instr care este independent de alte seturi de instructiuni din aplicatie.

Exista 2 modalitati de creearea unui fir de executie:

1. Fie am o clasa care mosteneste clasa thread , nu este abstracta ! Poate fii mostenita.
2. Folosirea interfetei runable , este interfata functionala(are o singura metodata
abstracta).

OddNumberThread -- > pentru numere impar.

Metoda principala a unui fir de executie este metoda run().

Firul de executie nu va pornii atunci cand ii creez instanta , ci dupa ce apelez comportamentul
start().

run() ---> este metoda principala a firului de executie cea pe care o suprascriem cea care
contine instructiunile care trebuiesc executate de firul de executie.
start() ---> este comportamentul oricarui fir de executie cu care pornim firul de executie , pe
start nu o vom suprascrie niciodata.

Se numeste starea Runnable , cea care firul de executie poate fii pus in executie de catre masina
virtuala.

Dupa ce se terminat executia firului de executie acesta trece in stagiu Dead, sirul nu mai poate
fii repornim din nou , vom primii o exceptie. Creem o noua instanta si o pornim pe aceea.

Stagiu block – firul de executie poate fii blocat , masina virtuala nu-l mai pune in running.Putem
sa il blocam pe o perioada determinata sau nedeterminata !

Nu putem intrerupe sau oprii un fir atunci cand el se afla in block , se arunca o exceptie check
numita InterruptedException

Ca sa punem in Blocked un fir de executie , folosim din clasa Thread metoda statica sleep().

SINCRONIZAREA FIRELOR DE EXECUTIE:

Join () -- > blocarea firului de executie pe perioada nedeterminata , este si metoda principala de
sincronizare , el poate sa faca firul curent de executie sa astepte pana cand un altul se termina.

Este un comportament.

Prin sincronizare putem specifica accesul catre un anumit bloc de instructiuni controlat.

Modificatorul Syncronize , Il folosim in 2 moduri : definind un bloc sincronizat sau direct pe

metoda.

Intre parantezele rontunde la synchronized se va pune un monitor