terça-feira, 8 de junho de 2010

Preparação para SCJP - Parte 3 (Interfaces)

Vamos ao próximo post: Interfaces.

Interfaces são classes abstratas por padrão. Sendo assim, não existe a necessidade de declará-la como tal. Porém, declará-la como abstract (apesar de redundante) é válido. Observe as seguintes declarações:

public abstract interface MinhaInterface { }


public interface MinhaInterface { }

Ambas declarações são válidas. Mas afinal de contas, o que raios é uma interface? Interface, é uma forma de você obrigar uma classe a se comportar de determinada forma. Como assim? Vamos entender por partes. Em primeiro lugar, a interface é um pouco mais que uma classe abstrata. É uma classe abstrata que possui somente métodos abstratos e públicos (mesmo que você não os declare como tal). Todos os atributos que você declarar em uma interface serão constantes, ou seja, não existem variáveis de instância em uma interface. Acompanhe o exemplo de declaração de métodos:

public interface MinhaInterface {
    public abstract void meuPrimeiroMetodo();
    // Se declarasse como abaixo também estaria correto:
    abstract void meuPrimeiroMetodo();
    // Assim também está certo:
    void meuPrimeiroMetodo();
}
Veja a declaração de atributos:
public interface MinhaInterface{
    public static final int constanteDeInterface = 20;
    // Os códigos abaixo declaram constantes, mesmo que não esteja explícito, e são todos válidos!
    public int constanteDeInterface = 20;


    static int constanteDeInterface = 20;
    final int constanteDeInterface = 20;
    public static int constanteDeInterface = 20;
    public final int constanteDeInterface = 20;
    static final int constanteDeInterface = 20;
}

Como dito anteriormente, interfaces são implicitamente classes abstratas. Sendo assim, não pode ser instanciada. Porém, diferente do que acontece com classes abstratas, interfaces não são extensíveis (exceto por outras interfaces), e sim implementáveis. Ao invés de usar a palavra chave "extends", utiliza-se "implements". Diferentemente do conceito de herança, uma classe pode implementar mais de uma interface. Veja os exemplos:

public interface MinhaInterface { }


// Implementação válida de uma interface
public class ClasseConcreta implements MinhaInterface { }


// O seguinte também é válido:
public class ClasseConcreta implements MinhaInterface, Runnable { }

// Uma interface pode extender de outra interface, 
// mas nunca implementar!
public interface OutraInterface extends MinhaInterface { }

Interfaces são também uma maneira de simular mútipla herança, já que por bons motivos, a linguagem não possui suporte a este recurso. Uma classe abstrata também pode implementar uma interface, mas isso implica em fornecer implementação aos métodos da interface (que são inerentemente abstratos). Como a classe é abstrata, ela pode optar por delegar a implementação dos métodos abstratos dela própria e da interface à próxima classe concreta. Acompanhe o exemplo:

public interface Pulador {
    // Lembre-se que métodos abstratos terminam 
    // com ";" e não "{}"!
    void pular();
}


// Observe que o fato de implementar uma interface não impede de extender outra classe!
public abstract class Pneu extends Borracha implements Pulador {
    public abstract void rodar ();
    // Perceba que a classe optou por não implementar o método pular.
    // Isso é totalmente válido, pois é uma classe abstrata.
}

public class PneuDeCaminhao extends Pneu {
    /* Essa classe, por ser concreta e herdar de Pneu é 
     * obrigada a fornecer implementação de todos os 
     * métodos abstratos que ainda não tem implementação. 
     * Tanto da interface quanto da classe abstrata que ele 
     * herda diretamente*/
    public void rodar() { 
        // Código útil aqui 
    }
    
    public void pular() {
        // Código útil aqui
    }
}

Como mostrado anteriormente, interfaces também utilizam herança. Interfaces NUNCA poderão implementar outra interface. Observe os exemplos:

public interface InterfacePai {
    void metodoDaInterfacePai ( );
}


// Este código é válido!
public interface InterfaceFilha extends InterfacePai{
    void metodoDaInterfaceFilha ( );
}


// Este código é inválido!


public interface InterfaceFilha implements InterfacePai{
    void metodoDaInterfaceFilha ( );
}


// Este código é válido!


public interface InterfaceFilha extends InterfacePai{
    void metodoDaInterfaceFilha ( );
    void metodoDaInterface
}

Bom, acho que tem bastante informação aí. É isso. Até mais!!! See you guys!!!

Nenhum comentário:

Postar um comentário