Universitatea Lucian Blaga din Sibiu

Facultatea de tiine
Catedra de Matematic i Informatic

Disciplina: Metode avansate de programare

Cadru didactic: Ralf Fabian
Specializarea: Informatic, anul III.

Interfee n Java
O clase conine atribute i metode. Metodele se compun dintr-un capul (prototip) i un corp.
Capul de metod reprezint interfaa unui obiect cu lumea exterioar.
Interfeele permit, ca i clasele, definirea unor noi tipuri de date. O interfa Java definete
un set de metode dar nu specific nici o implementare pentru ele. O clas care implementeaz o
interfa trebuie obligatoriu s specifice implementri pentru toate metodele interfeei,
supunndu-se aadar unui anumit comportament.
Pentru c este posibil ca o clas s implementeze mai mult de o interfa, interfeele
reprezint o alternativ pentru motenirea multipl, care nu este permis n Java.

Definirea unei interfee

O interfa este declarat ntr-un mod asemntor cu o clas, doar c n locul cuvntului
class se folosete cuvntul cheie interface.
[public] interface NumeInterfata
[extends SuperInterfata1, SuperInterfata2...]{
// Corpul interfetei:
// Date membre constante
// Metode membre funcii abstracte, metode fr implementare
}

O interfa poate avea un singur modificator i anume public. O interfa public este
accesibil tuturor claselor, indiferent de pachetul din care fac parte, implicit nivelul de acces fiind
doar la nivelul pachetului din care face parte interfaa.
Spre deosebire de motenirea claselor, cuvntul cheie extends permite specificarea a mai
multor interfee, separate prin virgul, care pot fi combinate ntr-o unitate logic mai mare.

Date membre constante

Modificatorii pentru datele membre ale unei interfee, se limiteaz la un anumit set: public,
static, final. Prin urmare variabilele membre din interfee pot avea doar valori constante.
Modificatorii public, static final sunt implicii, adic, declararea lor explicit nu este necesar, dar
uureaz nelegerea codului.
interface Test{
int PI = 3.14;
// Echivalent cu:
public static final int PI = 3.14;
int MAX;

// Incorect, lipseste initializarea

private int x = 1;

// Incorect, modificator nepermis

Metode membre fr implementare

Modificatorii pentru metode se limiteaz la: public. Acesta este implicit, prezena lui nefiind
necesar, dar uureaz nelegerea codului.
interface Test{
void functie();
// Echivalent cu:
public void functie();
}

Implementarea unei interfee

Implementarea uneia sau mai multor interfee de ctre o clas se face prin intermediul
cuvntului cheie implements:
class NumeClasa implements NumeInterfata

sau
class NumeClasa implements Interfata1, Interfata2, ...

sau
class NumeClasa1 extends NumeClasa2 implements Interfata1, Interfata2, ...

O clas poate implementa oricte interfee sau nici una. In cazul n care implementeaz o
anumit interfa, atunci trebuie obligatoriu s specifice cod pentru toate metodele interfeei
respective.
Interfeele i superclasele nu se exclud reciproc. O clas nou poate fi derivat dintr-o
superclas i poate implementa una sau mai multe interfee.
Modificarea unei interfee (adugarea unor metode noi sau schimbarea signaturii metodelor
existente) implic modificarea tuturor claselor care implementeaz acea interfa.
O clas poate avea i alte metode i variabile membre n afar de cele definite n interfa.
Implementarea unei interfee poate s fie i o clas abstract.
interface Ceas {
public String citesteTimpul();
}
class CeasCuLimbi implements Ceas {
public String citesteTimpul() {
String str ="CeasCuLimbi";
java.util.Date data = new java.util.Date();
for (int i=1; i <= data.getHours(); i++)
str=str+" "+i;
return str;
}
}
class CeasElectronic implements Ceas{
public String citesteTimpul(){
java.util.Date data = new java.util.Date();
return new String("CeasElectronic
"+data.getHours()+":"+data.getMinutes()+":"+data.getSeconds());
}
public static void main(String args[]){
System.out.println(new CeasCuLimbi().citesteTimpul());

System.out.println(new CeasElectronic().citesteTimpul());
}
}

Output-ul va fi:
CeasCuLimbi 1 2 3 4 5 6 7 8
CeasElectronic 8:28:11

Interfaa ca tip de date

O interfa nu este o clas ca urmare nu se pot instana obiecte de tip interfa, dar orice
referin de tip interfa poate primi ca valoare o referin la un obiect al unei clase ce
implementeaz interfaa respectiv. Din acest motiv, interfeele pot fi privite ca tipuri de date i se
poate spune c un obiect are tipul X, unde X este o interfa, dac acesta este o instan a unei clase
ce implementeaz interfaa X. Pentru exemplul de mai sus avem:
Ceas c;
c = new Ceas();
c=new CeasCuLimbi();

//Eroare, nu se pot instanta obiecte de tip Ceas

//Corect, pt. ca CeasCuLimbi implementeaza Ceas

Iniializarea cmpurilor din interfee

Cmpurilor din interfee sunt automat statice i finale dar ele pot fi iniializate cu expresii
neconstante, ca de exemplu:
import java.util.*;
public interface RandVals {
Random rand = new Random();
int randomInt = rand.nextInt(10);
long randomLong = rand.nextLong() * 10;
float randomFloat = rand.nextLong() * 10;
double randomDouble = rand.nextDouble() * 10;
}

ntruct cmpurile sunt statice ele vor fi iniializate la prima ncrcare a clasei, ceea ce are
loc la primul acces a unuia dintre cmpuri.

Gruparea de constate
Interfeele sunt instrumente utile pentru a realiza o grupare de constante, dat fiind natura
static i final a cmpurilor acestora.
public interface Lunile {
int
IANUARIE = 1, FEBRUARIE = 2, MARTIE = 3,
APRILIE = 4, MAI = 5, IUNIE = 6, IULIE = 7,
AUGUST = 8, SEPTEMBRIE = 9, OCTOMBRIE = 10,
NOIEMBRIE = 11, DECEMBRIE = 12;
}

Valorile acestor constant pot fi accesate din exterior prin expresii de forma
Lunile.NOIEMBRIE, evident c rezultatul va fi un int. Pentru obinerea unei sigurane de tip

(type safety) mai ridicate se poate scrie o clas de forma:

public final class Luni {

private String nume;
private Luni(String nl) { nume = nl; }
public String toString() { return nume; }
public static final Luni IAN = new Luni("Ianuarie"),
FEB = new Luni("Februarie"),
MAR = new Luni("Martie"),
APR = new Luni("Aprilie"),
MAI = new Luni("Mai"),
IUN = new Luni("Iunie"),
IUL = new Luni("Iulie"),
AUG = new Luni("August"),
SEP = new Luni("Septembrie"),
OCT = new Luni("Octombrie"),
NOI = new Luni("Noiembrie"),
DEC = new Luni("Decembrie");
public static final Luni[] lunile = {
IAN, FEB, MAR, APR, MAI, IUN,
IUL, AUG, SEP, OCT, NOI, DEC
};
public static final Luni numar(int ord) {
return lunile[ord - 1];
}
public static void main(String[] args) {
Luni m = Luni.IAN;
System.out.println(m);
m = Luni.numar(12);
System.out.println(m);
System.out.println(m == Luni.DEC);
System.out.println(m.equals(Luni.DEC));
System.out.println(Luni.lunile[3]);
}
}

Output-ul este
Ianuarie
Decembrie
true
true
Aprilie

Luni este o clas final cu constructor privat, aa c nu pot exista derivri sau instane ale
acestei clase. Singurele instane, sunt cele finale i statice create n interiorul clasei: IAN, FEB, etc.
Ele sunt folosite i n vectorul lunile ceea ce permite o iteraie pe un vectori de obiecte de tip
Luni. Metoda numar() permite selectarea unei luni pe baza unui numr dat.
n funcia principal variabila m este un obiect de tip Luni, spre deosebire de exemplul de
mai sus, unde era de tip int, permind astfel o asociere cu orice valoare ntreag.

Interfee vs. clase Abstracte

Clase
abstracte

Interfee

Variabile
Fr restricii

Constructor
Nu poate fi instaniat cu
operatorul new.
Constructorii se apeleaz
de subclase prin nlnuire
de constructori.
Toate variabilele trebuie Nu exist constructori. O
s fie declarate
interfa nu poate fi
public static final
instaniat cu operatorul
new.
4

Metode
Fr restricii.

Toate metodele trebuie

s fie public abstract.

Interfee pentru compararea obiectelor

O soluie simpl de sortare a unui vector este folosirea metodei sort din clasa
java.util.Arrays.
int v[]={3, 1, 4, 2};
java.util.Arrays.sort(v);
// Sorteaza vectorul v
// Acesta va deveni {1, 2, 3, 4}

n cazul n care elementele din vector sunt de tip primitiv nu exist nici o problem n a
determina ordinea fireasc a elementelor.
Pentru a vedea ce se ntmpl atunci cnd vectorul conine referine la obiecte s considerm
urmtorul exemplu, n care urmrim s sortm un vector format din instane ale clasei Persoana.
class Persoana {
int cod ;
String nume ;
public Persoana ( int cod , String nume ) {
this.cod = cod;
this.nume = nume ;
}
public String toString () {
return cod + " \t " + nume ;
}
public static void main ( String args []) {
Persoana p[] = new Persoana [4];
p[0] = new Persoana (6, " Ionescu ");
p[1] = new Persoana (1, " Vasilescu ");
p[2] = new Persoana (3, " Georgescu ");
p[3] = new Persoana (4, " Popescu ");
java . util . Arrays . sort (p);
//nu se poate aplica pt. ca p este un vector de obiecte
}
}

Interfaa Comparable
Interfaa Comparable impune o ordine total asupra obiectelor unei clase ce o
implementeaz. Aceast ordine este specificat prin intermediul metodei compareTo. Definiia
interfeei este:
public interface Comparable {
int compareTo(Object o);
}

Aadar, o clas ale crei instane trebuie s fie comparabil ntre ele va implementa metoda
compareTo care poate returna:
valoare strict negativ: dac obiectul curent (this) este mai mic dect obiectul primit ca
argument;
zero: dac obiectul curent este egal cu obiectul primit ca argument;
valoare strict pozitiv: dac obiectul curent este mai mare dect obiectul primit ca argument.

Pentru o ordonare a persoanelor dup codul lor intern se procedeaz astfel:

class Persoana implements Comparable {
int cod ;
String nume ;
public Persoana ( int cod , String nume ) {
this.cod = cod;
this.nume = nume ;
}
public String toString () {
return cod + " \t " + nume ;
}
public boolean equals ( Object o) {
if (!( o instanceof Persoana ))
return false ;
Persoana p = ( Persoana ) o;
return (cod == p.cod) && ( nume . equals (p. nume ));
}
public int compareTo ( Object o) {
if (o== null ){
System.out.println("Lipseste un obiect!");
System.exit(-1);
}
if (!( o instanceof Persoana )){
System.out.println("Nu pot compara!");
System.exit(-2);
}
Persoana p = ( Persoana ) o;
return (cod - p.cod );
}
}

Interfaa Comparator
Pentru cazul n care se dorete o sortare a elementelor unui vector, ce conine referine, dup
alt criteriu dect ordinea natural a elementelor, exist o soluie oferit tot de metoda sort din clasa
java.util.Arrays, dar n varianta n care, pe lng vectorul ce trebuie sortat, se transmite un
argument de tip Comparator care s specifice modalitatea de comparare a elementelor.
Interfaa java.util.Comparator conine metoda compare, care impune o ordine total
asupra elementelor unei colecii. Aceasta returneaz un ntreg cu aceeai semnificaie ca la metoda
compareTo a interfeei Comparable i are urmtoarea definiie:
public int compare(Object o1, Object o2);

Pentru o ordonare dup numele persoanelor se poate proceda astfel:

import java.util.*;
class Sortare {
public static void main ( String args []) {
Persoana p[] = new Persoana [4];
p[0] = new Persoana (3, " Ionescu ");
p[1] = new Persoana (1, " Vasilescu ");
p[2] = new Persoana (2, " Georgescu ");
p[3] = new Persoana (4, " Popescu ");
Arrays.sort (p, new Comparator () {
public int compare ( Object o1 , Object o2) {
Persoana p1 = ( Persoana )o1;
Persoana p2 = ( Persoana )o2;
return (p1.nume.compareTo(p2.nume ));

}//implementare cu clasa interna anonima

});
System.out.println(" Persoanele ordonate dupa nume :");
for (int i=0; i<p.length ; i++)
System.out.println (p[i]);
}
}

Compararea a dou iruri de caractere se face tot cu metoda compareTo, clasa String
implementnd interfaa Comparable.