Programação por Objectos. Java

Transcrição

1 Programação por Objectos Java Parte 7: Interfaces Java 1/31

2 Interfaces revisão (1) Uma interface é um conjunto de protótipos de métodos (sem implementações) que especifica um serviço bem definido: As interfaces não podem conter atributos, mas podem conter constantes. A implementação duma interface é realizada pela classe concreta. Na implementação ou concretização: Determina-se os atributos necessários à correcta implementação da interface. Descreve-se o código dos métodos das interface. LEEC@IST Java 2/31

3 Interfaces revisão (2) Uma interface pode herdar as definições de outra interface. Interfaces podem usar polimorfismo. Se uma classe concretizar mais de uma interface, e várias interfaces contiverem métodos com a mesma assinatura, basta definir uma única implementação. Uma interface não pode ser instanciada. LEEC@IST Java 3/31

4 Interfaces (1) Tanto as classes como as interfaces definem tipos (a unidade fundamental da programação OO). Em Java, uma classe só pode estender uma outra classe, mas pode implementar uma ou mais interfaces. Para uma dada classe, as classes estendidas e as interfaces implementadas são denominadas supertipos. A classe em si é denominada o subtipo. Uma referência para um objecto do subtipo pode ser usada sempre que uma referência para um objecto dos seus supertipos (classes ou interfaces) é necessária. LEEC@IST Java 4/31

5 Interfaces (2) O Java disponibiliza um conjunto de interfaces, de onde se destaca: Comparable: objectos deste tipo têm uma ordem associada que os permite comparar. Iterable: objectos deste tipo disponibilizam um iterador, e portanto podem ser usadas no ciclo for-each. Collection: objectos deste tipo conseguem guardar outros objectos. Set, List, Queue, LEEC@IST Java 5/31

6 Interfaces (3) Sintaxe Qualif* interface Ident [ extends IdentI [, IdentI ]*] { [ QualifC* Tipo IdentC = expressão; ] * [ QualifM* Tipo IdentM ( [TipoP IdentP [, TipoP IdentP ]*); ]* Qualif: qualificador (visibilidade, entre outros) Ident: identificador da interface extends IdentI: especialização de interface LEEC@IST Java 6/31

7 Interfaces (4) Qualificadores de interface: public: interface publicamente acessível. abstract: a interface não pode ser instanciada. Por omissão do qualificador public, uma interface é apenas acessível no pacote onde está definida. LEEC@IST Java 7/31

8 Interfaces (5) Todas as interfaces são implicitamente abstract. Por convenção, o qualificador abstract é omitido. Todos os membros são implicitamente public. Por convenção, o qualificador public é omitido. Todas as constantes são implicitamente public static final. Por convenção, os qualificadores são omitidos. Todos os métodos são implicitamente public abstract. Por convenção, os qualificadores são omitidos. Nenhum outro qualificador é permitido às contantes e métodos duma interface. LEEC@IST Java 8/31

9 Interfaces (6) public interface Pilha { //métodos boolean vazia(); Object topo(); boolean adicionar(object o); void remover(); LEEC@IST Java 9/31

10 Herança de interfaces (1) Uma interface pode estender mais que uma interface. As interfaces que são estendidas são denominadas superinterfaces, enquanto que a nova interface é denominada subinterface. Uma subinterface herda todas as constantes declaradas nas suas superinterfaces. Se uma subinterface declara uma constante com o mesmo nome que uma constante herdada (independentemente do tipo), a constante da subinterface esconde a constante herdada. Na subinterface a constante herdada é acedida apenas pelo seu nome qualificado (superinterface.constante). LEEC@IST Java 10/31

11 Herança de interfaces (2) interface X { int val = 1; String strx = X ; interface Y extends X { int val = 2; int sum = val + X.val; String stry = Y extends + strx; LEEC@IST Java 11/31

12 Herança de interfaces (3) Se uma interface herda duas ou mais constantes com o mesmo nome, qualquer referência simples a essa constante é ambígua e resulta num erro de compilação. interface A { String str = A ; interface B extends A { String str = B ; interface C extends A { String str = C ; interface D extends B, C { String d = str; interface D extends B, C { String d = A.str+B.str+C.str; Erro de compilação: qual str? LEEC@IST Java 12/31

13 Herança de interfaces (4) Uma subinterface herda todos os métodos declarados nas suas superinterfaces. Se uma subinterface declara um método com a mesma assinatura, a menos de um retorno covariante, que um ou mais métodos herdados, o método da subinterface é uma redefinição dos métodos herdados. Se uma subinterface herda mais do que um método com a mesma assinatura, a menos de um retorno covariante, a subinterface contém apenas um método o método que retorna o subtipo comum. LEEC@IST Java 13/31

14 Herança de interfaces (5) Se um método da subinterface difere apenas no tipo de retorno de um método herdado, ou se dois métodos herdados diferem apenas no tipo de retorno, e estes retornos não são covariantes, há um erro de compilação. Se um método tem o mesmo nome, mas diferentes parâmetros que um método herdado, o método é uma sobreposição do método herdado. LEEC@IST Java 14/31

15 Herança de interfaces (6) interface X { void xpto(); Number foo1(); Number foo2(); interface Y { Object foo1(); Object foo2(); interface Z extends X, Y { void xpto(string s); Integer foo1(); Métodos da interface Z: public void xpto() public void xpto(string) public Integer foo1() public Number foo2() LEEC@IST Java 15/31

16 Implementação de interfaces (1) Uma classe identifica as interfaces que implementa, listando-as a seguir à palavra chave implements. Sintaxe (revisão) Qualif* class Ident [ extends IdentC] [ implements IdentI [,IdentI]* ] { [ Decl_atributos Métodos ]* LEEC@IST Java 16/31

17 Implementação de interfaces (2) As interfaces que uma classe implementa são denominadas as superinterfaces da classe. A classe deve disponibilizar uma implementação para todos os métodos definidos nas suas superinterfaces, senão a classe tem de ser declarada abstract. LEEC@IST Java 17/31

18 Implementação de interfaces (3) Quando um classe implementa uma interface, a classe pode aceder às constantes definidas na interface como se tivessem sido declaradas na classe. Uma classe que implementa mais do que uma interface, ou que estende uma classe e implementa uma ou mais interfaces, sofre dos mesmo problemas de constantes escondidas e ambiguidade que uma interface que estende mais de uma interface (ver slides 10, 11 e 12). LEEC@IST Java 18/31

19 Implementação de interfaces (4) interface X { int val = 1; String strx = X ; class Z implements Y { int val = 3; Z z = new Z(); System.out.println( z.val= + z.val + interface Y extends X { int val = 2; int sum = val + X.val; String stry = Y extends + strx; ((Y)z).val= + ((Y)z).val + /* ou Y.val */ ((X)z).val= + ((X)z).val) /* ou X.val */; System.out.println( z.strx= + z.strx + z.stry= + z.stry; No terminal é impresso z.val=3 ((Y)z).val=2 ((X)z).val=1 strx=x stry=y extends X LEEC@IST Java 19/31

20 Implementação de interfaces (5) interface A { String str = A ; interface B extends A { String str = B ; interface C extends A { String str = C ; class D implements B, C { String d = str; class D implements B, C { String d = A.str+B.str+C.str; Erro de compilação: qual str? LEEC@IST Java 20/31

21 Implementação de interfaces (6) Se uma classe implementa várias interfaces com mais do que um método com a mesma assinatura a classe contém apenas um tal método. Se uma classe implementa várias interfaces com mais do que um método com a mesma assinatura, a menos de um retorno covariante, a implementação deve definir o método que retorna o subtipo comum (caso contrário resulta num erro de compilação). Se uma classe implementa várias interfaces com mais do que um método que difere apenas no tipo de retorno, e estes retornos não são covariantes, há um erro de compilação. LEEC@IST Java 21/31

22 Implementação de interfaces (7) interface X { void xpto(); Number foo1(); Number foo2(); interface Z extends X, Y { void xpto(string s); Integer foo1(); interface Y { Object foo1(); Object foo2(); class ClasseZ implements Z { public void xpto() {... public void xpto(string s) {... public Integer foo1() {... public Number foo2() {... É importante identificar os métodos a implementar de uma interface: se a ClasseZ não disponibilizar a implementação para todos os métodos definidos nas suas superinterfaces tem de ser declarada abstract (ver slide 17). LEEC@IST Java 22/31

23 Implementação de interfaces (8) A implementação da interface Pilha pode ser feita de diferentes maneiras: Baseada numa tabela: PilhaComTabela Baseada numa lista ligada: PilhaComLista A interface Pilha corresponde ao tipo de dados abstracto, enquanto que ambas as classes PilhaComTabela e PilhaComLista correspondem ao tipo de dados implementado de duas formas diferentes. public interface Pilha { //métodos boolean vazia(); Object topo(); boolean adicionar(object obj); void remover(); LEEC@IST Java 23/31

24 Implementação de interfaces (9) public class PilhaComTabela implements Pilha { private final int MAX; private Object pilha[]; private int poslivre; // primeira posição livre public PilhaComTabela(int max) { MAX = max; pilha = new Object[MAX]; poslivre = 0; public boolean vazia() { return poslivre==0; public Object topo() { return pilha[poslivre]; LEEC@IST Java 24/31

25 Implementação de interfaces (10) //continuação do slide anterior... public boolean adicionar(object obj){ if (poslivre<max-1){ pilha[poslivre++] = obj; return true; else return false; public void remover() { pilha[poslivre--] = null; public int nummaxelementos() { return MAX; LEEC@IST Java 25/31

26 Implementação de interfaces (11) public class PilhaComLista implements Pilha { private ElementoPilha topo; private int numelementos; public PilhaComLista(){ topo = null; numelementos = 0; public boolean vazia() { return numelementos==0; public Object topo() { return topo!=null?topo.elemento:null; LEEC@IST Java 26/31

27 Implementação de interfaces (12) //continuação do slide anterior... public boolean adicionar(object obj){ topo = new ElementoPilha(obj,topo); numelementos++; return true; public void remover() { if (topo!=null) { topo = topo.próximo; numelementos--; public int numelementos() { return numelementos; LEEC@IST Java 27/31

28 Implementação de interfaces (13) public class ElementoPilha { Object elemento; ElementoPilha próximo; public ElementoPilha(Object elem, ElementoPilha prox){ elemento = elem; próximo = prox; LEEC@IST Java 28/31

29 Implementação de interfaces (14) Definindo as interfaces um tipo, é possível declarar variáveis com o seu tipo: Pilha p = new PilhaComTabela(100); Contudo, referências para um tipo de interface, só podem ser usadas para aceder a membros da própria interface: p.adicionar(new Integer(100)); p.adicionar(new Character( a )); p.remover(); int max = p.nummaxelementos(); //INVÁLIDO!!! Para contornar este problema pode usar-se um cast: int max = ((PilhaComTabela)p).numMaxElementos(); LEEC@IST Java 29/31

30 Implementação de interfaces (15) É possível chamar qualquer método de Object com uma referência para um tipo de interface: String s = p.tostring(); LEEC@IST Java 30/31

31 Implementação de interfaces (16) O programador pode instanciar a pilha que mais lhe interessa: Pilha p1 = new PilhaComLista(); Pilha p2 = new PilhaComLista(); p1.adicionar(new Integer(5)); p2.adicionar(new Character( a )); Se houver interesse em usarpilhacomtabela, em vez de PilhaComLista, a única alteração reside na instanciação dos objectos, e não na declaração das referências para o tipo Pilha: Pilha p1 = new PilhaComTabela(20); Pilha p2 = new PilhaComTabela(100); p1.adicionar(new Integer(5)); p2.adicionar(new Character( a )); LEEC@IST Java 31/31