Examen: Programare Orientata pe Obiecte

1. Explicați efectul instrucțiunilor //1, //2, //3 și //4. Precizați ce mesaje sunt afișate.
#include <iostream.h> class D: public B{ void main(){
class B{ public: B *pb;
public: D(){cout<<"D()"<<endl;} pb=new D(); //1
B(){cout<<"B()"<<endl;} virtual ~D(){cout<<"~D()"<<endl;} pb->m(); //2
virtual ~B(){cout<<"~B()"<<endl;} virtual void m(){cout<<"D::m()"<<endl;} pb->s(); //3
virtual void m(){cout<<"B::m()"<<endl;} void s(){cout<<"D::s()"<<endl;} delete pb; //4
void s(){cout<<"B::s()"<<endl;} }; }
};

2. Considerați următoarea definiție a clasei TwoDim.

2.1. Să se supraîncarce operatorul << astfel încât instrucțiunea // 1 să afișeze
*px=1; *py =2;
2.2. Explicați rezultatul afișat de instrucțiunea // 3
2.3. Supraîncărcați operatorul = astfel încât instrucțiunea //3 să afișeze *px=100; *py =200;
#include <iostream.h> void main(){
class TwoDim{ TwoDim x(1,2), y(10,20);
public: cout<<x<<endl; // 1
TwoDim(int x, int y){ px=new int; x=y; // 2
py=new int; *px=x; *py=y; x.set(100,200);
} y.set(1000,2000);
void set(int x, int y){*px=x; *py=y;} cout<<x<<endl; // 3
private: }
int *px, *py;
friend ostream& operator<<(ostream& o, const TwoDim t);
};

3. Adăugați programului de mai jos clasa Impl astfel încât prin executarea programului să fie
afișat mesajul
Hello, Tudor!
public class Interf{ interface ModAfisare{
public static void main(String[] args){ public void afisare(String s);
ModAfisare ma= new Impl("Tudor"); }
ma.afisare("Hello");
}
}

4. În următorul program Java vi se cere să explicați:

4.1. Rezultatele afișate;
4.2. Rezultatele afișate, daca linia //synchr este stearsă;
4.3. Rezultatele afișate, daca linia //static este stearsă (dar //synchr este prezentă);
4.4. Ce se intamplă dacă se înlocuiește cuvântul cheie while prin if?
class Fir extends Thread{
static int x=0;
public class ExecFir{
static //static
public static void main (String[] args){
Object sem =new Object();
Fir f1, f2;
int t;
f1= new Fir(); f1.start();
void incr() {
f2= new Fir(); f2.start();
synchronized(sem) //synchr
while(f1.isAlive() || f2.isAlive()){}
{t=x;t++; x=t;}
System.out.println("x="+Fir.x);
}
}
public void run() { incr();}
}
}
Examen: Programare Orientata pe Obiecte

5. Se consideră următoarea interfaţă Java, în care sunt definite câteva operaţii elementare asupra
listelor de obiecte:
interface ListOperations{
public void add(Object o);// adauga un obiect in lista
// returneaza, fara a sterge,
// elementul curent din lista
public Object currentElement();
public void delete();// sterge elementul curent
}

Se cere să implementaţi această interfaţă printr-o clasă Queue ale cărei obiecte sunt liste eterogene First
In First Out (cozi în care elementul current are cea mai mare vechime în listă şi este indicat de cursor).
Aceste liste sunt observabile în sensul următor: când cursorul este deplasat, noul element curent este
transmis către toate obiectele observatoare (aici includem şi cazul în care se adaugă un element într-o
listă vidă).
Obiectele observatoare sunt din clasa QueueObserver, pe care trebuie de asemenea s-o definiţi.
Completând corespunzător //…1, //…2, //…3 şi //…4, programul test de mai jos trebuie să afişeze
rezultatele următoare:

100
100
Tudor
Andrei

class Queue //. . .1

public Queue(int mD){maxDim=mD; v=new Object[maxDim];}
// metode
//. . .2
//atribute
private int free=0; //pozitia libera
private int cursor=0;// pozitia cu elementul util
// 0<=numberOfElements<=maxDim,
//numarul real de elemente din coada
private int numberOfElements=0;
private Object v[];
private int maxDim;
}

class QueueObserver //. . .3

public QueueObserver(Queue q){obsQ=q;}
// metoda update
//. . .4

// atribute
private Queue obsQ; // coada observabila

public class ObservableList{ q.add(new Integer(400));

public static void System.out.println
main(String[] args){ (q.currentElement());
Queue q=new Queue(4); q.delete();
QueueObserver qO= new q.add(new Integer(500));
QueueObserver(q); q.delete();
q.addObserver(qO); q.add(new Integer(100));
q.add(new Integer(100)); }
q.add("Tudor"); }
q.add("Andrei");