Laborator 3.

Programare orientată obiect

1. Constructori – metode speciale fără tip de return care inițializează obiectele în momentul creării
lor cu new; un constructor se apelează automat în momentul crearii unui obiect cu new.
// SimpleConstructor2.java
//Constructorii pot fi cu sau fara argumente.
class Rock2 {
Rock2(int i) { //constructor cu argumente
System.out.println("Rock " + i + " ");
}
}
public class SimpleConstructor2 {
public static void main(String[] args) {
Rock2 obj;
for(int i = 0; i < 8; i++)
obj=new Rock2(i); //se creaza 8 obiecte din clasa Rock2
//instantierea se face cu trimiterea argumentului i - asa cum o cere constructorul Rock2
//se vor afisa 8 mesaje - deoarece se va apela de 8 ori constructorul Rock2(int i)
}
}

2. Supraîncărcarea metodelor – într-o clasă putem avea același identifcator (nume) utilizat la
definirea mai multor metode, dar fiecare metodă trebuie să aiba argumente diferinte și același tip
de return.
// Overloading.java
//Constructorii pot fi supraincarcati
//metodele dintr-o clasa pot fi supraincarcate
class Tree {
int height;
Tree() { //constructor implicit fara argumente
System.out.println("Planting a seedling");
height = 0;
}
//constructorii supraincarcati ofera flexibilitate in initialirea obiectelor
Tree(int initialHeight) { //acelasi constructor Tree supraincarcat cu un argument
height = initialHeight;
System.out.println("Creating new Tree that is " + height + " feet tall");
}
//metode supraincarcate
void info() { //metoda info fara argumente cu tip de return void
System.out.println("Tree is " + height + " feet tall");
}
void info(String s) { //metoda info cu argumente cu tip de return void
System.out.println(s + ": Tree is " + height + " feet tall"); }
}
 public class Overloading {
public static void main(String[] args) {
for(int i = 1; i < 5; i++) {
Tree t = new Tree(i); //instantiere utilizand constructorul supraincarcat cu un argument
t.info(); //apel metoda info() fara argumente
t.info("overloaded method"); //apel metoda info cu argument
}
Tree t=new Tree(); //instantierea obiectului t prin constructorul fara argument
}
}

3. Utilizarea this
//Leaf.java
public class Leaf { //clasa Leaf
int i = 0; //atribut in clasa Leaf
Leaf increment() { //metoda ce returneaza un obiect de tip Leaf
i++;
return this; // se returneaza obiectul curent
}
void print() { //metoda in clasa Leaf
System.out.println("i = " + i);
}
public static void main(String[] args) {
Leaf x = new Leaf(); //instantiere
x.increment().increment().increment().print(); //3 apeluri ale metodei increment
//fiecare apel al metodei increment schimba valoarea atributlui i si returneaza obiectul cu noua
//valoare; fiecare apel increment() returneaza un obiect de tip Leaf
}
}

4. Utilizarea finalize
În programul de mai jos, se presupune că o carte (Book) trebuie să fie în mod necesar “checkin” înainte
ca aceasta să fie ”distrusă”. Observăm ca există o carte pentru care nu se face checkin și la apelul
forțat al garbage collector-ului, va apărea mesajul de eroare din finalize().

//TerminationCondition.java
class Book {
boolean checkedOut = false;
Book(boolean checkOut) { //constructor cu argument
checkedOut = checkOut; //initializeaza atributul checkedOut cu valoarea trimisa prin argument
}
 void checkIn() { //metoda checkin
checkedOut = false;
}
protected void finalize() { //utilizarea finalize() in clasa Book
//inainte de distrugerea obiectelor cu garbage collector se va apela metoda finalize()
if(checkedOut) //daca atributul checkedOut e True - se afiseaza eroare
System.out.println("Error: checked out");
// Normally, you’ll also do this:
// super.finalize(); // Call the base-class version
}
}
public class TerminationCondition {
public static void main(String[] args) {
Book novel = new Book(true); //creare obiect novel de tip Book
// Proper cleanup:
novel.checkIn(); //dupa utilizare - se da checkin() - obiectul se poate sterge
// Drop the reference, forget to clean up:
new Book(true); //se creaza un nou obiect din clasa Book
// Force garbage collection & finalization:
System.gc();
//se apeleaza garbage collector - ce determina executia finalize() din clasa Book
//pentru ca la cel de-al doilea obiect nu s-a apelat metoda checkIn() - se va afisa mesajul de eroare
}
}

5. Ordinea de inițializare – ordinea în care datele membre/atributele sunt definite în clasă

//OrderOfInitialization.java
class Window {
Window(int marker) { //constructor
System.out.println("Window(" + marker + ")");
}
}
class House {
Window w1 = new Window(1); // (1) initializare (apelul constructorului Window din clasa Window)
// se face inainte de apelul constructorului House()
House() { //constructor in clasa House()
// Show that we’re in the constructor:
System.out.println("House()");
w3 = new Window(33); // (4) reinitializare w3 dupa ce ultima initializare implicita a avut loc (pct. 3)
}
Window w2 = new Window(2); // (2) initializare inainte de apelul constructorului House()
void f(){
System.out.println("f()");
}
Window w3 = new Window(3); //(3) ultima initializare implicita - inainte de apelul constructorului House()
}
public class OrderOfInitialization {
public static void main(String[] args) {
//instantierea ob House (apelul constructorului House()) determina initializarea in ordinea de mai sus
House h = new House();
h.f(); // Shows that construction is done
}
}

6. Initializarea static – atributele statice se initializeaza o singura data; daca acestea au fost deja
intializate, ele nu se reinitializeaza.
//StaticInitialization.java
class Bowl {
Bowl(int marker) { //constructor in clasa Bowl
System.out.println("Bowl(" + marker + ")");
}
void f1(int marker) { //metoda in clasa Bowl
System.out.println("f1(" + marker + ")");
}
}
class Table {
static Bowl bowl1 = new Bowl(1); //(init. 1) membru static de tip Bowl in clasa Table
Table() { //apelul constructor se face dupa initializarea atributelor statice din clasa
System.out.println("Table()");
bowl2.f1(1); //apel catre metoda f1()
}
void f2(int marker) { //metoda in clasa Table
System.out.println("f2(" + marker + ")");
}
static Bowl bowl2 = new Bowl(2); //(init. 2) membru static de tip Bowl in clasa Table
}
class Cupboard {
//initializarea membrilor non-statici se face dupa initializarea celor statici din clasa
Bowl bowl3 = new Bowl(3); //membru non static de tip Bowl in Cupboard
static Bowl bowl4 = new Bowl(4); //(init.3) membru static de tip Bowl in clasa CupBoard
Cupboard() { //constructor in Cupboard
System.out.println("Cupboard()");
bowl4.f1(2);
}
void f3(int marker) {
System.out.println("f3(" + marker + ")");
}
static Bowl bowl5 = new Bowl(5);//(init. 4) membru static
}

public class StaticInitialization {

public static void main(String[] args) {
System.out.println("Creating new Cupboard() in main");
new Cupboard();
System.out.println("Creating new Cupboard() in main - !!!atributele statice nu mai sunt initializate");
new Cupboard(); //!!! la a doua instantiere se initializeaza doar atributele non-statice
table.f2(1);
cupboard.f3(1);
}
static Table table = new Table();
static Cupboard cupboard = new Cupboard();
}
Astfel, ordinea de initializare a atributelor în clasă devine:
• Se inițializează atributele/obiectele statice în ordinea în care apar în clasă, dacă acestea nu
au fost anterior inițializate.
• Se inițializeaza atributele/obiectele non-statice în ordinea în care apar în clasă. Cuvântul
static se poate aplica numai atributelor din clase si nu variabilelor locale. Dacă un atribut
nu este initializat explicit, atunci Java asigură inițializarea cu valoarea implicită a tipului (ex:
pentru int valoarea implicită este 0; pentru obiecte valoarea implicită este null).

7. Initializarea prin explicit static

class Cup {
Cup(int marker) {
System.out.println("Cup(" + marker + ")");
}
void f(int marker) {
System.out.println("f(" + marker + ")");
}
}
class Cups {
static Cup cup1;
static Cup cup2;
static { // blocul static explicit de initializare
cup1 = new Cup(1);
cup2 = new Cup(2);
}
Cups() { // constructor default
System.out.println("Cups()");
}
}
public class ExplicitStatic {
public static void main(String[] args) {
System.out.println("Inside main()");
Cups.cup1.f(99); // (1) acces la membrii statici fara instantiere
//initializarea statica se face si in acest caz - prin simpla referire
}
//initializarea statica se face inainte de instantiere - la incarcarea clasei
//static Cups cups1 = new Cups(); // (2)
//static Cups cups2 = new Cups(); // (2) }
 8. Initializare non-statica – mecanism denumit instance-initialization – initializare la nivel de
instanta
//Mugs.java
class Mug {
Mug(int marker) {
System.out.println("Mug(" + marker + ")");
}
void f(int marker) {
System.out.println("f(" + marker + ")");
}
}

public class Mugs {

Mug mug1;
Mug mug2;
{ // bloc non-static de initializare - se face la fiecare instantiere cu new a clasei
mug1 = new Mug(1);
mug2 = new Mug(2);
System.out.println("mug1 & mug2 initialized");
}
Mugs() {
System.out.println("Mugs()");
}
Mugs(int i) {
System.out.println("Mugs(int)");
}
public static void main(String[] args) {
System.out.println("Inside main()");
Mugs o1 = new Mugs(); //determina initializare a atributelor in o1
System.out.println("new Mugs() completed");
Mugs o2 = new Mugs(1); //determina reinitializarea atributelor in o2 (o1 raman neschimbate)
System.err.println("new Mugs(1) completed");
//o1 si o2 sunt doua obiecte distincte (instante ale clasei Mugs)
//a caror atribute non-statice pot lua valori diferite in fiecare obiect
}
}

9. Initializarea sirurilor de obiecte

Creati o clasa care este caracterizata de un atribut de tip String. Tot in aceasta clasa creati un constructor
supraincarcat care sa initializeze atributul din clasa. In constructor, tipariti valoarea primita ca si argument.

In main, creati un sir de obiecte de tip String si initializati fiecare obiect din sir. Tipariti sirul folosind un for.
Creati un sir de referinte catre obiecte din clasa creata, dar fara a crea obiectele din sir. Initializati sirul cu
obiecte din clasa creata. La executia programului, vedeti daca mesajul din constructor este tiparit.