Java Lexicon

Java Software Development I exam 1Z0-803 si 804
Java termeni esentiali 

Teodor Iancu, 2015 version. 0.4


CLASS ACCESS CONTROLS
Class Access Modifiers

- Classes au doi access modifiers: public, si
default (default este control level) ( private si protected se aplica numai membrilor unei clase)
- Clasele si Interfatele NU pot fi private s-au protected (cu exceptia inner Class)
- Classes au un access level: default (package acces)
- O classa cu default acces este vizibila numai de clasesele din acelasi packet

Class Nonacces modifiers
- final, abstract, si strictfp

- O classa final NU poate fi mostenita
- O classa NU poate fi si final si absttract in acelasi timp

Abstract Class
- Methodele abstracte ale unei clase abstracte (si a interfatelelor) NU au corp si se termina cu ;
- O clasa abstracta este o clasa generalizanta si simplificata
- NU poate fi instantiata (nu se pot obtine obiecte direct ci numai din subclasse)
- poate avea atat methode abstracte cat si neabstracte
- o singura methoda "abstract" intr-o classa, face ca intreaga classa sa devina abstracta
- Prima classa concreta care extinde o classa abstracta trebuie sa implementeze toate methodele abstracte ale acesteia. (numai overridden NU si overloaded ?)
- O classa abstracta poate sa extends o clasa normala
- Subclasses of an abstract class must implement (override) all abstract methods of its abstract superclass.
The non-abstract methods of the superclass are just inherited as they are. They can also be overridden, if needed.
- Abstract methods are methods in the abstract class (have to be declared abstract) which means the extending concrete class must override them as they have no body.

  1. Define methods which can be used by the inheriting subclass.
  2. Define abstract methods which the inheriting subclass must implement.
  3. Provide a common interface which allows the subclass to be interchanged with all other subclasses.

 


  Interfaces


- Interfaces sant contracte despre ceea ce poate face o classa, dar NU spune nimic despre modul in care urmeaza sa o faca
- O interface poate fi default sau public (daca este public trebuie ca numele fisierului sa fie identic cu numele interfatei)
- Methodele interfatelelor (si metodele abstracte ale claselor abstracte) NU au corp si se termina cu ;
- Interfaces pot fi implementate de orce classa in orcare ierarhie (arbore) de mostenire
- Interfatele sant 100% classe abstracte (indiferent daca foloseste modificatorul abstract s-au nu)
- Interfaces extend una s-au mai multe interfete IEI 
- Interfaces NU pot extend classe INEC

- Interfaces NU pot implements nimic (interfate sau class) ININ
- Eine Klasse muß alle Interface Methoden implementieren (oder selbst abstract sein)
- Interfaces pot avea NUMAI methode abstracte (neconcrete)
- Methodele Interfatelor sant implicite public si abstract (declarearea este optionala)
- Methodele Interfatelor trebuiesc sa NU fie static, final, private s-au protected
- Pt ca mehtodele interfatelor sant abstract NU pot fi final, strictfp s-au native
- Constantele interfatelor sant obligatoriu public static si final (declarearea si ordinea este optionala) putem spune ca Interfaces pot declara numai Constante (nu si instanz variabile)
- O clasa abstracta poate implementa o interfata
- O clasa abstracta NU trebuie sa implementeze methodele interfatei (dar prima subclasa concreta trebuie)
- Interfaces pot extend una s-au mai multe interfate
- Interfaces NU pot  extend o classa
java-kurs
- Interfaces NU pot implementa classe s-au interfete
- Interfaces NU au constructori si NU pot fi instantiate. Dar Interface = new ClassCareA_ImplementatAceaInterfata este ok.(acel obiect este de typ interfata)

 

 

Modifiers in Java

element Data field Method Constructor Class Interface
modifier top level
(outer)
nested
(inner)
top level
(outer)
nested
(inner)
abstract no yes no yes yes yes yes
final yes yes no yes yes no no
native no yes no no no no no
private yes yes yes no yes no yes
protected yes yes yes no yes no yes
public yes yes yes yes yes yes yes
static yes yes no no yes no yes
synchronized no yes no no no no no
transient yes no no no no no no
volatile yes no no no no no no
strictfp no yes no yes yes yes yes

 

Local Variables
Instantz Variables
Methods
final
final
final
public
public
protected
protected
private
private
static
static
transient
abstract
volatile
syncronised
strictfp
native


Access Protection Modifiers in Java (Visibility)

 
class \ have access to private
elements
default
elements
(no modifier)
protected
elements
public
elements
own class yes yes yes yes
subclass - same package no yes yes yes
class - same package no yes yes yes
subclass - another package no no inheritance yes
class - another package no no no yes

Access modifiers:
public, protected,default, private

Nonacces modifiers:
final, abstract; strictfp(force floating points)

Local Variabiles Modifiers
Access modifiers NU se aplica niciodata la local variabile - de fapt la local variable NU se aplica niciodata un modificator cu o singura exceptie: final
o singura exceptie: final
NU au valori default asa ca trebuiesc initializate inainte de a fi folosite

Members Access  Modifiers
- Methodele si instance variables sant cunoscute ca "members"
- Members pot folosi toate cele patru acces levels: public, protrected, default si private
- Accesul members se face in doua forme:
    - Codul dintr-o clasa poate accesa membri altor classe
    - O subclass-a poate mosteni membri superclass-ei sale
- Daca o clasa NU poate fi accesata nici membri ei NU pot fi accesati
- Vizibilitatea clasei trebuie clarificata inainte de vizibilitatea membrilor
- public members pot fi accesati de toate classele chiar si din alte pakete
- Daca un membru ale unei superclasse este public, subclassele sale or sa le mosteneasca, indiferent in ce pakete se afla
- Accesarea membrilor fara "dot operator" se poate face numai daca se afla in acceasi classa
- this. se refera mereu la obiectul care ruleaza actual
- this.oMethoda() este sinonim cu invocarea metodei oMethoda()
- private members se pot accesa numai de codul din acceasi clasa
- private members NU sant vizibili in afara de propria classe (asa ca private members NU se pot mosteni)
- private methods are not inherited at all so there is no question of overriding a private method.
- private methods NU pot fi suprascrise

- default si protected members difera numai daca sant implicate subclasele
        - default members pot fi accesati numai de clasele si interfatele din acelasi paket
       - Daca o clasa aflata in acelasi paket cu subclasa instantiaza subclasa, NU are acces la membri protected mosteniti de aceasta subclasa (cu exceptia subclaselor subclaselor) ??
       - protected members pot fi accesati de toate clasele din accelasi paket, PLUS in subclase (adinca prin extends) indiferent de paket.
       - protected:   -. package, identic cu default
                                si / sau
                             -. alte pakete + kids (extends)


Other Modifiers-Members
- final - Methodele final NU pot fi suprascrise in subclase
- Methodele abstract sant declarate cu o semnatura, tip de returnare, optional clauze throw, dar NU sant implementate (nu contin cod functional )
   se fol. pt a forta o subclassa sa le implementeze (datorit methodei abstracte clasa respectiva devine si ea abstracta )
- Methodele abstract se termina cu ; (fara acolade{})
- O methoda NU este abstracta daca:
        - NU este declarata "abstract"
        - are paranteze
        - POATE (dar NU trebuie) sa aiba cod intre paranteze
- Prima clasa concreta care extinde o clasa abstracta trebuie sa implementeze toate methodele abstracte ale acelei clase abstracte
- Clasele abstracte NU trebuie sa implementeze methodele abstracte din superclassa abstracta implementata DAR prima clasa concreta trebuie sa implementeze TOATE methodele abstracte din TOATE clasele abstracte mosteite
-abstract - Methodele abstract trebuiesc fi implementate de subclasse, asa ca trebuiesc fi mostenibile, din acest motiv:
        - java-kurs methodele abstracte NU pot fi private
        - methodele abstracte NU pot fi final
Synchronized Methods
- indica faptul ca acesta metoda poate fi accesata doar de un un singur thread de-o-data
- Modificatorul synchronized se aplica numai la methode si "code blocks"
- Modificatorul synchronized poate folosi oricare controlor de acces si poate fi marcat si final
- native - este un modifier si se aplica numai la methode si se termina cu (); Modificatorul native se poate aplica numai la methode
   implementeaza cod nativ (ex C) java-kurs
- strictfp - Modificatorul  strictfp poate fi aplicat numai pt. classe si methode

- Denumirea parametrul unei methode NU poaate fi la fel cu denumirea unei local variabile (method variable)
- Class variable(static) si instanz variable NU pot avea acelasi nume

 

Variable Declarations
- Instant variabilile pot
        - avea orice controlor de acces
        -  pot fi marcate ca fiind final s-au transient
- Instant variabilile NU pot fi: abstract, synchronized, native, or strichtfp
- Este legal ca numele unei "local variable" sa fie indentica cu o "instant variable" (aceasta se numeste "shadowing")
- final variables pot avea urmatoarele proprietati:
        - final variables NU pot primi alte valori dupace a fost declarata
        - final reference variables NU poate sa se refere la un alt obiect dupa ce a fost declarat final
        - final variables trebuiesc fi initializate inainte de executarea constructorului
- NU exixta object final, un object refence marcat ca fiind final NU inseamna ca acel obiect NU poate fi schimbat
- transient si volatile modifiers se aplica numai la instanz variable



 


Polymorphism (overriden si overloaden)
Polimorfismul se aplica numai la instanz metoden nu si la instant variable
(because at runtime method of subclass will be called but the member of parent is printed) Because instance variables CANNOT be overridden in Java. In Java only methods can be overridden

  1. Static binding happens at compile-time while dynamic binding happens at runtime.
  2. Binding of private, static and final methods always happen at compile time since these methods cannot be overridden. Binding of overridden methods happen at runtime.
  3. Java uses static binding for and dynamic binding for overridden methods.


- Tipul obiectului (nu tipul referenz variabile ) determina ce mehtoda overriddev va fi folosita la Runtime // Runtime
- Tipul referenz variabilei (nu tipul obiectului) determina ce mehtoda overloadet va fi folosita la Compilertime // Compilertime
Deci Compilerul vede numai Referenztype si JVM (Runtime) se vede numai Objecttyp

PiesaDeSah  pds = new Turn();  
PiesaDeSah este Referenztyp si Turn este Objekttyp
Compilerul vede numai Referenztyp (nu si Objekttyp)

in superclasa PiesaDeSah se afla metoda mutaPiesa()
PiesaDeSah  pds = new Turn(a5);  
String s = pds.mutaPiesa(
);

daca avem metoda mutariPosibile(); atunci putem da ca parametu o figura de sah
mutariPosibile(pds);

Intersamt este ca prin conceptul de Polimorfie, abia la executia progamului (run time) se poate vedea care varianta carei metode se apeleaza (a turnului , a pionului , etc)
Compilatouruli nu poate decide deoarece el vede numai parametrul pds al metodei mutariPosibile este de tip PiesaDeSah

Deci Compilerul vede numai Referenztype si JVM (Runtime) se vede numai Objecttyp

. ____

La declararea unui parametru de tip superclasa, (ex  mutaPiesa(PiesaDeSah p )), Obiectvariabilile au acces numai la membri care sant definiti superclassa (PiesaDeSah) nu si la aceia din obiectul concret (de ex nebun)

Encapsulation
- instant variabilile sint protejate prin "private" implementarea numai prin geter si seter


Inhertitance
IS-A
se refera la mostenire(extends) s-au implementare(implements) O masina ESTE-UN vehicol, Dacia este o masina (asadar o dacie este o masina si deci este si un vehicol)
HAS-A inseamna ca instanta unei clase "has a" referenta la o instanza(obiect) a unei altei clase s-au alta instanta ale aceleiasi classe. (ex void mutPiesaDeSah(PiesaDeSah piesa) unde variabila piesa este o piesa de sah concreta ( class Pion, Nebun etc,))
intr-o relatie HAS-A
, un obiect contine ca si membru o referint la un alt obiect (HAS-A se mai numeste si compositon)
Inhertitance este un concept de baza a IS-A, Polimorphism, overriding, overloading si casting.

Objects
- obiejectele (inkl. instanz variables) traiesc ins Heap

Overriding (supradefinirea)

- Definition - Method overriding means having two methods with the same arguments, but different implementation. One of them would exist in the Parent class (Base Class) while another will be in the derived class(Child Class).

- Method overriding is the example of run time polymorphism.
- Method overloading is the example of compile time polymorphism.


Pt a supradefini o metoda, metoda trebie sa fie definita in subclasa folosind aceasi semnatura si acelasi return type ca in superclass
Metodele pot fi overiden numai in subclase (Regula de overriding se aplica numai intre clasele care au legaturi prin de mostenire (extends) )

- Methodele pt a fi overriding trebuie sa indeplineasca urmatoarele conditii:
        - trebuie sa aiba acelasi semnatura
        - acelasi return typ (cu exceptia "covariant typ = unde return typ poate fi o subclasa")
        - NU trebuie sa aiba accesori de modificare mai restrictivi (dar mai lejeri da) decat metoda ce urmeaza a fi overriden 
        - Methodele care sant markate ca fiind static sau final sau private nu pot fi overrriden

- O subclassa foloseste super.overridenMethod() pt. a folosi versiunea mehodei din superclassa
      
Uneori o metoda poate fi si Overrided si Overloaded in aceasi subclasa (nu una si aceasi metoda ci o data asa si o data asa in acesi clasa)

- Polimorphismul se aplica numai la overriding nu si la overloading

- Pt a implementa polimorfismul cu classe, putem defini metode abstracte sau non-abstracte in superclass si le ovverriden in subclasse

- in overriding methods este permisa schimbarea return type atata timp cat noul typ este un subtype declarat la return in superclass(p. 123)

Exceptions
Reguli pt. Methoden overriding:

o methoda care redefineste o oalta metoda @Override trebuie sa aiba:
- aceasi semnatura
- aceasi sau kovariante rückgabe Typ (ist ein beziehung)
MUSS sa throw urmatoarele Exceptions
Gleiche Weniger/keine oder Engere (mai exacte) Checked Exceptions werfen
KANN jegliche "Unchecked Exceptions" werfen


Overloading

(semnaturi diferite si/s-au corp diferit) (Overloading methods sant de fapt metode total diferite care folosesc acelasi nume)
Overloading inseamna sa definesti mai multe metode cu acelasi nume dar cu semnaturi diferite (si optional cu return type diferit (dar numai in combinatie cu o semnatura diferita))
Reutilizarea a aceasi nume de metoda dar cu argumente(parametri) diferiti

- Methodele pt a putea fi overload-e trebuie sa indeplineasca urmatoarele conditii:
        - arguments list trebuie sa fie diferit
        - Poate avea return typ diferit (- in overriding methods este permis sa schimban return type numai atata timp cat noul typ este un subtype declarat la return in superclass(p. 123) )
        - Poate avea acces moodifiers diferit
        - Poate "throw" exceptii diferite

- Metodele overloaded pot fi ori in aceasi clasa ori in clase diferite care au legaturi prin mostenire (extends)
- Polimorphism se aplica la overriding nu si la overloading

- Obiect Type determina ce mehtoda overridden va fi folosita la Runtime
- Referenz Type variabilei (nu tipul obiectului) determina ce mehtoda overloadet va fi folosita la Compilertime
  Deci Compilerul vede numai Referenztype si JVM (Runtime) se vede numai Objecttyp

- Constructori pot fi numai overloaded

referce type (nu Object type) determina care metoda va fi invocata pt a fi suprascrisa

overriden   ===  Obiect type   == Runtime
overloaded ===  Refence type == Compilertime

Uneori o metoda poate fi si Overrided si Overloaded in aceasi subclasa (nu una si aceasi metoda ci o data asa si o data asa in acesi clasa)

Daca schimbi return type trebuie schimbat si parametri


 


IDENTIFIERS

- Pot incepe cu o litera, cu underscore _  sau cu (currecy character €,$, etc (pt cod generat automat))
- Liniuta de unire "-" nu este posibil
- Dupa primul caracter poate contine si cifre
- Clasele trebuie sa inceapa cu o litera mare si sa fie substantive (nouns) de ex.Account, PrintWriter
- Interfaces au nume de adjective (ex: Runnable)
- Methodele au nume combinat de substantiv si verb (ex. getBalance, doCalculation )
- Variabilele au nume scurt si descriptiv in CamelCase (buttonWidth)
- Constantele sant scrise cu litera mare separate de _ si sant static si final (MAX_VALUE)

 


Return Types

- Methodele overloaded pot sa isi schimbe return type (Methodele suprascrise NU (cu excepria covariantei)
- Obicects reference return type poate accepta "null" ca return value
- array este un return type legal (si ca declarare si si ca return type)
- Methods care au ca return un type un object refernz, pot returna un subtype
- Methods care au ca return type o interfata, pot returna "any implementer"

  == compara Strings reference pe cand methoda equals() compara valuarea in sine
  == return true numai daca ambele referentz var se refera la acelasi obiect.
  == la Primitive compara valoarea Variables (5==5) // true (5==9)// false
Compararea Stringului in sine se face cu methoda equals()


String a = "hallo";  
String b = "hallo";                                   // in acest caz String este "refolosit" din lista de stringuri de aceea nu se mai creeaza incaun String in heap
System.out.print(a == b);                       // true
System.out.print(a.equals(b));             // true
(contain the same characters))

String a = new String("hallo");
String b = new String("hallo");              //   datorita opratorului new "hallo" este un nou obiect in heap
System.out.print(a == b);                        // false
System.out.print(a.equals(b));              // true
(contain the same characters))

Book a = new Book("hallo");
Book b = new Book("hallo");
System.out.println(a == b);                  // false
System.out.println(a.equals(b));
         // false   // la acest obiect avem un constuctor care cere un string,  Dar comparatia se face intre cele doua obiecte nu a stingului primit //Without overriding it we always get false for two different objects.


 


Constructors
this()
este intodeauna un call la un alt constructor din aceasi clasa
- super()
este un call la constructorul din superclass
- Prima linie intr-un constructor trbuie sa fie un call la super() s-au un call la this() (daca nu il adaugam manual, super() este adaugat automat de compiler) (dar nico-o data super si this impreuna)
- Chiar si classele abstracte au un constructor
- Constructorii trebuiesc sa aiba acelasi nume cu classa
- Constructorii NU au return type (daca vezi in cod asa ceva, este vorba despre o methoda care are acelasi nume cu classa)
- Constructori pot folosi oricare acces modifiers (default si inkl. private)
- Constructori NU pot fi: static, final s-au abstract
- Instanz members sint accesibili numai dupa executia super constructor java-kurs
- Clasele abstracte au constructori care se executa cand se initializeaza o subclasa concreta
- Interfaces NU au constructori
- Default Constructor nu are nici o data argumente (no-args)
- Default Constructor are acelasi acces modifiers ca si classa
- Default Constructor  are un no-arg call la super constructor super() superclasei si este adugat automat si mereu
- Daca folosesti un constructor cu args si ai nevoie de construcltorul default. trebuie scris manual
- Daca un constructor in superclass are argumente atunci constructorul din subclass este obligat sa foloseasca acele argumente in constructorul sau prin super(acele argumente) Daca superclassa nu are decat    
   constructorul cu argumente atunci sin subclass esti obligat sa declari manual un constructor unde sa adaugi argumentele necesare

- Constructori NU pot fi mosteniti (de accea NU se pot suprascrie)
- Un Constructor NU poate fi invocat direct decat de un alt constructor (prin super() sau this())         
-  in cazul this()
        - trebuie sa apara primul in statmentul  constructor
        - this() si super() NU pot aparea in acelasi constructor (numai daca folosesc parametri)???

A constructor can access the non-static members of a class.
(A constructor is non-static, and so it can access directly both the static and non-static members of the class.) 
Numai variabilele si metodele statice pot fi accesate prin super() si this(). (ex: super(Animal.NAME) unde NAME este declarat static

Constructorii pot fi numai overloaded


 


Casting


Referenz variable Castting
- au doua tipuri Downcasting si Upcasting


O referenz variable (printer) a unei superclasse Printer nu poate accesa variabile si metode definite in subclassa LaserPrinter
  fara un casting explicit:
Printer printer = new LaserPrinter();
sysout ((LaserPrinter)printer).unIntegerdinClassaLaserPrinter

 


Initialization Blocks
{ }
Instance itialization blocks are useful if you want to have some code run regardless of which constructor is used or if you want to do some instance initialization for anonymous classes.
ideea  lui este de a folosi un cod intr-o classa care sa fie impartit de toti constructori
- static {bla bal }se foloseste pt cand vrei ca acel cod sa fie executat numai o data la incarcarea classei
- fara nimic {bla bla } se executa la fiecare noua instanta imediat dupa ce superconstructorul a fost executat
- variabilile din bloc sant local variable
- ordinea lor conteaza (sant executate de sus in jos in ordinea care apare)

Ordinea de executare a unei clase:

     0. Prima data tot e este in main() inainte de creerea unui obiect

  1. static initialization blocks of super classes

  2. static initialization blocks of the class

  3. instance initialization blocks of super classes

  4. constructors of super classes

  5. instance initialization blocks of the class

  6. constructor of the class.

  7. 0. Restul de cod din main() dupa creerea obiectelor



 


Static Variable Methods
(static este un modifier)

- Methodele si variabilele statice NU sant legate la nici o instanta particulara a unei classe (independente de obiecte)
- Pt accesarea unui membru static al unei clase, NU este nevoie de instantarea acelei clase
- Exixta numai o singura copie a unei variabile statice si toate instantele impart aceasi copie
- methodele statice NU au acces direct la membri nonstatici
- O metohoda statica NU poate accesa instanz variabile (non statice) direct, pt a fi accesate trebuie folosit .dot operator.
- Singura forma de a accesa o metoda statica sau o variabila statica direct, este prin folosirea operatorului . dot in numele clasei (ex:  Frog.frogCount unde Frog este classa si frogCount este o variabila statica)
- Membri NonStatici au acces la membri static dar Static NU are acces la nonStatic
- static method cannot be overridden by a non-static method and vice versa
- NU poate folosi this (apartine unui anumit obiect)

- Metodele statice au comportament unic in toate instantele
- static variable au o singura copie a valori in toate instantele
- toti membri statici apartin clasei NU a vreunei instante
- methodele statice NU pot fi suprascrise (dar pot fi redefinite)

- Static- atributele statice mai sant numite si "class fields" s-au "class methodos" pt ca apartin classei si NU a unei instante.


 


Array

- Arrays pot primi primitve s-au obiecte, dar un array in sine este mereu el insusi un obiect
- Un Array este un obiect
- Elementele unui array de objecte NU sant create automat pe cand primitvele primesc valori default
- Un array de obiecte poate stoca orice obiect care trece testul IS-A (s-au instanceof()) al tipului de obiect declarat (ex. daca Pisica extends Animale atunci un obiect "Pisica" pote intra intrun array Animale)
- Ultimul element dintr-un array se acceseaza cu ajutorul lui length -1
- o variabila byte poate fi acceptata intr-un array de int

- un array de interfete este ok

Passing Arrays to methods
- When passing an array to a method, the reference of the array is passed to the method

char[] myPopulatedArray = {'a', 'b', 'c', 'd', 'e'};
length = 1 2 3 4 5 // .length is 5
index = 0 1 2 3 4 // index (zero basiert) 

int length = myPopulatedArray.length; // is 5
int lastIndex = myPopulatedArray.length - 1; // is 4
char lastItem = myPopulatedArray[myPopulatedArray.length -1]; // is 'e'


Two-dimensional array

String[][] data = new String [9][200]; (array-ul (obiectul) "data" are 9 arays, a cate 200 de elemente fiecare)
System.out.println(data.length); // 9
System.out.println(data[0].length +" "+ data[1].length +" "+ data[8].length)
; //200 200 200

String[][] data = new String[9][200];
System.out.println(data.length -1); // 8
System.out.println(data[0].length -1); //199

ArrayLists
- este un "resizable array"
- poate primi numai objeke NU si primive (wrapper lasa numai impresia de primitive)
- pot contine "entries" duplicate
ArrayLists Methods
ad(element) adauga elementul la sfarsitul arraylistului
ad(index, element)
adauga elementul la index (zero base) si impinge lista de acolo la index +1
clear();
sterge tot
remove(index) sterge elementul de la index
remove(Object) sterge primul Obiect
boolean contains(element); // return true s-au false
size()  // return nr de elemente in arrayList. // Array are atributul length iar ArrayLists are metoda size()
Object get(index) return obiectul de la index
int indexOf(Object) . return int locatiei obiectului, sau -1 daxa objectul nu a fost gasit


 


Initialization Blocks
{ }
- static {bla bal }se foloseste pt cand vrei ca acel cod sa fie executat numai o data la incarcarea classei
- fara nimic {bla bla } se executa la fiecare noua instanta imediat dupa ce superconstructorul a fost executat
- variabilile din bloc sant local variable

 


Stack si Heap

- Local variables (methods variables) traiesc in STACK
- Obiectele si instant variabilile traiesc in HEAP

 


instanceof
este folosit numai pt objectreference variable ( daca trece testul IS-A test este true)
Verifica daca este un obiect de (nu daca este un tip de)
daca o interfata a fost implementata de o superclasa atunci toate subclasele sant instanceof si ale interfetei respective
se poate folosi numai in aceasi class ierarhie

 


String


- Orice caracter intr-un strings este un 16 bit Unicode character
- Daca intr-o expresie avem un String si un nr atunci operatorul + este considerat ca fiind concatenator ("2" + 3             // rezultatul este: 23)
- Dar daca in expresie este o operatie System.out.println(x/y + "asdfgsdfga" + z/y);

  == compara Strings reference pe cand methoda equals() compara valuarea in sine
  == return true numai daca ambele referentz var se refera la acelasi obiect.
  == la Primitive compara valoarea Variables (5==5) // true (5==9)// false
Compararea Stringului in sine se face cu methoda equals()


String a = "hallo";
String b = "hallo"; // in acest caz String este "refolosit" din lista de stringuri de aceea nu se mai creeaza incaun String in heap 
System.out.print(a == b); // true
System.out.print(a.equals(b)); // true (contain the same characters)) 

String a = new String("hallo");
String b = new String("hallo"); //	datorita opratorului new "hallo" este un nou obiect in heap 
System.out.print(a == b); // false
System.out.print(a.equals(b)); // true (contain the same characters)) 

Book a = new Book("hallo");
Book b = new Book("hallo");
System.out.println(a == b); // false
System.out.println(a.equals(b)); // false // la acest obiect avem un constuctor care cere un string, Dar comparatia se face intre cele doua obiecte nu a stingului primit //Without overriding it we always get false for two different objects.



- String este un obiect
- String este imutabila dar string referent variable NU sant
- String are o methoda java-kurs pe nume lengh() -- arrays au un atribut pe nume .length (A-A)
- String, StringBuilder, si StringBuffer au exact aceleasi metode dar StringBuilder este mai rapid pt ca metodele sale nu sant sincronizate.
- String, StringBuilder, and StringBuffer - all are final classes.

String methoden:
public char charAt(int index )
public String concat(String s)
public boolean equalsIgnoreCase(String s)
public int length()
  // Atentie la Array este un atribut pe nume length
public String replace()
public String substring(int begin) //
return un substring de la begin pana la sfarsitul stringului, int begin este ZERO Base. Ex: substring(int beginIndex) // "unhappy".substring(2) returns "happy"
public String substring(int begin, int end)
return un substring de la begin pana la end. int begin este ZERO Base dar int end NU este ZERO Base. Ex
String x = "fred"; sysout(x.substring(1,3));          // re
public String toLowerCase()
public String toString()
public String trim()
//indeparteaza spatiile libere de la inceputul si sfarsitul stringului

StringBuilder

- String, StringBuilder, si StringBuffer au exact aceleasi metode dar StringBuilder este mai rapid pt ca metodele sale nu sant sincronizate.
- String, StringBuilder, and StringBuffer - all are final classes.
StringBuilder methoden:

public StringBuilder append(String s)
public StringBuilder delete(int start, int end)
int begin este ZERO Base dar int end NU este ZERO Base Ex: StringBuilder sb = new StringBuilder("0123456789");          sb.delete(4,6)           // output 01236789
public StringBuilder insert(int offset, String s) Ex: StringBuilder sb = new StringBuilder("01234567");          sb.insert(4, "---")           // output 0123---4567
public StringBuilder reverse() // inverseaza


 


Exceptions

Exception handling face posibil ca o metoda sa "throw" (arunce) o exceptie la apelantul sau (its caller)
Exceptions apar in timpul executari unei metode.

throw  new Exception
(inseamna ca exceptia este declansata (aruncata) si urmeaza a fi prinsa undeva in ierharhie)

Exceptions sant de doua tipuri: checked si uncheked
Cheked exceptions
includ toate subtipurile Exceptions cu exceptia claselor care extínd RuntimeExceptions si Error
Cheked exceptions se supun regulei "Handle or Declare"
Uncheked exceptions
(RuntimeExceptions si Error) regula "Handle or Declare" este optionala
Declararea
se face cu keywordul "throws". Handle se face cu Try/Catch. Cu "throw" se arunca o exceptie
blocul finally se executa mereu indiferent daca apar probleme s-au nu. (cu exceptia cand in try s-au catch block se invoca System.exit())
blocul finally trebuie sa fie ultimul (dupa toate catch-urile)
return intr-un catch block nu o sa intrerupa executarea lui finally
Ordinea blocurilor catch trebuie sa inceapa cu cele mai specifice si sa continue cu mai generalizate.

nu este permis cod intre try si catch
un try trebuie urmat de un catch s-au de finally
finally poate modifica un "return value" care vine dintr-un catch bloc doar daca este de tip object (nu si pt primitive) (Primitivele sant passed by value, iar Objectele sant passed by reference)

Reguli pt. Methoden overriding:
o methoda care redefineste o oalta metoda @Override trebuie sa aiba:
- aceasi semnatura
- aceasi sau kovariante rückgabe Typ (ist ein beziehung)
MUSS sa throw urmatoarele Exceptions
Gleiche Weniger/keine oder Engere (mai exacte) Checked Exceptions werfen
KANN jegliche "Unchecked Exceptions" werfen


if() Statment

if(boolean){}
- acoladele sant optionale
- incrementaril facute in if() se pastreaza chiar daca este false

do while
executa cel putin o data blocul din do, dupa care blocul din do atata timp cat while este true

int i = 0;
do {
System.out.println(i);
} while (i++ < 1);

switch()
- poate evalua numai: enums, byte, short, int, char si String         // NU boolean, long, float and double
- The class of the switch variable may also be a Wrapper class i.e. Character, Byte, Short, or Integer.
- case trebuie sa fie un Compilertime Final (adica la compiler time acea variabila trebuie sa aiba o valuare initializata)
- default este executat numai daca nici un case nu este true (indiferent in ce pozitie este gasit).
  dar dupa true, default este executat daca intre true si default JVM nu gaseste un break

- default NU este obligatoriu


for()

daca este true, prima data se executa statmentul si DUPA acea se face iteratia, ( ACELASI nr de iteratii) indiferent daca sete post s-au pre
++ -- STATMENT si pe urma x++ x-- s-au  ++x --x

break; si continue;
iesiri premature din for se face cu:
- break;
- return;
- System.exit()

continue trebuie sa fie in interiorul buclei (daca nu avem compiler error)
break trebuie sa fie in interiorul buclei cat si a swich-ului

Label-ed break si continue
Verschachtelte Schleifen können mit einem Label versehen werden. Die break- bzw. continue-Anweisungen können sich dann durch Angabe des Labels auf äußere Schleifen beziehen.
Ohne Angabe des Labels wirken break und continue auf die Schleifen, in denen sie gesetzt wurden.
Durch die Verwendung beschrifteter break- und continue-Anweisungen kann die Ausführung außerhalb der aktiven Schleife fortgesetzt werden.


- label se poate folosi la toate loops (for(), while() si do while) dar nu si la if chiar daca se afla intr-un for()

int x = 0;
out: for (int i = 0; i < 2; i++) { // Label out
while (x < 2) {
if (x++ > 2) {
break out; // Beendet for-Schleife
}
System.out.println("if = false ");
}
System.out.println("i = " + i);
}
System.out.println("x = " + x);

// rezultat: 
// if = false 
// if = false 
// i = 0
// i = 1
// x = 2

Variable scope.
Daca x este declarat in afara for-ului, pote fi folosit si in afara buclei si atentie, x are acum valuare de dupa terminarea buclei


int x = 3;
for (x = 0; x < 9; x++) {
}
System.out.println(x); // x este 9



for each (pt arryas)
for each (pt arryas) 
//- daca a este un array atunci se itereaza peste tot myArray-ul
int[][] myArray = {{ 1, 2, 3, 4}, {7,8,9}}; for (int []a : myArray {System.out.println(a);}

//- daca myArray este un simplu int, nu se poate sa casting un array intr-un int 
int[][] myArray = {{ 1, 2, 3, 4}, {7,8,9}}; for (int a : myArray) {System.out.println(a);} // - daca myArray este un simplu int, se poate itera numai pe o dimensiune
int[][] myArray = {{ 1, 2, 3, 4}, {7,8,9}}; for (int a : myArray[1]) {System.out.println(a);}

// Tip: se poate fol Arrays.deepToString(a)

 

 


Enums
- este specificarea unei liste de constante asigurate unui anumit tip (luni, marti, sant de constante de tip saptamana)
- un enum NU este un string s-au int ci de tipul declarat javakurs
- un enum poate fi declarat intr-o class proprie s-au ca membru intr-o clasa dar niciodata intr-o metoda
- Un enum declarat in afara unei clase, trebuie sa NU fie marcat ca fiind: static, final, abstract, protected s-au private
- enum pot contine: constructori, metode, variabile, "constant-specific class bodies"
- constantele enum pot trimite argunente la constructorul sau folosind sintaxa: IANUARIE(1), unde literarul 1 este "passed" constructorului eunm
- constructorul enum poate avea argumente iar acestea pot fi suprascrise
- constructori enum NU pot fi NICIODATA invocati direct in cod, ei sant chemati automat cind un enum este initializat
- semicolons ; la sfarsitul declaratiei sint optionale
- MyEnum.value() returneaza un array al valorilor din MyEnums


 


Class

- Intr-un fisier de cod sursa, nu poate exixta decat o singura classa ca fiind declarata public iar numele classei trebuie sa corespunda cu numele Fisierului.java (Dog.java -> public class Dog{})
   dar poate contine orce nr de classe, interfatesi enums, nepublice
- Putem avea acelasi nume de classa, dar in pakete diferite

 


Logical Operators
 Precedenta:

int x = 1;


int y = x++;        //
1
          1

int y = x + x++; // 2
           1 + 1

int y = x++ + x; //3
             1   + 2

int y = ++x  +  x; // 4
              2   +  2

int y = ++x  +  x++; // 4
              2   +  2

int y = ++x + ++x;  // 5
             2   +   3

int y = x + x++ + ++x + ++x + x;  //13
           1 + 1     +    3  +   4   + 4


System.out.println(X++ * ++X * X++);   9//
                                  1    *     3  *  3

 

4 + 20 / (3 - 1) * 2 //24
if (x < 100) && (x > 10) // cu paranteze s-au && NU are ce cauta acolo

(true) && (++i > 5) // in acest caz i nu mai este incrementat pt ca primul test este true

true || true && false // true (&& are prioritare inainte la ||)

int z = 5;
if (++z  > 5 || ++z > 6) z++;      // 7 (++z > 6 nu a mai fost evaluata)
if (++z  > 5 | ++z > 6) z++;      // 8

^ logical XOR (exclusiv -OR), return true daca exact un operand este TRUE
(4 > 3) ^ (5 > 2)   // false
(4 > 3) ^ (5 > 10) // true


Operator Precedence
Postfix increment are prioritate mai mare decat Prefix
Post dreapta
Pre stanga


la Post dreaptam ai intai se asigura valuarea la variabila si pe urma se incr s-au decr
int x1 = -4;         // -4
int x2 = x1--;      // x2 is first assigned the value of x1 i.e. -4 and then x1 in decremented by 1 to become -5 (adica x2 primeste valuarea -4 dupa care  x1-- devine -5 dar in cazul nostru x1 nu mai este folosit si nu ii mai vedem valuarea)
int x3 = ++x2;    // x2 becomes -3 first and then its value i.e. -3 is assigned to x3

Operator Description Level Associativity
[]
.
()
++
--
access array element
access object member
invoke a method
post-increment
post-decrement
1 left to right
++
--
+
-
!
~
pre-increment
pre-decrement

unary plus
unary minus
logical NOT
bitwise NOT
2 right to left
()
new
cast
object creation
3 right to left
*
/
%
multiplicative 4 left to right
+ -
+
additive
string concatenation
5 left to right
<< >>
>>>
shift 6 left to right
<  <=  >  >=  
instanceof
relational
type comparison
7 left to right
==
!=
equality 8 left to right
& bitwise AND 9 left to right
^ bitwise XOR 10 left to right
| bitwise OR 11 left to right
&& conditional AND 12 left to right
|| conditional OR 13 left to right
?: conditional 14 right to left
  =   +=   -=   *=   /=   %=   &=   ^=   |=  <<=  >>= >>>=  
assignment 15 right to left

 

 


I/O

  Binar Text
Input InputStream Reader
Output OutputStream Writer
     

DataOutputStream    BufferedOutputStream  FileOutputStream .../myFile.dat
      writeIn(int i)
      writeUTF(String s)

  DataInputStream  BufferedInputStream  FileInputStream   ../myFile.dat
        readInt()
        readUTF()

 PrintWriter  BufferedWriter  FileWriter .../myFiele.txt
       print()
       println()

←  BufferedReader ←  FileReader  ../myFile.dat
         read()
         readLine()

DataOutputStream out = new DataOutputStream(new BufferedOutputStream(new FileOutputStream(fileName.bin))))
DataInputStream in = new DataInputStream(new BufferedInputStream(new FileInputStream(fileName.bin))))

 

 

Floating-point numbers sant implicit double (64 bits)
daca declaram float myNr = 345,45; //acesta este de fapt un douoble
daca vrei sa fie un float (32 bits) atunci trebuie adaugat un f sau F
float myNr = 345,45F;

 




import
- este numai pt a economisi apasare de tastatura
- * este continutul unei pagini

 

Inheritance
- Mostenirea permite unei clase sa fie subclasa unei superclasse si sa-i mosteneasca variabilile public, protect si methodele accestei classe
- IS-A concept cheie pt. polinorfism, supraincarcare, suprascriere si casting



Literal un literal este o valuare fixa care NU are nevoie de nici o operatiune si pentru afi asigurata unei variabile de orice fel
http://cplusplus-development.de/wissenswertes/oktal-dezimal-hexadezimal-ascii-tabelle
Decimal int i = 345; double d = 45,5;
Binary int bi = 0B101010; int bi = 0b101010:
Octal (nr nr intre 0 si 7) int oc = 06;
Hexadecimal (16 simbols) 0123456789ABCDEF  int x = 0x7ffffff

byte + byte = int

 

Local Variables
- Local variables NU au valori "default" de accea trebuiesc initializate inainte a putea fi folosite (int t = 3;)
- Local variables (methods variables) traiesc in STACK
- Local variable (adica declarate intr-o methoda) declarations NU pot avea acces modifiers
- final este singurul modificator disponibil la "local variabile"


 

main()
- main() pate fi un nume de metoda oarecare (in conbinatie cu public static void main (String[] args))
- main() poate fi suprascrisa


Methods

- Methods arguments are always copies
- prima litera mica, camelCase si sa fie Verb + Substantiv (ex.getBallance())

 

Math.random()

int zufallszahl = (int)(Math.random() * (max - min) + min); // between min and max.
int zufallszahl = (int)(Math.random() * (5 - 2) + 2); // >= 2, < 5

zufallszahl = Math.random(); // >= 0.0, < 1.0 (float, double)
int zufallszahl = (int)(Math.random() * 40); // (intre 0 si 39) // >= 0, < 40 (exclusiv) sinonim cu 
int zufallszahl = (int)(Math.random() * (39 + 1)); // (intre 0 si 39) // >= 0, < 40 sinonim cu ex de sus

int zufallszahl = (int)(Math.random() + 0.5)	// 0 OR 1



nested classes este sinonim cu inner classes



Scope
Scope se refera la "lifetime-ul" unei variabile:
si anume patru basics scopes:
        - static variables live atata timp cit traieste clasa sa (Klassen Variable)
        - instanz variables exixsta atit cit obiectele sale (Object  Variable)
        - local variables live atata timp cit methoda este in stack (Methoden Variable)
        - block variables (ex for if) live pana la terminarea blocului

Local variabilele trebuiesc initianilizate inainte de a fi folosite in orce fel

Source File Declarations Rules
- O sursa cod poate avea numai one public class
    daca codul contine o classa public, numele clasei (fisierului) trebuie sa fie acelasi cu numele classei
- Un fisier poate avea mai multe nonpublic class javakurs

 

public static void main(String[] args) VM

arrays au un atribut pe nume .length (A-A)


PI = packet import

Animal doina = new Horse();
Animal --> Compiler Time //
Horse --> Run Time // DR dreapta runTime

- Suprascris = Run Time // OR Overwrite runTime
- Supraincarcat = Compiler Time

The concept is : variables are shadowed and methods are overridden.

^ logical XOR, return true daca exact un operand este TRUE

-2 * -1 = 2 // -1 das inverseaza primitivele

+ * + = +
+ * - = -
- * + = -
- * - = +

Packetul java.lang este importat automat

String, StringBuilder, and StringBuffer - all are final classes.

Math.pow(2, 3); // 8.0 //atentie typ double

int x = 0; int y = x = x + 1; //1

int x = 1; y = (x > 2) ? 10 : -10; //-10

int a = 4 + 20 / 2 * 2; // 24

int x, int y; // Wrong (de doua ori int)

int month = 09; // Wrong (octal fara cifra 8 si 9)

class Beta extends java.util.HashMap{} // este admis

modulo operator is typically used with integer operands, it also works for floating-point values

Octal values is base 8 (adica 0 - 7)
Octal literals are with a leading zero, for example 035 and 02764523 (fara 8 si 9)

int a = 4; int b = 7; System.out.println((-a) + (-b)); // -11

while(open = true) // e ok

Odd este OU unpar

 

short s = 1;
int i = 1;
s += i;

All compound assignment operators internally do an explicit cast. You can, therefore, read it like this:
s = (short) (s + i);

 

--------------------------

String str1 = "one"; 
String str2 = "two";
System.out.println( str1.equals(str1=str2) ); // false 

First the value of 'str1' is evaluated (i.e. one). Now, before the method is called, the operands are evaluated, so str1 becomes "two". so "one".equals("two") is false.

----------------------

int i = 0; 
bool = ( bool2 & method1(i++) );
bool = ( bool2 && method1(i++) ); // method1() is not called
bool = ( bool1 | method1(i++) );
bool = ( bool1 || method1(i++) ); // method1() is not called

// i => 2 
& and | do not short circuit the expression but && and || do.
As the value of all the expressions ( 1 through 4) can be determined just by looking at the first part, && and || do not evaluate the rest of the expression, so method1() is not called for 2 and 4.
Hence the value of i is incremented only twice.

---------------------------------

int k = 1; 
k += (k = 4) * (k + 2);
adica
k = 1 + (4) * (4 + 2) // adica k este 25

 

 

1. Mostenirea (Inheritance)

In mostenire instanz variabilile bind la compilertime si metodele la runtime

1.1.      Refence Variable si Object Types

1.1.1   
Accesarea unei member variabille "pret" mostenita din Classa "Jucari" de catre un obiect de Typ "Minge"
       
  Mingie mingie1 = new Mingie()

class Jucari {
	int pret;
}

interface Umflabil {
	public void umfla();
}

class Mingie extends Jucari implements Umflabil {
	int diametru;

	@Override
	public void umfla() {
		System.out.println("Mingea a fost umflata");
	}
}

public class MagazinDeJucari {
	public static void main(String[] args) {
		Mingie mingie1 = new Mingie();
	mingie1.diametru = 30;
		mingie1.pret = 10;
		mingie1.umfla();		
		System.out.println("Diametru: " + mingie1.diametru + " cm," + " Pret: " + mingie1.pret + " Lei");
	}
}
//Mingea a fost umflata 
//Diametru: 30  Pret: 10


1.1.2   Accesarea unei metode umfla() din Sub classa "Minge" de catre un obiect de Typ Jucari

Jucari jucari = new Mingie

Referenz variabila "jucari" de typ Jucari poate vedea numai membri definiti in clasa Jucari (cu toate ca obiectul este de typ Mingie)

class Jucari {
	int pret;
}

interface Umflabil {
	public void umfla();
}

class Mingie extends Jucari implements Umflabil{
	int diametru;

	@Override
	public void umfla() {
		System.out.println("Mingea a fost umflata");
	}
}

public class MagazinDeJucari {
	public static void main(String[] args) {
		Jucari jucari = new Mingie();

		jucari.umfla();    // NU compileaza, Variabila "jucari" NU poate accesa member-ul "umfla()" definit in classa Mingie
		jucari.pret = 10;  // Este Ok, Variabila "jucari" poate accesa membrul "pret" definit classa Jucari
	}
}

// Referenz variabila "jucari" de typ Jucari poate vedea numai membri definiti in clasa Jucari (cu toate ca obiectul este de typ Mingie)

 

 

1.1.3   O variabila de typ "Umflabil" poate vedea numai membri definiti in interfata "Umflabil"

CompresorDeAer compresor = new Mingie();

class Jucari {
	int pret;
}

interface Umflabil {
	public void umfla();
}

class Mingie extends Jucari implements Umflabila {
	int diametru;

	@Override
	public void umfla() {
		System.out.println("Mingea a fost umflata");
	}
}

public class MagazinDeJucari {
	public static void main(String[] args) {

		CompresorDeAer compresor = new Mingie();  // Referenz variabila "compresor" a obiectului de typ "Mingie" este de type "CompresorDeAer"
		
			compresor.diametru = 100;                 // NU commpileaza, Referenz variabila "compresor" a obiectului de typ "Mingie
compresor.pret = 2; // nu poate accesa membri din classa "Jucari" s-au "Mingie compresor.umfla(); // Este Ok, metoda "umfla()" definita in interfata "CompresorDeAer", poate fi accesata. } } // O variabila de typ "CompresorDeAer" poate vedea numai menbri definiti in interfata "CompresorDeAer"

 

1.1.4 Varabilele si a Metodele la COMPILER-TIME VS RUN-TIME
          Prin mostenire, instanz variabilele se "bind" la compilertime iar metodele la runtime

class Jucari {
	String descriere = "Jucari ";

	void printDescriere() {
		System.out.println(descriere);
	}
}

class Bicicleta extends Jucari {
	String descriere = "Bicicleta ";

	void printDescriere() {
		System.out.println(descriere);
	}
}

public class MagazinDeJucari {
	public static void main(String[] args) {
		Jucari jucari = new Jucari();
		Jucari j2 = new Bicicleta();

		System.out.println(jucari.descriere);  // Jucari 
		jucari.printDescriere();			   // Jucari 

		System.out.println(j2.descriere);	   // Jucari 
		j2.printDescriere();				   // Bicicleta 

	}
}

// valabil si cu interfete 
// de ex. daca in acest ex Clasa Jucari ar fi interfata

 

1.2  Casting 

 

 

1.3  this() si super() pt accesarea obiectelor si a constructorilor

 

1.4  Casting 

 

2. Polimorfia

2.1  Polimorfismul cu clasele  

 

Package
scrii paketul dorit in IDE, click si creezi paketele automat

 

Typenumwandlung (Cast) este posibil dar dezactivezi verificarea de catre compiler, la runtime este foarte posibil sa apara probleme

 

Try-with-resources

 try(FileInputStream input = new FileInputStream("file.txt")) {
// .. }

in loc de

try {input = new FileInputStream("file.txt");
// ..           
} finally {
if(input != null){
input.close();
}
}

 

Collections (Generic Collections) java.util
O colectie este un obiect in care sant stocate referinte catre alte obiecte care au relatii de "is-a"

Set - nu contile duplicate

List - este o colectie ordonata, poate contine duplicate

Queue First-in, First-out colection that models a waiting line, other orders can be specified

 

Map (nu se trage in Classa Collections) key-value, nu poate avea key duplicate

 

o

 

o

 

o

 


Links:
The Java® Language Specification
  James Gosling

Engineering ToolBox
  Decimal, binary, octal and hexadecimal numbers

ASCII -Table

 

 

Java ™ and all Java-based trademarks are trademarks of Oracle®, Inc. in the United States
Primavera-Kassensysteme Die Professionelle und Bedienungsfreundliche Registrierkasse