Interface

Interfata (interface)

Definitie

Interfata reprezinta un mecanism prin care o clasa C utilizeaza date si servicii oferite de instante ale unor clase A1, A2,. . ., An, in mod independent de acestea, accesand clasele Ai prin intermediul unei interfete.

Context

Sa presupunem ca trebuie scrisa o aplicatie de gestiune a activitatii unui agent comercial de aprovizionare cu bunuri de consum. Programul va necesita informatii in legatura cu entitati ca: furnizori, companii de transport, depozite etc. Este foarte probabil ca modelarea acestor entitati sa se realizeze cu ajutorul cate unei clase distincte, specifice (ele vor corespunde claselor Ai din definitie). Exista insa cel putin un element comun care le caracterizeaza: adresa postala. Deoarece adresele apar in mai multe parti ale interfetei utilizator, avem nevoie de o clasa care sa permita editarea si afisarea adreselor, dar care sa poata fi reutilizata ori de cate ori avem de a face cu adrese. Fie AddressPanel numele acestei clase (corespondenta clasei C din definitie).
AddressPanel trebuie sa poata regasi si seta informatia de adresa in obiecte diferite (pe care le vom denumi cu un nume generic DataClass), fara a fi afectata de aceasta diversitate.
Daca implementarea se va face in C++, care permite mostenirea multipla, problema se poate rezolva impunand ca obiectele DataClass sa derive (pe langa eventuale alte superclase) si dintr-o clasa AddressIF, care sa joace rol de intermediar. AddressIF poate fi o clasa abstracta.
Daca limbajul folosit pentru implementare este Java, care nu admite mostenire multipla, AddressIF va trebui sa fi o interfata, iar obiectele DataClass vor implementa aceasta interfata:

Motivatii

Daca instantele unei clase A trebuie sa utilizeze un obiect despre care se presupune din start ca apartine unei clase particulare B, atunci perspectivele de reutilizare ale clasei A sunt minime.
Presupunem ca instantele unei clase A utilizeaza alte obiecte de la care se pretinde doar sa implementeze anumite metode. Pentru a limita dependenta clasei A fata de obiectele respective doar la aceasta cerinta, se defineste o interfata ce inglobeaza metodele necesare si se proiecteaza clasa A astfel incat sa faca referinta la interfata.

Solutie

Pentru a evita cuplajul intre clase rezultat prin faptul ca unele le utilizeaza pe altele, practic se indirecteaza utilizarea, plasand o interfata intre clasele "client" si cele "server":

Consecinte

Aplicand sablonul Interfata se previne cuplarea unei clase care are nevoie de un serviciu, de o clasa care ofera acel serviciu. Ca orice indirectare, insa, Interface poate face ca un program sa fie mai putin clar.

Implementare

Se defineste o interfata (interface in Java sau clasa abstracta in C++) in care se declara operatiile corespunzatoare serviciilor necesare. Clasele client vor contine o referinta la interfata, iar clasele server vor implementa interfata (implements in Java, respectiv derivate public din clasa abstracta in C++).
Considerand exemplul din paragraful "Context", putem scrie:

// varianta Java
public interface AddressIF {
    public String getAddr( );
    public void setAddr( String addr);
    public String getCity( );
    public void setCity(String city);
}
public class AddressPanel {
    private AddressIF obServer;
    public void save( ) {
        if (obServer != null ) {
            obServer.setAddress(getText( ));
            obServer.setCity(getText( ));
        }
    }
    //. . .
}
public class Furnizor implements AddressIF {
    // clasa Furnizor poate eventual sa si extinda o anumita superclasa, daca e cazul
    private String addr;
    private String city;
    public String getAddr( ) { return addr; }
    public void setAddr( String addr) { this.addr = addr; }
    //. . .
}

// varianta C++
class AddressIF {
    public:
        String getAddr( ) = 0;
        void setAddress(String) = 0;
        String getCity( ) = 0;
        void setCity(String) = 0;
};
class AddressPanel {
    private:
        AddressIF *obServer;
    public:
        void save( ) {
             if (obServer != 0 ) {
                obServer -> setAddress(getText( ));
                obServer -> setCity(getText( ));
            }
        }
        //. . .
};
class Furnizor : public AddressIF {
    // clasa Furnizor poate eventual sa derive si din alte superclase, daca e cazul
    private:
        String addr;
        String city;
    public:
        String getAddr( ) { return addr; }
        void setAddr( String addr) { this -> addr = addr; }
    //. . .
};

Tema

Se cere sa se realizeze:

o clasa Buffer cu rol de interfata, avand declarate operatiile

void Adauga(int elem) - pt. adaugarea unui element dat ca parametru;
void Extrage(int elem) - pt. eliminarea unui element dat ca parametru;

o clasa Vector, o clasa Lista si o clasa Multime care sa implementeze operatiile de mai sus, pe langa alte operatii specifice; astfel, Vector va mai avea o operatie care sa returneze valoarea elementului cu un anumit indice dat, Lista va avea o operatie de inserare a unui element la o pozitie specificata, iar Multime va avea o operatie de reuniune a 2 multimi;

o clasa cu rol de client care sa apeleze operatiile Adauga si Extrage, prin intermediul lui Buffer, pentru obiecte de tip Vector, Lista, respectiv Multime.