Variabilele, data types si operatorii

Variabilele primitive: - Un loc in memorie unde poti stoca ceva

1.
Int: un numar intreg / declararea de genul : int myFirstNumer = 5;
- width of 32 4 bytes
Tip de data
(data type):
asignare un loc
in memorie de
tip integer

Loc denumit
myFirstNumb

int minValue = -2147483648

int

Atribuire valoare
literara (a * b
atribuire
expresiva,
folosind o
maxValue
=

2147483647
! In Java 1.7 a fost implementata _ : pt a citi mai bine valorile
ex. -2147483648 = -2_147_483_648
2.
byte: o valoare ce ocupa un spatiu mult mai mic in memoria
calculatorului = width of 8
Poate stoca valori intre:

-128 si 127

Se utilizeaza intrucat foloseste aprox. 1 sfert din memoria care

ar fi luat-o un int
3.
short: un tip de date care are valori intre : -32768 si 32767
of 16 2 bytes

- width

- foloseste aprox. de 2x mai multa memorie decat un byte

4.

long: un tip de date, care foloseste la atribuirea unei valori litera L la

final
Ex. myLongValue = 100L;
! In operatiile de aritmetica, java transforma automat o expresie, intr-un integer
Ex. myByteValue = -100;
byte myTotal = (myByteValue / 2);
= eroare.
Rezolvare > prin casting :

o expresie, convertita automat in int

byte myTotal = (byte) (myByteValue / 2);

5. Float: single precision. Se deosebeste prin adaugarea de f dupa

valoarea atribuita
- o precizie de 7 cifre dupa punct (zecimale)
6. Double: double precision. Se deosebeste prin adaugarea de d dupa
valoarea atribuita, sau declararea unei variable de genul: double myDouble =
5.25; Java automat va declara variabila de tip myDouble de genul double.
- o precizie de 16 cifre dupa punct (zecimale)

7. char : un tip de date care stocheaza un singur element: litera, cifra,

caracter, sau unicode caracter. Sub forma :
char myChar ='D';
char mySecondChar = \u00A9;
8. boolean: true sau false
9. String : o secventa de caractere
String lastString = "10";
int myInt = 50;
lastString = lastString + myInt;
System.out.println("Last String: " + lastString);

Last String: 1050 -> converteste in String, si nu face suma

boolean isCar = true;

boolean wasCar = isCar ? true : false;
// if isCar == true, return true, else return false.
if (wasCar)
System.out.println("was Car is true");

KEYWORDS si EXPRESII
Acestea sunt rezervate de Java!

abstract
In front of a `class` keyword, prevents this class from being directly instantiated. In front of a
method signature, allows the implementation of this method to be deferred to an inheriting
class.

assert
Assert describes a predicate (a truefalse statement) placed in a java-program to indicate
that the developer thinks that the predicate is always true at that place. If an assertion
evaluates to false at run-time, an assertion failure results, which typically causes execution to
abort. Optionally enable by ClassLoader method.

boolean
Defines a boolean variable for the values "true" or "false" only (NB: "null" as in class Boolean
is not allowed).

break
Used to end the execution in the current loop body.

byte
Defines a byte variable representing a sequence of 8 bits. (NB: Only 1-byte-characters can
be used, f.i. '' would produce an error).

case
A statement in the switch block can be labeled with one or more case or default labels.
The switch statement evaluates its expression, then executes all statements that follow the
matching case label; see switch .[3]

catch

Used in conjunction with a try block and an optional finally block. The statements in
the catch block specify what to do if a specific type of exception is thrown by
the try block.

char
Defines a character variable capable of holding any character of the java source file's
character set (NB: Physical storage may exceed one byte).

class
A type that defines the implementation of a particular kind of object. A class definition
defines instance and class fields, methods, and inner classes as well as specifying
the interfaces the class implements and the immediate superclass of the class. If the
superclass is not explicitly specified, the superclass is implicitly Object . The class keyword
can also be used in the form Class.class to get a Class object without needing an instance
of that class. For example, String.class can be used instead of doing new
String().getClass().

const
Although reserved as a keyword in Java, const is not used and has no function.[2][1] For
defining constants in java, see the 'final' reserved word.

continue
Used to resume program execution at the end of the current loop body. If followed by a
label, continue resumes execution at the end of the enclosing labeled loop body.

default
The default keyword can optionally be used in a switch statement to label a block of
statements to be executed if no case matches the specified value; see switch .[3]
[4]
Alternatively, the default keyword can also be used to declare default values in a Java
annotation. From Java 8 onwards, the default keyword is also used to specify that a method
in an interface provides the default implementation a method.

do
The do keyword is used in conjunction with while to create a do-while loop, which executes
a block of statements associated with the loop and then tests a boolean expression
associated with the while . If the expression evaluates to true , the block is executed
again; this continues until the expression evaluates to false .[5][6]

double
The double keyword is used to declare a variable that can hold a 64-bit double
precision IEEE 754 floating-point number.[7][8] This keyword is also used to declare that a
method returns a value of the primitive type double .[9][10]

else
The else keyword is used in conjunction with if to create an if-else statement, which tests
a boolean expression; if the expression evaluates to true , the block of statements
associated with the if are evaluated; if it evaluates to false , the block of statements
associated with the else are evaluated.[11][12]

enum (as of J2SE 5.0)

A Java keyword used to declare an enumerated type. Enumerations extend the base
class Enum .

extends
Used in a class declaration to specify the superclass; used in an interface declaration to
specify one or more superinterfaces. Class X extends class Y to add functionality, either by
adding fields or methods to class Y, or by overriding methods of class Y. An interface Z
extends one or more interfaces by adding methods. Class X is said to be a subclass of class
Y; Interface Z is said to be a subinterface of the interfaces it extends.
Also used to specify an upper bound on a type parameter in Generics.

final
Define an entity once that cannot be changed nor derived from later. More specifically: a final
class cannot be subclassed, a final method cannot be overridden, and a final variable can
occur at most once as a left-hand expression on an executed command. All methods in a
final class are implicitly final .

finally
Used to define a block of statements for a block defined previously by the try keyword.
The finally block is executed after execution exits the try block and any
associated catch clauses regardless of whether an exception was thrown or caught, or
execution left method in the middle of the try or catch blocks using the return keyword.

float
The float keyword is used to declare a variable that can hold a 32-bit single
precision IEEE 754 floating-point number.[7][8] This keyword is also used to declare that a
method returns a value of the primitive type float .[9][10]

for
The for keyword is used to create a for loop, which specifies a variable initialization,
a boolean expression, and an incrementation. The variable initialization is performed first,
and then the boolean expression is evaluated. If the expression evaluates to true , the
block of statements associated with the loop are executed, and then the incrementation is
performed. The boolean expression is then evaluated again; this continues until the
expression evaluates to false .[13]
As of J2SE 5.0, the for keyword can also be used to create a so-called "enhanced for
loop",[14] which specifies an array or Iterable object; each iteration of the loop executes the
associated block of statements using a different element in the array or Iterable .[13]

goto
Although reserved as a keyword in Java, goto is not used and has no function.[2][1]

if
The if keyword is used to create an if statement, which tests a boolean expression; if the
expression evaluates to true , the block of statements associated with the if statement is
executed. This keyword can also be used to create an if-else statement; see else .[11][12]
implements
Included in a class declaration to specify one or more interfaces that are implemented by the
current class. A class inherits the types and abstract methods declared by the interfaces.
import

Used at the beginning of a source file to specify classes or entire Java packages to be
referred to later without including their package names in the reference. Since J2SE
5.0, import statements can import static members of a class.
instanceof

A binary operator that takes an object reference as its first operand and a class or interface
as its second operand and produces a boolean result. The instanceof operator evaluates
to true if and only if the runtime type of the object is assignment compatible with the class or
interface.
interface
Used to declare a special type of class that only contains abstract or default methods,
constant ( static final ) fields and static interfaces. It can later be implemented by
classes that declare the interface with the implements keyword.
long

The long keyword is used to declare a variable that can hold a 64-bit signed two's
complement integer.[7][8] This keyword is also used to declare that a method returns a value of
the primitive type long .[9][10]
native

Used in method declarations to specify that the method is not implemented in the same Java
source file, but rather in another language.[10]
new
Used to create an instance of a class or array object. Using keyword for this end is not
completely necessary (as exemplified by Scala), though it serves two purposes: it enables
the existence of different namespace for methods and class names, it defines statically and
locally that a fresh object is indeed created, and of what runtime type it is (arguably
introducing dependency into the code).
package
A group of types. Packages are declared with the package keyword.
private

The private keyword is used in the declaration of a method, field, or inner class; private
members can only be accessed by other members of their own class. [15]
protected
The protected keyword is used in the declaration of a method, field, or inner class;
protected members can only be accessed by members of their own class, that
class's subclasses or classes from the same package.[15]
public
The public keyword is used in the declaration of a class, method, or field; public classes,
methods, and fields can be accessed by the members of any class.[15]
return
Used to finish the execution of a method. It can be followed by a value required by the
method definition that is returned to the caller.
short

The short keyword is used to declare a field that can hold a 16-bit signed two's
complement integer.[7][8] This keyword is also used to declare that a method returns a value of
the primitive type short .[9][10]
static

Used to declare a field, method, or inner class as a class field. Classes maintain one copy of
class fields regardless of how many instances exist of that class. static also is used to
define a method as a class method. Class methods are bound to the class instead of to a
specific instance, and can only operate on class fields. (Classes and interfaces declared
as static members of another class or interface are actually top-level classes and
are not inner classes.)
strictfp (as of J2SE 1.2)
A Java keyword used to restrict the precision and rounding of floating point calculations to
ensure portability.[10]
super

Used to access members of a class inherited by the class in which it appears. Allows a
subclass to access overridden methods and hidden members of its superclass.
The super keyword is also used to forward a call from a constructor to a constructor in the
superclass.
Also used to specify a lower bound on a type parameter in Generics.
switch
The switch keyword is used in conjunction with case and default to create a switch
statement, which evaluates a variable, matches its value to a specific case , and executes
the block of statements associated with that case . If no case matches the value, the
optional block labelled by default is executed, if included.[3][4]
synchronized

Used in the declaration of a method or code block to acquire the mutex lock for an object
while the current thread executes the code.[10] For static methods, the object locked is the
class's Class . Guarantees that at most one thread at a time operating on the same object
executes that code. The mutex lock is automatically released when execution exits the
synchronized code. Fields, classes and interfaces cannot be declared as synchronized.
this

Used to represent an instance of the class in which it appears. this can be used to access
class members and as a reference to the current instance. The this keyword is also used
to forward a call from one constructor in a class to another constructor in the same class.
throw

Causes the declared exception instance to be thrown. This causes execution to continue
with the first enclosing exception handler declared by the catch keyword to handle an
assignment compatible exception type. If no such exception handler is found in the current
method, then the method returns and the process is repeated in the calling method. If no
exception handler is found in any method call on the stack, then the exception is passed to
the thread's uncaught exception handler.
throws
Used in method declarations to specify which exceptions are not handled within the method
but rather passed to the next higher level of the program. All uncaught exceptions in a
method that are not instances of RuntimeException must be declared using
the throws keyword.
transient

Declares that an instance field is not part of the default serialized form of an object. When an
object is serialized, only the values of its non-transient instance fields are included in the
default serial representation. When an object is deserialized, transient fields are initialized
only to their default value. If the default form is not used, e.g. when

a serialPersistentFields table is declared in the class hierarchy, all transient keywords are
ignored.[16][17]
try

Defines a block of statements that have exception handling. If an exception is thrown inside
the try block, an optional catch block can handle declared exception types. Also, an
optional finally block can be declared that will be executed when execution exits
the try block and catch clauses, regardless of whether an exception is thrown or not.
A try block must have at least one catch clause or a finally block.
void

The void keyword is used to declare that a method does not return any value.[9]
volatile

Used in field declarations to specify that the variable is modified asynchronously by

concurrently running threads. Methods, classes and interfaces thus cannot be
declared volatile, nor can local variables or parameters.
while

The while keyword is used to create a while loop, which tests a boolean expression and
executes the block of statements associated with the loop if the expression evaluates
to true ; this continues until the expression evaluates to false . This keyword can also be
used to create a do-while loop; see do
EXPRESII

Alcatuite din : Values, Variables Si Operatori + Metod Calls

double kilometres = (100 * 1.609344); //componentele expresiei
if (highScore == 50){
System.out.println("This is an expression!"); // o alta expresie!
}
// expresiile din codul urm este
int score = 100;
//expresia 1. (data tipul si ; nu fac parte din expresie)
if (score > 99){ //partea din interiorul () este o expresie
System.out.println("You get the high score!");
//"You get the high score!" o alta expresie
score = 0; // score = 0, alta expresie

STATEMENTS
int myVariable = 50; // myVariable = 50 este expresia

int myVariable = 50; - este statement, toata linia.

- Este cel mai bine ca fiecare statement sa fie pe
cate o linie
- White space: sa folosim spatii pt a avea o
imagine mai clara a codului. Este ignorat de Java.
INDENTARE , cod block
if (gameOver == true) {
int finalScore = score + (levelCompleted * bonus);

System.out.println("Your final score was " + finalScore);

}

1. exemplul de mai sus e un code block. Variabila finalScore este creata in acel
block. Dupa executare, variabila este stearsa, astfel incat nu poate fi accesata
ulterior.
Metodele
Public static void main este o metoda de tipul Main
Nu poti pune o metoda in alta metoda!!
//aici introducem argumentele la calculateScore()
calculateScore(true, 800, 5, 100);
calculateScore(true, 10000, 8, 200);
}
// metoda pt calculul scorului
// setam variabilele in metoda, definim parametrii
// introducem data tipul
public static void calculateScore(boolean gameOver, int score, int levelCompleted, int
bonus) {
if (gameOver) {
int finalScore = score + (levelCompleted * bonus);
finalScore += 2000;
System.out.println("Your final score was " + finalScore);
}
}

Method overloading
Foarte folosit acelasi nume ca si metoda, dar cu alti parametrii
public static int calculateScore(String name, int score){
System.out.println("Player " + name + " scored " +
score);
return score * 1000;
}
public static int calculateScore(int score){
System.out.println("Unnamed Player scored " +
score);
return score * 1000;
}

Switch statement
Folositor cand trebuie sa testezi mai multe variante, insa testeaza doar un
singur punct, in exemplul de mai jos switchValue.
Switch statement poate fi folosit cu 4 tipuri de date primitive:
Byte, short, char, int
int switchValue = 3;
switch(switchValue) {
case 1:
System.out.println("Value was 1");

break; // inchide secventa de switch

case 2:
System.out.println("Value was 2");
break;
default: // any other cases, varianta la ELSE
System.out.println("Neither 1 nor 2");
break;
}

for loop
for (init; termination; increment){
}

init unde incepe loop-ul

termination unde se termina
increment expresia care e invocata dupa fiecare iteratie
String.format("%.2f",calculateInterest(10000.0,i)));
%.2f converteste numarul rezultat, intr.unul cu doar 2 zecimale
Pentru numere prime:
int b = 0;
for (int a = 2; a <= 50; a++){
if (isPrime(a)) {
System.out.println("The number " + a + " is prime.");
b++;
}
if (b == 8)
break;
}
}
public static boolean isPrime(int n){
if (n == 1){
return false;
}
for (int i=2; i<= n/2; i++){
if (n % i == 0){
return false;
}
}
return true;
}
while (number != finishNumber)
{
//
number++;
//
if (isEvenNumber(number)){
//
System.out.println(number + " este numar intreg.");
//
}
//
else
//
System.out.println(number + " nu este numar intreg.");
if (!isEvenNumber(number))
{
number++;
continue;

}
System.out.println("Even number: " + number);
number++;
}

Clasele
Obiectele: au stare si comportament (state and behavior)
Clasa: - un template pt a crea un obiect
Variabile locale: definite doar in interiorul unei metode
- sunt vizibile doar in acea metoda
variabile member, sau class , cunoscute ca si fields acces in toata clasa
public static void main(String[] args){
Car porsche = new Car();
Car holden = new Car();
porsche.model = "Carrera";

! nu tine cont de encapsulare (data fieldul model este public si nu privat)

private String model;
private String engine;
private String colour;
//metoda sa updatam modelul
public void setModel(String model){
// update THIS component (model - field) cu valoarea
//parametrului
this.model = model;

De ce sa folosim Getters and Setters?!

public void setModel(String model){
// update THIS component (model - field) cu valoarea
//parametrului
this.model = model;
}
public String getModel(){
return this.model;

1. putem aplica tot felul de reguli pt setter: valida, testa etc.

Pentru setarea unor default-uri intr-un constructor, folosim:
public BankAccount(){
this("56789",2.50,"Default name","Default address" +
, "Default phone");

folosing this urmat de argumentele aferente parametrilor.

- Trebuie sa fie primul statement dintr-un

constructor! this
- Parametrii
respectivi
provin
dintr-un
constructor Overloaded
-

public BankAccount(){
this("56789",2.50,"Default name","Default
address", "Default phone");
System.out.println("Empty constructor
called.");
}
public BankAccount(String accountNumber, double
accountBalance, String customerName,
String customerEmail, String
customerPhone){
System.out.println("Account constructor cu
parametrii chemati.");
this.accountNumber = accountNumber;
this.accountBalance = accountBalance;
this.customerName = customerName;
this.customerEmail = customerEmail;
this.customerPhone = customerPhone;

- Obs: este recomandata updatarea field-urilor

direct in constructor, si nu apeland la Setters
(se poate intampla ca metoda respectiva sa nu
fie accesata)
- Obs 2: e posibil ca anumite aspecte ale
initializarii obiectului respectiv sa nu se
termine in constructor
- Obs 3: pot fi folositi mai multi constructori,
doar pentru a completa spre ex. partial
parametrii cu unii default:
-

public BankAccount(String customerName,

String customerEmail, String
customerPhone) {
this("99999",100.55, customerName,
customerEmail, customerPhone);
this.customerName = customerName;
this.customerEmail = customerEmail;
this.customerPhone = customerPhone;
}

INHERITANCE
Crearea de clase care sa mosteneasca alte feature-uri ale altor clase, desi ele
fiind diferite.
Ex. clasa Animals : caini, pisici, pesti,etc sunt animale
Toate au creier

Nu toate au picioare etc.

Crearea unei clase care toate celelalte clase ar avea in comun aceleasi field-uri
Obs: pt mostenire se foloseste extends keyword
// pt mostenire -> se foloseste "Extends"
public class Dog extends Animal {
{

public Dog(String name, int brain, int body, int size, int weight)
}

super(name, brain, body, size, weight);

public class Dog extends Animal {

//caracteristicile unice ale Dog, in plus fata de Animal
private int eyes;
private int legs;
private int tail;
private int teeth;
private String coat;
public Dog(String name, int size, int weight, int eyes, int legs,
int tail, int teeth, String coat) {
super(name, 1, 1, size, weight);
this.eyes = eyes;
this.legs = legs;
this.tail = tail;
this.teeth = teeth;
this.coat = coat;
//inlocuiesc brain = 1, toate animalele au brain
//trebuiesc initializate si field-urile specifice
//(eyes, legs, etc...)
// super - apeleaza parametrii comuni de unde face parte
}
}

Am creat metoda eat() in Animal, pt ca toate animalele mananca.

Insa nu toate animalele mananca la fel, unele mesteca, altele inghit, etc.
Asadar am Override metoda eat, cu una chew, in clasa Dog
private void chew(){
System.out.println("Dog.chew() called.");
}
@Override
public void eat() {
super.eat();
}

clasele create, automat mostenesc anumite lucruri din java.lang.Object

Composition, polymorphism, Encapsulation
Composition: o clasa, parte a unei alte clase (ex: ca field intr-o alta clasa)
Ex:
public class Monitor {
private
private
private
private

String model;
String manufacturer;
int size;
Resolution nativeResolution;

public class Resolution {

private int width;
private int height;
public class Main {
public static void main(String[] args){
Dimensions dimensions = new Dimensions(20,20,5);
Case theCase = new Case("220B","Dell","240",dimensions);
//creare monitor resolution, fara ca sa instantiem obiectul ca dimensions
Monitor theMonitor = new Monitor("27inch Beast","Acer",27, new
Resolution(2540,1440));
Motherboard theMotherboard = new Motherboard("B2-200","Acus",4,6,"v2.44");
//obiectul thePC, acceseaza alte obiecte, inauntru acestuia
// fara a avea inheritance
//Case, Monitor, si Motherboard NU sunt PC, asa ca folosim composition
PC thePC = new PC(theCase, theMonitor, theMotherboard);
thePC.getMonitor().drawPixelAt(1500,1200,"red");
thePC.getMotherbord().loadProgram("Windows 1.0");
thePC.getTheCase().pressPower();
}
}

Composition creaza Obiecte in interiorul altui Obiect

Unde folosim Composition si unde folosim Inheritance?
1. Ca regula generala, folosim Composition
2. Composition ofera mai multa flexibilitate
ENCAPSULATION
1. Mecanismul care restrictioneaza accesul catre anumite componente ale
obiectelor

2. Opreste pe cei din exterior in a avea acces la cum lucreaza o clasa

POLYMORPHISM
1. Mecanismul care permite ca actiunile sa se desf diferit in functie de
anumite lucruri.
2. Crearea claselor in aceeasi clasa, folositoare doar daca sunt clase mici,
compacte.
3. Se foloseste daca ai clase care mostenesc parametrii unei super clase.
ARRAYS
- java aloca 4 bits de memorie pt fiecare integer, 8 bits pt double
-Se folosesc pt a stoca mai multe variabile
-O structura data ce iti permite sa salvezi multiple secvente
-numerotarea pozitiilor in array incepe de la 0!!!
int[] myVariable; //definirea standard a unui array
myVariable = new int[10]; //asignare 10 elemente
//folosirea metodelor in loc de HARD CODING!
for (int i =0; i<10; i++)
{
myIntArray[i] = i*10;
}
for (int i=0;i<10;i++){
System.out.println("Element " + i +" is " + myIntArray[i]);
}

Exemplu: for (int i =0; i<myIntArray.length; i++)

.length!!
{

int[] myIntArray = new int[25]; //{1,2,3,4,5,6,7,8,9,10};

//folosirea metodelor in loc de HARD CODING!
for (int i =0; i<myIntArray.length; i++)
{
myIntArray[i] = i*10;
}
printArray(myIntArray);

}
public static void printArray(int[] array){
for (int i=0;i<array.length;i++){
System.out.println("Element " + i +" is " + array[i]);

Exemplu de array folosind metode!!

private static Scanner scanner = new Scanner(System.in);
public static void main(String args[])
{
int[] myIntegers = getIntegers(5);
for (int i = 0; i<myIntegers.length; i++){
System.out.println("Element " + i +" types was " +
myIntegers[i]);
}
}
public static int[] getIntegers(int number){
System.out.println("Enter " + number +" integer values.\r");
int[] values = new int[number];
for (int i = 0;i<values.length;i++){
values[i] = scanner.nextInt();
}
return values;
}
//de creat un program folosing arrays care sorteaza o lista de elemente in
ordine descendenta
//numerele trebuie introduse de la tastatura
//implementare metode getIntegers, print array, sortInteger
public class Main {
private static Scanner scanner = new Scanner(System.in);
public static void main(String args[]){
int[] myIntegers = getIntegers(5);
int[] sorted = sortIntegers(myIntegers);
printArrays(sorted);
}
public static int[] getIntegers(int array){
System.out.println("Introdu elementele: \r");
int[] values = new int[array];
for (int i = 0; i<values.length; i++){
values[i] = scanner.nextInt();
}
return values;
}
public static void printArrays(int[] array){
System.out.println("Array:");
for (int i =0 ; i<array.length; i++){

System.out.println("Elementul " + i + " este: "+

array[i]);
}
//
//
//
//

public static int[] sortIntegers(int[] array){

int[] sortedArray = new int[array.length];
for (int i = 0 ; i<array.length;i++){
sortedArray[i] = array[i];
}
int[] sortedArray = Arrays.copyOf(array,array.length);
boolean flag = true;
int temp;
while (flag){
flag = false;
// element 0
50
//element 1
160
//element 2
40
for (int i = 0; i<sortedArray.length-1;i++){
if (sortedArray[i] < sortedArray[i+1]){
temp = sortedArray[i];
sortedArray[i]=sortedArray[i+1];
sortedArray[i+1] = temp;
flag = true;
}
}

}
return sortedArray;

Resize Array:
public class ResizeArray {
private static Scanner s = new Scanner(System.in);
private static int[] baseData = new int[10];
public static void main(String[] args){
System.out.println("Enter 10 elements:");
getInput();
printArray(baseData);
resizeArray();
System.out.println("Enter 12 integers:");
getInput();
printArray(baseData);
}
private static void getInput(){
for (int i = 0; i<baseData.length;i++)
baseData[i]=s.nextInt();
}
private static void printArray(int[] arr){
for (int i = 0; i<arr.length;i++)

System.out.print(arr[i] + " ");

System.out.println();
}
private static void resizeArray(){
int[] original = baseData;
baseData = new int[12];
for (int i = 0;i<original.length;i++){
baseData[i] = original[i];
}
}
}

LIST un concept de interfata; o colectie ordonata (sequence)

ArrayList mosteneste interfata LIST
package Arrays.ListAndArrayList;
import java.util.ArrayList;
/**
* Created by Daniel on 10/28/2016.
*/
public class GroceryList {
//definire ArrayList - fara a defini tipul acesteia
//arraylist - poate contine obiecte
//definire lista Array de tip String
private ArrayList<String> groceryList = new ArrayList<>();
public void addGroceryItem(String item){
groceryList.add(item); //adaugare item in Lista
}
public void printGroceryList(){
System.out.println("You have " + groceryList.size() + " items");
for (int i =0 ; i<groceryList.size(); i++){
System.out.println((i+1) + ". " + groceryList.get(i));
}
}
public void modifyGroceryItem(String newItem){
}
public void modifyGroceryItem(int position, String newItem){
groceryList.set(position,newItem);
System.out.println("Grocery item " + (position+1) +
" has been modified.");
}
public void removeGroceryItem(int position){
String theItem = groceryList.get(position);
groceryList.remove(position);
}
public String findItem(String searchItem){
//contains - fast search a item din lista
// boolean exists = groceryList.contains(searchItem);
//returnare item daca exista

//returneaza pozitia index a acelui item cautat

int position = groceryList.indexOf(searchItem);
if (position >= 0){
return groceryList.get(position);
}
return null;
}
}

// copiaza continutul unei lista intr.o alta lista, dupa ce am introdus

// UN GETTER
public static void processArrayList(){
ArrayList<String> newArray = new ArrayList<String>();
newArray.addAll(groceryList.getGroceryList());
// alta metoda de a copia continutul - se intampla la declarare
ArrayList<String> nextArray = new
ArrayList<String>(groceryList.getGroceryList());

AUTOBOXING si UNBOXING ??
LinkedList?? o alternativa pt arraylist, in care stocheaza noua informatie in
continuare, in loc de a introduce la o anumita pozitie in array
INTERFACES
Provide a common behavior that can be used by several classes by having
them all implement the same interface
!!!! Multi inheritance POSIBIL doar prin interfete
Ex. bird, dog animal BUT bird can walk and fly, dog can only walk
Trebuie avuta in vedere relatia CLASEI FINALE cu obiectele care sunt
implementate
public interface ITelephone {
//cream signatures, si nu definim codul
void powerOn();
void dial(int phoneNumber);
void answer();
boolean callPhone(int phoneNumber);
boolean isRinging();
}
public class Main {
public static void main(String[] args)
{
ITelephone timsPhone;
timsPhone = new DeskPhone(123456);
timsPhone.powerOn();
timsPhone.callPhone(123456);

timsPhone.answer();
//pot folosi o alta instanta cu acelasi nume!!
//pt ca implementeaza amandoua clase aceeasi interfata
timsPhone = new MobilePhone(24565);
timsPhone.powerOn();
timsPhone.callPhone(24565);
timsPhone.answer();
}

public class DeskPhone implements ITelephone {

private int myNumber;
private boolean isRinging;
public DeskPhone(int myNumber) {
this.myNumber = myNumber;
}
@Override
public void powerOn() {
System.out.println("No action taken, deskphone nu are power buton");
}
@Override
public void dial(int phoneNumber) {
System.out.println("Now ringing " + phoneNumber);
}
@Override
public void answer() {
if (isRinging){
System.out.println("Answering the deskphone..");
isRinging = false;
}
}
@Override
public boolean callPhone(int phoneNumber) {
if (phoneNumber == myNumber){
isRinging = true;
System.out.println("Ring ring");
} else {
isRinging = false;
}
return isRinging;
}
@Override
public boolean isRinging() {
return isRinging;
}
}
public class MobilePhone implements ITelephone {
private int myNumber;
private boolean isRinging;
private boolean isOn = false;

public MobilePhone(int myNumber) {

this.myNumber = myNumber;
}
@Override
public void powerOn() {
isOn = true;
System.out.println("Mobile phone powered up");
}
@Override
public void dial(int phoneNumber) {
if (isOn) {
System.out.println("Now ringing " + phoneNumber + " on mobile phone");
} else {
System.out.println("Phone is switched off");
}
}
@Override
public void answer() {
if (isRinging){
System.out.println("Answering the mobile phone..");
isRinging = false;
}
}
@Override
public boolean callPhone(int phoneNumber) {
if (phoneNumber == myNumber && isOn){
isRinging = true;
System.out.println("Melody ring");
} else {
isRinging = false;
System.out.println("Mobile phone not On");
}
return isRinging;
}
@Override
public boolean isRinging() {
return isRinging;
}
}

INNER CLASSES
//GearBox - outer class
//Gear inner class, in GearBox
//pt referinta: OuterClass.InnerClass
GearBox mcLaren = new GearBox(6);
GearBox.Gear first = mcLaren.new Gear(1, 1.3);
GearBox.Gear second =
System.out.println(first.driveSpeed(1000));
public class GearBox {
private ArrayList<Gear> gears;
private int maxGears;

private int currentGear = 0;

public GearBox(int maxGears) {
this.maxGears = maxGears;
this.gears = new ArrayList<>();
Gear neutral = new Gear(0, 0.0);
this.gears.add(neutral);
}
public class Gear {
private int gearNumber;
private double ratio;
public Gear(int gearNumber, double ratio) {
this.gearNumber = gearNumber;
this.ratio = ratio;

}
public double driveSpeed (int revs){
return revs *(this.ratio);
}

local classes: declarate intr-un block (metode)

public class Main {
private static Scanner scanner = new Scanner(System.in);
private static Button btnPrint = new Button("Print");
public static void main(String[] args) {
//local class-> definita intr.o metoda
class ClickListener implements Button.OnClickListener{
public ClickListener(){
System.out.println("I've been attached");
}
@Override
public void onClick(String title) {
System.out.println(title + " was clicked");
}
}
btnPrint.setOnClickListener(new ClickListener());
listen();
}
private static void listen(){
boolean quit = false;
while (!quit){
int choice = scanner.nextInt();
scanner.nextLine();
switch (choice){
case 0:
quit = true;
break;
case 1:
btnPrint.onClick();
}
}
}
}

anonymous class!!: -> same code as up, buttt....

//anonymous class!!
btnPrint.setOnClickListener(new Button.OnClickListener() {
@Override
public void onClick(String title) {
System.out.println(title + " was cliked.");
}
});
listen();
}

ABSTRACT CLASSES
Definesc metode care nu produc o implementare a acelor metode
Diferente intre interfete si clase abstracte
Abstract class member variables that are inherited
- Pot avea constructori
Interfaces public STATIC final variables, nu se schimba
GENERICS!!
public class Team<T> { //declarare Team de tip GENERIC!!
private String name;
int played = 0;
int won = 0;
int lost = 0;
int tied = 0;
private ArrayList<T> members = new ArrayList<>();
public Team(String name) {
this.name = name;
}
public String getName() {
return name;
}
public boolean addPlayer(T player){
if (members.contains(player)){
System.out.println(((Player) player).getName() + " is already on the
team.");
return false;
}

public class Main {

public static void main(String[] args){
FootballPlaye joe = new FootballPlaye("Joe");
BaseballPlyer pat = new BaseballPlyer("Pat");
SoccerPlayer bechkam = new SoccerPlayer("Beckham");
Team<FootballPlaye> adelaideCrows = new Team<>("Adelaide Crows");
adelaideCrows.addPlayer(joe);
adelaideCrows.addPlayer(pat);
adelaideCrows.addPlayer(bechkam);
System.out.println(adelaideCrows.numPlayers());

//
//

Team<BaseballPlyer> baseballTeam = new Team<>("Chicago Cubs");

baseballTeam.addPlayer(pat);
}

1.

2.

3.

4.

Naming Conventions!
Packages:
a. always lower case
b. names should be unique
c. internet domain name, reversed, as a prefix for the package name
d. invalid domain name:
1. replace invalid chars ( -) with _
2. domain name components starting with a number
should start with an _
3. domain name components that are Java keywords
should start with _
e. over 9 million Java devs worldwide
i. about:
1. Class or Interface name conflict IS INEVITABLE
2. Mechanism is needed to fully specify the class
3. Easy to determine that the classes are related to
4. Class and interface name conflicts are avoided
5. Classes within the package can have unrestricted
access to one another while still restricting access for
the classes outside
Class names:
a. Should be nouns (substantive)
b. Start with a capital letter
c. Each word in a name should start with a Capital: ex. LinkedList
Interfaces:
a. Capitalized like class names : ex. CamelCase
b. Consider what object implementing the interface will become or
what they will be able to do: ex. List, Comparable, Serializable
Methods:

a. mixedCase
b. often verbs
c. reflects the function perfomed or the result returned ex. size(),
getName()
5. Constants
a. All UPERCASE!!
b. Separate words with _
c. Declared using final keyword
d. Ex. static final int MAX_INT
6. Variables
a. mixedCase
b. meaningful and indicative
c. start with lower case letter
d. do NOT use _
7. Type parameters:
a. Single character, capital letter as well
i. E Element (java framework)
ii. K Key
iii. N Number
iv. T Type
v. V Value
vi. S,U,V etc. 2nd, 3rd, 4th types
SCOPE!
ACCESS MODIFIERS!!
TOP LEVEL
a. Only classes, interfaces and enums can exist at top level, anything
else must be included within one of these
b. Public object visible to all classes everywhere, whether they are in
the same package or been imported
c. Package-private object is only available within its own package
(remove the public keyword)
MEMBER LEVEL
a. Public same meaning as top level

b. Package-private same meaning as top level

c. Private object is visible ONLY within the class is declared
d. Protected visible anywhere within its package, but also in
subclasses even if they are in other packages
STATIC STATEMENT
a.