Curs 1

Clase și Obiecte
"Să începem cu o analogie. Să presupunem că doriți să construiți o navă mică. Lucrați la
un proiect și apoi trimiteți modelul într-o fabrică, unde o navă va fi asamblată conform
designului dvs.. Sau o duzină de nave sau mai multe nave după cum doriți. Ideea mea
este că zeci de nave identice pot fi realizate pe baza unui plan (blueprint)."

„Exact așa funcționează cu Java”.

"Programatorii Java sunt ca inginerii de proiectare, cu excepția că în loc de a crea planuri,

ei scriu clase. Piesele navelor sunt realizate pe baza unor planuri, în timp ce obiectele
sunt create pe baza claselor."

"În primul rând, scriem clase (realizăm planuri). Apoi, atunci când programul este rulat,
mașina Java creează obiecte bazate pe aceste clase. Este exact așa cum se construiesc
navele dintr-un model. Un plan - multe nave (O clasă – multe obiecte). Navele sunt
diferite. Au nume diferite și poartă încărcături diferite. Dar sunt în continuare similare.
Toate au un design identic și sunt capabile să îndeplinească sarcini similare. "
În Java, clasele și obiectele sunt interrelaționate. Nu putem avea un obiect fără o clasă,
cum nu putem avea o navă fără un plan (șablon).

Clasa din Java nu este decât o colecție de diverși membri de date (câmpuri) și funcții
ale membrilor (metode).

Obiectul din Java este o instanță a unei clase pentru a accesa proprietățile și metodele
definite.
CLASE
În Java, Class este o structură de date și va combina diferite tipuri de membri de date, cum ar
fi câmpurile, funcțiile membrilor și evenimentele într-o singură unitate.

EXEMPLU:
Vom defini o clasă Car care va ști să construiască mașini. Aceste obiecte (mașini) vor trebui să
aibă atribute comune cum ar fi:

- nume, model, an de fabricație (denumite câmpuri);

Si vor putea avea funcționalități cum ar fi:

- Pornire / oprire motor (denumite metode);

public class Car {
public String model;
public String nume; //CÂMPURI
public int anDeFabricatie;

public Car() { //CONSTRUCTOR

// Constructor Statements
}

public void startEngine() { //METODE

System.out.println("Motorul a pornit.");
}

public void stopEngine() {

System.out.println("Motorul s-a oprit.");
}
}
OBIECTE
În Java, Obiect este o entitate din lumea reală, de exemplu, scaun, mașină, pix, telefon mobil,
laptop etc.

Cu alte cuvinte, obiectul este o entitate care are stare și comportament. Aici, starea
înseamnă date și comportamentul înseamnă funcționalitate.

Obiectul este o entitate runtime, este creat la runtime.

Obiectul este o instanță a unei clase. Toți membrii clasei pot fi accesați prin obiect.

Să vedem un exemplu pentru a crea obiect folosind cuvântul cheie new.

Car c1 = new Car();

aici, c1 este numele variabilei in care va fi stocat obiectul, Car este tipul de date al variabilei
c1, semnul = va stoca obiectul in variabilă, iar new Car() este obiectul (sau instanța clasei
Car).
În acest moment, putem crea câte obiecte de tipul clasei Car dorim, și cu ajutorul acestora
vom putea accesa câmpurile si funcționalitățile (metodele) clasei prin operatorul punct (.).

Exemplu:

public static void main(String[] args) {

Car c1 = new Car();

c1.nume = “Wolsvagen”;
c1.model = “Golf VII”;
c1.anDeFabricatie = 2017;

System.out.println(c1.nume + “ “ + c1.model + “ “ + c1.anDeFabricatie);

c1.startEngine();
}
//Ce credeți că va rezulta din codul de mai sus?
Membrii unei clase
 CÂMPURI (FIELDS)

Când o variabilă este declarată direct într-o clasă, aceasta este adesea denumită câmp (sau atribut).

Nu este necesar, dar este o practică bună să începeți cu o primă literă cu majuscule atunci când denumiți
clase. De asemenea, este comun ca numele fișierului Java și numele clasei să se potrivească, întrucât
acesta face ca codul nostru să fie organizat. Cu toate acestea, nu este necesar.

Câmpurile le puteți accesa creând un obiect al clasei și folosind sintaxa punctului (.). Rulați, spre exemplu,
codul de mai jos:

class Car {

String color = "red";

int maxSpeed = 200;

static void main(String[] args) {

Car myObj = new Car();
System.out.println(myObj.color);
System.out.println(myObj.maxSpeed);
}
}
 CÂMPURI (FIELDS)

De asemenea, puteți lăsa câmpurile goale și le puteți modifica atunci când creați obiectul:

class Car {
String color;
int maxSpeed;

static void main(String[] args) {

Car myObj = new Car();

myObj.color = "red";
myObj.maxSpeed = 200;

System.out.println(myObj.color);
System.out.println(myObj.maxSpeed);
}
}
Acest lucru este util mai ales când se creează mai multe obiecte dintr-o clasă:

class Car {
String model;
String color;
int year;

static void main(String[] args) {

Car ford = new Car();
ford.model = "Mustang";
ford.color = "red";
ford.year = 1969;

Car opel = new Car();

opel.model = "Astra";
opel.color = "white";
opel.year = 2005;

System.out.println(ford.model);
System.out.println(opel.model);
}
}
 METODELE CLASEI

Ați aflat din cursul Metode că metodele sunt utilizate pentru a efectua anumite acțiuni.
Metodele aparțin în mod normal unei clase și definesc modul în care se comportă un obiect al unei clase.

La fel ca în cazul câmpurilor, puteți accesa metode cu sintaxa punct (.). Cu toate acestea, rețineți că metoda
trebuie să fie publică. Și amintiți-vă că folosim numele metodei urmată de două paranteze () și un punct și
virgulă (;) pentru a apela (executa) metoda:

class Car {
String color; // câmp
int maxSpeed; // câmp

public void fullThrottle() { // metodă

System.out.println("Masina ruleaza la putere maxima!");
}

public static void main(String[] args) {

Car myObj = new Car();
myObj.fullThrottle(); // Apelul (chemarea) metodei
}
}
 METODELE CLASEI

De ce am declarat metoda ca doar publică și nu și statică?

Motivul este simplu: o metodă statică poate fi accesată fără a crea un obiect al clasei, în timp ce
metodele publice pot fi accesate doar de obiecte.

Putem folosi mai multe clase pentru o mai bună organizare (una pentru câmpuri și metode și alta
pentru execuție). De exemplu clasa care conține metoda main() sa fie folosită pentru execuție, iar
clasa Car să fie folosită pentru câmpuri și metode. Clasele fiind create în pagini separate.
 CONSTRUCTORI

Un constructor este o metodă specială care este folosită pentru inițializarea obiectelor. Avantajul unui
constructor este că se apelează automat atunci când este creat un obiect al unei clase.

Ca sintaxă, constructorul este de fapt o metodă cu acelasi nume ca al clasei din care face parte, dar care
nu are tip returnat de date. Pot fi creați oricât de mulți constructori in aceeași clasă, cu condiția să
primească un număr diferit de parametri.

Cel mai des poate fi utilizat pentru a seta valori inițiale pentru câmpuri:

class Car { //Creează o clasă

public String model; // Creează un câmp

public Car() { //Creează un constructor al clasei fără parametri

model = "Mustang"; // Setează valoarea inițială pentru câmpul model

}
}

Exercițiu: Creați două obiecte car1 și car2, apoi afișați modelul lor la consolă. Observați ce se întâmplă.
 CONSTRUCTORI

• Rețineți că numele constructorului trebuie să corespundă cu

numele clasei și acesta nu poate avea un tip de returnare (cum ar fi
void sau int)

• De asemenea, rețineți că constructorul este apelat automat la

crearea obiectului.

• Toate clasele au constructori în mod implicit: dacă nu creezi singur

un constructor al clasei , Java creează unul pentru tine. Cu toate
acestea, atunci nu puteți seta valori inițiale pentru câmpuri.

• Constructorii economisesc timp! Aruncați o privire la ultimul

exemplu pentru a înțelege cu adevărat de ce.
CONSTRUCTORII CU PARAMETRI

Constructorii pot lua de asemenea, parametri, care sunt utilizați pentru inițializarea câmpurilor.

Următorul exemplu adaugă un parametru String modelName la constructor. În interiorul constructorului

am setat modelul modelName (model = modelName). Când numim constructor, trecem un parametru
constructorului („Mustang”), care va seta valoarea modelului la „Mustang”:

class Car {
public String model;

public Car(String modelName) { //Constructor cu 1 parametru

model = modelName; //aici vom discuta de sintaxa (this)

}

static void main(String[] args) {

Car ford = new Car("Mustang");
System.out.println(ford.model);
}
}
Exercițiu: Creați două obiecte car1 și car2, apoi afișați modele diferite la consolă. Observați ce se întâmplă.
CONSTRUCTORII CU PARAMETRI

Puteți avea câți parametri doriți:

class Car {
public String model;
public String color;
public int year;

public Car(String modelName, String modelColor, int modelYear) { //Constructor cu mai multi parametri
model = modelName;
color = modelColor;
year = modelYear;
}

public static void main(String[] args) {

Car Ford = new Car("Mustang", "Red", 1969);

System.out.println(Ford.color + " " + Ford.year + " " + Ford.model);
}
}
Exercitii:
1. Creați o clasă numită Student cu variabila String name și variabila int roll_no. Alocați valoarea
roll_no cu 2 și cea a numelui cu John prin crearea unui obiect al clasei Student.
2. Alocați și afișați numărul roll_no, numărul de telefon și adresa a doi elevi cu nume Sam și respectiv
John prin crearea a două obiecte ale clasei Student.

3. Scrieți un program care să afișeze informațiile (numele, anul înscrierii, salariul, adresa) a trei angajați
prin crearea unei clase numită Employee. Afișarea trebuie să fie următoarea:
Name Year of joining Address
Robert 1994 64C – WallStreet
Sam 2000 68D – WallStreet //folositi spatierea cu TAB in formatarea Stringului
John 1999 26B – WallStreet

4. Sa se creeze clasa Person. Aceasta să conțină atributele (câmpurile) nume, vârstă, sex, adresă, si
funcționalitățile (metodele) walk(), eat(), sleep().
Creați 2 obiecte, un băiat și o fată, care să acceseze aceleași atribute și metode, dar cu rezultate diferite.
Metodele să afișeze doar ceva text.
Afișați ambele obiecte sub forma:
“Salut, ma numesc... , am ... ani, locuiesc in ...” - //accesand campurile
“Johnny merge pe strada.” //accesand metodele
“Mary doarme pana tarziu.” //scrieți voi logica și la celelalte metode