No Slide Title

JAVA –Interface
ATAI
1
Interfaces em JAVA
As Interfaces JAVA podem ser uma alternativa à construção de
classes em situações a que o mecanismo de herança não consegue
dar solução por se basear na hierarquia directa de classes
Problema típico: pretende-se que as classes D e F, e apenas estas,
implementem os métodos m1 e m2
Object
B
D
m1
m2
C
E
F
m1
m2
2
Interfaces em JAVA
Interfaces:
são especificações sintácticas de conjuntos de métodos, que
qualquer classe, em qualquer ponto da hierarquia, pode querer
implementar (localmente), ou seja, definem requisitos operacionais
Problemas que o mecanismo de Interfaces tenta melhorar/resolver
relativamente a outras linguagens OO

resolução do problema da herança múltipla

definição clara de tipos de dados definidos pelo utilizador e
implementação de tais tipos de dados

possibilidade de garantir que classes não relacionáveis na hierarquia
e, portanto, por herança, partilham propriedades comportamentais, ou
seja, implementam o comportamento especificado
3
Declaração de Interfaces JAVA
Uma interface apenas pode conter:

um identificador

um conjunto opcional de constantes


identificadores declarados como static e final
um conjunto de assinaturas (declarações) de métodos que são abstractos

usar abstract é opcional
Exemplo:
public interface Ordem {
public abstract boolean igual(Ordem elem);
public abstract boolean maior(Ordem elem);
public abstract boolean menor(Ordem elem);
}
4
Declaração de Interfaces JAVA
Numa interface:

os únicos identificadores de valores são constantes e declarados
como final

todos os métodos são abstractos

os métodos não impõem qualquer tipo de restrição sobre as
implementações que venham a ser feitas, apenas definem a sintaxe das
operações que se pretendem a ser implementadas

um interface não tem qualquer código de implementação

o código concreto da implementação dos métodos encontra-se nas
classes que declarem a utilização/implementação de uma ou mais
interfaces (implements)
5
Declaração de Interfaces JAVA
O mecanismo de interfaces de JAVA permite:
 especificar um conjunto de operações que uma qualquer classe
pode declarar querer implementar (i.e., usar a interface)


independentemente do seu posicionamento hierárquico
independentemente de continuar a ser uma subclasse da sua classe
original
Uma classe que implemente um ou mais interfaces passa a ter duas
vistas:



a vista de classe – que estrutura e comportamento (herdado+definido)
a vista de interfaces – que interfaces implementa, i.e., que propriedades
adicionais acrescenta às suas instâncias
Numa classe convergem, através de mecanismos diferentes,
os conceitos de subclasse e subtipo
6
Exemplos de declarações de interfaces
public interface Enumeravel {
public abstract boolean vazia();
public abstract Object seguinte();
}
public interface Colorivel {
public abstract void defineCor (int
}
public interface Ordem {
public abstract boolean igual(Ordem
public abstract boolean maior(Ordem
public abstract boolean menor(Ordem
}
cor);
elem);
elem);
elem);
Existe uma
hierarquia de
interfaces
public interface Desenhavel extends Colorivel {
public abstract void posicao (double x, double y);
public abstract void desenha ();
}
7
Benefícios da Interface

Como Java é uma linguagem fortemente tipificada, o
compilador deve garantir que os métodos chamados por
um objecto são realmente definidos por sua classe.

Em Java não é necessário saber qual a classe de um
objecto para chamar um método. Se este método é
definido por uma interface, basta utilizar uma referência
para a interface e será aplicado ao objecto o método
implementado na sua classe.
8
Exemplo: Definição de uma Interface
public interface Comparavel {
int compara( Comparavel rhs ); // Semelhante a compareTo
boolean menorQue( Comparavel rhs );
}
----------------------------------public static void ordena (Comparavel [] tab)
{
for(int i=0; i < tab.length; i++)
for(int j=i; j < tab.length; j++)
if ((tab[i].compara(tab[j]) > 0)
{
Comparavel tmp = tab[i];
tab[i] = tab[j];
tab[j] = tmp;
}
}
9
Exemplo: Implementação de uma Interface
public final class MeuInteiro implements Comparavel {
private int valor;
public MeuInteiro( int x ) { valor = x; }
// Alguns métodos
public String toString( ) { return Integer.toString( valor ); }
public int getValor( )
{ return valor; }
public boolean equals( Object rhs ) {
return rhs != null && valor == ((MeuInteiro)rhs).getValor(); }
// Implementa a interface
public int compara( Comparavel rhs ) {
return valor < ((MeuInteiro)rhs).getValor() ? -1 :
valor == ((MeuInteiro)rhs).getValor() ? 0 : 1;
}
public boolean menorQue( Comparavel rhs ) {
return valor < ((MeuInteiro)rhs).getValor();
}
}
10
Interfaces Múltiplas
public interface Hashable {
int hash( int tamTabela );
}



Função hash(k) transforma uma chave k em um endereço.
Este endereço é usado como a base para o armazenamento e
recuperação de registros.
É similar a uma indexação, pois associa a chave ao endereço
relativo do registro.
11
Interfaces Múltiplas
package Supporting;
public final class MeuInteiro implements Comparavel, Hashable {
private int valor;
public MeuInteiro( )
{ this( 0 ); }
public MeuInteiro( int x ) { valor = x; }
public int getValor( )
{return valor; }
public String toString( ) {return Integer.toString( valor );}
public boolean equals( Object rhs ) {return rhs != null && valor ==
((MeuInteiro)rhs).getValor(); }
public int compara( Comparavel rhs ) {
return valor < ((MeuInteiro)rhs).getValor() ? -1 :
valor == ((MeuInteiro)rhs).getValor() ? 0 : 1;
}
public boolean menorQue( Comparavel rhs ) {
return valor < ((MeuInteiro)rhs).getValor();
}
public int hash( int tamTabela ) {
if( valor < 0 )
return -valor % tamTabela;
else
return valor % tamTabela;
}
12
Hierarquia da classe Object
Interface
Comparable
AbstractObject
Chr
Classe
Abstracta
Int
Classe
Concreta
Str
extends
implements
Container
AbstractContainer
SearchableContainer
AbstractSerchableContainer
13
Objectos Abstractos Comparáveis
public classe Object
{
public final Class getClass ();
public String toString ();
public boolean equals (Object object);
….
}
public interface Comparable{
boolean isLT (Comparable object);
boolean isLE (Comparable object);
boolean isGT (Comparable object);
boolean isGE (Comparable object);
boolean isEQ (Comparable object);
boolean isNE (Comparable object);
int compare (Comparable object);
}
14
Objectos Abstractos Comparáveis
public abstract class AbstractObject implements Comparable{
public final boolean isLT (Comparable object)
{ return compare (object) < 0; }
public final boolean isLE (Comparable object)
{ return compare (object) <= 0; }
…..
public final boolean equals (Object object)
{
if (object instanceof Comparable)
return isEQ ((Comparable) object);
else
return false;
}
public abstract int compare (Comparable object);
}
15
Objectos Abstractos Comparáveis
public interface Container extends Comparable{
int getCount ();
boolean isEmpty ();
boolean isFull ();
void purge ();
void accept (Visitor visitor);
Enumeration getEnumeration ();
}
16