POO (Programare orientată pe obiect)

1. Încapsulare. Exemple în cel puțin 2 limbaje de programare.

În limbajele de programare orientată pe obiecte, noțiunea de încapsulare se referă la gruparea

datelor, împreună cu metodele care operează asupra acestor date, într-o unitate individuală. În
general, majoritatea limbajelor de programare utilizează încapsularea sub forma unor clase. O
astfel de clasă este un model de program-cod ce permite dezvoltatorilor să creeze un obiect care
dispune atât de variabile (adică date, caracteristici input), cât și de comportamente (adică funcții
sau metode, respectiv caracteristici output).Un exemplu tipic de încapsulare îl reprezintă clasele,
întrucât ele sunt formate din date și metode ce au fost ulterior grupate într-o singură unitate, după
cum am spus. În aceeași măsură, încapsularea definește și mecanismul prin care accesul direct la
unele componente ale unui obiect sunt restricționate, astfel încât utilizatorii nu pot accesa
valorile de stare pentru toate variabilele care definesc un anumit obiect. Cu alte cuvinte, este
„mecanismul de ascundere” a modului de implementare a datelor, pentru a restricționa accesul la
metodele publice. În acest scop, variabilele de instanță sunt păstrate private, iar metodele de
dezvoltare sunt făcute publice.

1.C++

class Student

string mNume;

float mMedie;

public:

Student(){};

Student(char *nume, float medie);

void set_nume(char *nume);

void set_medie(float medie);

char *get_nume();

float get_medie();
bool restantier();

};

#include “Student.h”

bool Student::restantier()

if ( mMedie < 5 )

return true;

else

return false;

void Student::set_nume(char *nume)

mNume = nume;

void Student::set_medie(float medie)

mMedie = medie;

Student::Student(char *nume, float medie)

mNume = nume;

mMedie = medie;

char* Student::get_nume()

return &mNume[0];
}

float Student::get_medie()

return mMedie;

2.Python

class JustCounter:

__secretCount = 0

def count(self):

self.__secretCount += 1

print self.__secretCount

counter = JustCounter()

counter.count()

counter.count()

print counter.__secretCount

2. Moștenire. Exemple în cel puțin 2 limbaje de programare.

Numită și derivare, moștenirea este un mecanism de refolosire a codului specific limbajelor

orientate obiect și reprezintă posibilitatea de a defini o clasă care extinde o altă clasă deja
existentă. Ideea de bază este de a prelua funcționalitatea existentă într-o clasă și de a adăuga una
nouă sau de a o modela pe cea existentă.Clasa existentă este numită clasa-părinte, clasa de bază
sau super-clasă. Clasa care extinde clasa-părinte se numește clasa-copil (child), clasa derivată sau
sub-clasă.
Moștenirea este un mecanism care permite crearea unor versiuni “specializate” ale unor clase
existente (de bază). Moștenirea este folosită în general atunci când se dorește construirea unui tip
de date care să reprezinte o implementare specifică (o specializare oferită prin clasa derivată) a
unui lucru mai general. Un exemplu simplu ar fi clasa Dacia care moștenește clasa Car.

1.C++

class persoana{

// corpul clasei de baza

};

class angajat: protected persoana{

double salariu;

};

2.Python

class Operations:

a = 10

b = 20

def add(self):

sum = self.a + self.b

print(“Sum of a and b is: “, sum)

class MyClass(Operations):

c = 50

d = 10

def sub(self):

sub = self.c – self.d

print(“Subtraction of c and d is: ”, sub)

ob = MyClass()

ob.add()
ob.sub()

3. Polimorfism. Exemple în cel puțin 2 limbaje de programare.

Polimorfismul este unul din conceptele esențiale din POO și reprezintă capacitatea unor entități
de

a lua forme diferite (polymorphism), sprijinind astfel scrierea de cod eficient cu costuri de

dezvoltare și întreținere reduse. Această facilitate este specifică limbajelor care permit “legarea

întârziată” la apelul metodelor, adresa de apel a unei metode stabilindu-se doar în momentul

rulării, spre deosebire de cele cu "legare timpurie" la care adresa se stabilește la compilare.

1.C++

class Figura {

protected:

int latime, inaltime;

public:

void setDimensiune(int latime, int inaltime){

this->latime=latime;

this->inaltime=inaltime;

void setDimensiune(int valoare){

this->latime=this->inaltime= valoare;

int daArie(){

return 0;

void scrie(){

cout<<"Figura"<<endl;
}

};

class Dreptunghi: public Figura{

public:

int daArie(){

return latime*inaltime;

void scrie(){

cout<<"Dreptunghi"<<endl;

};

class Triunghi: public Figura{

public:

int daArie(){

return latime*inaltime/2;

void scrie(){

cout<<"Triunghi"<<endl;

};

void main(){

Dreptunghi d;

Triunghi t;

Figura *f1 = &d; //atribuire valida

Figura *f2 = &t; //atribuire valida

f1->setDimensiune(1,2); //se apeleaza metoda din clasa de baza

f2->setDimensiune(1,2); se apeleaza metoda din clasa de baza

cout << f1->daArie() << endl;//afiseaza 0

cout << (static_cast<Triunghi*>(f2))->daArie() << endl;//afiseaza 1

2.Python

class AudioFile:

def _init_(self, filename):

if not filename.endswith(self.ext):

raise Exception("Format nesuportat")

self.filename = filename

class MP3File(AudioFile):

ext = "mp3"

def play(self):

print("se canta {} un mp3".format(self.filename))

class WavFile(AudioFile):

ext = "wav"

def play(self):

print("se canta {} un wav".format(self.filename))

class OggFile(AudioFile):

ext = "ogg"

def play(self):

print("se canta {} un ogg".format(self.filename))

class FlacFile:

def _init_(self, filename):

if not filename.endswith(".flac"):

raise Exception("Format necunoscut")

self.filename = filename

def play(self):

print("se canta {} un flac".format(self.filename))

if _name_ == '_main_':

filename = input('*.ogg file = ')

ogg = OggFile(filename)

ogg.play()

4. Supraîncarcare de operatori. Exemple în cel puțin 2 limbaje de programare.

Supraîncărcarea operatoriilor permite definirea comportamentului operatorilor când sunt aplicaţi

obiectelor unui nou tip de date(clase). Supraîncărcarea (supradefinirea, termenul overloading)
operatorilor permite atribuirea de noi semnificaţii operatorilor uzuali (operatorilor intâlniţi pentru
tipurile de date predefinite). Similară cu supraîncărcarea funcţiilor. Numele funcţiei este înlocuit
de cuvântul cheie operator urmat de simbolul operatorului.Tipul de return reprezintă tipul valori
care va fi rezultatul operaţiei.

1.C++

class complex{

public:

friend complex& operator+ (const complex&, const complex&);

... private:

double _real;

double _imag;

};

int main(){

complex c1, c2(4,5);

complex c3 = c1+c2;
cout << c3;

5. Functii virtuale. Exemple in cel putin 2 limbaje de programare.

În programarea orientată pe obiecte (POO), o funcție virtuală sau metodă virtuală este o funcție
al cărei comportament, în virtutea declarării acesteia ca fiind "virtuală", este determinat de către
definiția unei funcții cu aceeași semnătură cea mai îndepărtată pe linia succesorală a obiectului în
care este apelată. Acest concept este o foarte importantă parte din porțiunea de polimorfism a
paradigmei de programare pe obiecte (POO).Distincția dintre virtual (dinamic) și static este
făcută pentru a rezolva această problemă. Dacă funcția în cauză este etichetată drept "virtuală"
atunci funcția clasei derivate va fi apelată (dacă ea există). Dacă e statică, atunci va fi apelată
funcția clasei de bază.

De exemplu, o clasă de bază Animal poate avea o funcție virtuală eat. Sub-clasa Fish va
implementa eat() într-un mod diferit față de sub-clasa Wolf, dar poți invoca metoda eat() în
cadrul oricărei instanțe de clasă de referință Animal, și obține o comportare specifică clasei
derivate pentru care această metodă a fost redefinită. Aceasta îi dă posibilitatea programatorului
să proceseze o listă de obiecte din clasa Animal, spunându-i fiecăruia pe rând să mănânce
(apelând funcția eat()), fără a ști ce fel de animal se poate afla pe listă. Nici măcar nu trebuie să
știi cum mănâncă fiecare animal, sau care ar putea fi setul complet de tipuri posibile de animale.

1)Următorul este un exemplu în C++:

#include <iostream>

using namespace std;

class Animal

public:

virtual void eat() { cout << "Eu mănânc așa cum o poate face orice Animal.\n"; }

};
class Wolf : public Animal

public:

void eat() { cout << "Eu înfulec ca un lup!\n"; }

};

class Fish : public Animal

public:

void eat() { cout << "Eu mă hrănesc ca un pește!\n"; }

};

class OtherAnimal : public Animal

};

int main()

Animal *anAnimal[4];

anAnimal[0] = new Animal();

anAnimal[1] = new Wolf();

anAnimal[2] = new Fish();

anAnimal[3] = new OtherAnimal();

 for(int i = 0; i < 4; i++)

anAnimal[i]->eat();

2.Java

abstract class Dog {

final void bark() { //bark() is not virtual because it is
System.out.println("woof"); //final and if you tried to override it
} //you would get a compile time error.

abstract void jump(); //jump() is a "pure" virtual function

}
class MyDog extends Dog{
void jump(){
System.out.println("boing"); //here jump() is being overridden
}
}
public class Runner {
public static void main(String[] args) {
Dog dog = new MyDog(); // Create a MyDog and assign to plain Dog variable
dog.jump(); // calling the virtual function.
// MyDog.jump() will be executed
// although the variable is just a plain Dog.
}
}

Subiect 2.

2.1. Identificati un domeniu D si enuntati o problema P din acel domeniu D

2.2. Proiectati o ierarhie de clase care acopera problema P

2.3. Implementati rezolvarea problemei intr-un limbaj OO

Să se realizeze un program din domeniul cinematografiei ce foloseşte o problema, clasă Film cu

următorii membrii:

-Nume (titlu film)

-actor principal

-actor secundar

Se cere afişarea membrilor. Se vor utiliza funcţii constructor şi destructor. #include<iostream.h>

#include<stdio.h>

using namespaces std;

class film {

private:

char nume[35];

char actp[35];

char acts[35];

public:

film()

cout<<"\n S-a apelat constructorul clasei film";

cout<<"\n Introduceti numele filmului: ";

gets(nume);

cout<<" Actorul principal: "; gets(actp);

cout<<" Actorul secundar: "; gets(acts);

~film()

cout<<"\n Se trece prin destructorul clasei film";

void afisare_film()

cout<<"\n Nume film: "<<nume;

cout<<"\n Actor principal: "<<actp;

cout<<"\n Actor secundar: "<<acts<<endl;

}; int main()

film f1, f2;

f1.afisare_film();

f2.afisare_film();