JAVA –Interface

1. JAVA –Interface ATAI

2. Object B C D m1 m2 E F m1 m2 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

3. 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 garantirque classes não relacionáveis na hierarquia e, portanto, por herança, partilham propriedades comportamentais, ou seja, implementam o comportamento especificado

4. 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); }

5. 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)

6. 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

7. 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 cor); } public interface Ordem { public abstract boolean igual(Ordem elem); public abstract boolean maior(Ordem elem); public abstract boolean menor(Ordem elem); } public interface DesenhavelextendsColorivel { public abstract void posicao (double x, double y); public abstract void desenha (); } Existe uma hierarquia de interfaces

8. 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.

9. Exemplo: Definição de uma Interface public interfaceComparavel { 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; } }

10. 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(); } }

11. 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.

12. Interfaces Múltiplas package Supporting; public final class MeuInteiroimplementsComparavel,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; }

13. Hierarquia da classe Object Interface Classe Abstracta Classe Concreta extends implements Comparable AbstractObject Chr Int Str Container AbstractContainer SearchableContainer AbstractSerchableContainer

14. 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); }

15. 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 abstractint compare (Comparable object); }

16. Objectos Abstractos Comparáveis public interface Container extends Comparable{ int getCount (); boolean isEmpty (); boolean isFull (); void purge (); void accept (Visitor visitor); Enumeration getEnumeration (); }