Interface

O que é interface?

-É um recurso utilizado em orientação a objeto, que funciona como um "contrato" que define ações que devem ser obrigatoriamente executadas, mas que cada classe pode executar de forma diferente, ou seja, é um contrato no qual a classe que assina o contrato (implements) será obrigada a implementar esses métodos (sobrescrevê-los).
-Interface não é classe e, sim uma entidade/tipo. Ou seja, ela não possui instância.

-Palavra chave: "ser capaz de".

-Pode ser também  considerada como "É-UM", mas está mais para informar que um objeto "está apto a fazer algo".

-As interfaces são implicitamente "abstract", colocar esse modificador é opcional;

Como funciona?

-Similar a uma classe abstrata, mas como um tipo de "contrato", onde são especificados os atributos e métodos abstratos (métodos sem código) que obrigam as classes que implementarem a interface implementar esses métodos abstratos, mas não é uma classe.

-Toda interface é publica.

-Não pode ser instanciada, pois não possui implementação própria.

-A classe que implementa a interface deve garantir que todas as operações da interface tenham um método (o contrato deve ser respeitado).

-Uma classe não herda uma interface, ela a implementa.

-A classe tem que ter as mesmas operações da INTERFACE.

-A interface não pode ser instanciada e não pode declarar construtor.

-A classe é obrigada a implementar o/os método(s) para cada uma das operações definidas pela interface, caso contrário o compilador acusará um erro.

-Uma classe pode implementar mais de uma interface.

-Classes não podem estender uma interface.

-Ao usar uma interface, você não herda código, e sim assume um contrato.

-Todas as classes que implementa, a interface (assumem este contrato) devem fornecer métodos concretos para as operações declaradas por ela.

-Interfaces podem estender outras interfaces.

-Também permite polimorfismo de inclusão.

-O parâmetro "T" é definido no momento em que a interface é declarada. Ele define a classe utilizada na interface, ou seja, a classe que a interface utilizará para implementar seus métodos;

-Quando uma classe implementa uma interface genérica, ela precisa declarar qual tipo será considerado. No caso T poderá ser uma Classe, String, etc.

-Uma classe não precisa ser final para implementar uma interface;

-Uma interface não pode ter o modificador private ou protected;

-Uma interface só pode ser public ou default;

-Uma interface pode estender de várias interfaces (extends);

-Uma classe pode implementar diversas interfaces;

-Uma interface não pode implementar outra interface ou classe.

-Suporta somente constantes do tipo estática

-Se todas as diversas implementações compartilham a assinatura do método, entao a interface funciona melhor.

-Todas as declarações de constantes em uma interface são presumidamente publicas ou estáticas.

-Se você incluir um novo método em uma interface você precisa ajustar todas as implementações da interface;

-Uma classe que implementa uma interface não pode declarar nenhuma exceção nova, ou mais abrangente, mas pode declarar exceções de tempo de execução em qualquer método;

-Toda variável criada numa interface é public, static e final, ou seja, elas são constantes, ou seja, toda constante deve ser inicializada. Logo essas declarações de public, static e final são opcionais;

Diferenças entre Classe Abstrata e Interface?

CLASSE ABSTRATA:

-Devem contem pelo menos um método abstrato, ou seja, método que não tem implementação;Se tiver classe abstrata com todas as operações abstratas, utilize uma INTERFACE.

-É um tipo especial de classe em que não há como criar instâncias dela.

-É usada apenas para ser herdade, funciona como uma superclasse.

-Vantagem: Força a hierarquia para todas as subclasses, manutenção mais simples do código e uma maior reusabilidade do mesmo;

-É um tipo de contrato que faz com que as subclasses contemplem as mesmas hierarquias e/ou padrões

-Se todos os métodos forem abstratos, provavelmente estamos fazendo errado, e sim deveria ser uma Interface.

-Uma classe pode herdar somente uma classe.

-Pode conter constantes estáticas e de infância.

-Se as várias implementações são todas do tipo e compartilham um comportamento e status comum, -então a classe abstrata funciona melhor;

-Se você incluir um novo método em uma classe abstrata, você tem a opção de fornecer uma implementação padrão para ele.

-Uma classe abstrata que implementa uma interface não é obrigada a implementar seus métodos, mas a primeira classe concreta da arvore de herança deve implementá-los.


INTERFACE:

-Contém somente métodos abstratos públicos ;

-Uma interface não pode ter o modificador private ou protected;

-É um tipo especial de "contrato" em que não há como criar instância dela, assim não possui construtor.

-A interface é implementada por classes, cabendo a elas implementarem (escrever) os métodos da interface.

-Uma classe pode implementar diversas interfaces;

-Se todas as diversas implementações compartilham a assinatura do método então a interface funciona melhor.

-Ao usar uma interface, você não herda código, e sim assume um contrato.

-Se o código do seu cliente conversa somente em termos de uma interface, você pode facilmente alterar a implementação concreta usando um método factory.

-Se você incluir novo método em uma interface você precisa ajustar todas as implementações da interface.

-Uma interface não pode implementar outra interface ou classe.

-Uma interface pode estender de várias interfaces (extends);

-Interface suporta somente constantes do tipo estáticas;

-Toda variável criada numa interface é public, static e final, ou seja, elas são constantes, ou seja, toda constante deve ser inicializada. Logo essas declarações de public, static e final são opcionais;


Vantagem de utilizar Interface?

-Permite que duas classes diferentes possuam uma interface comum.

-Prover um caminho para uma classe ser parte de duas classes: uma herdada hierarquicamente e outra da interface.


EXEMPLO PRÁTICO:

package Interface1;
public interface Area {
    public double calcularArea();
}

Classe: Circulo.java

package Interface1;
public class Circulo implements Area {
    private double raio;
    public Circulo(double raio) {
        this.raio = raio;
    }
    public double calcularArea() {
        return raio * raio * Math.PI;
    }
}

Classe: Quadrado.java

package Interface1;
public class Quadrado implements Area {
private double lado;
public Quadrado(double lado) {
   this.lado = lado;
   }
   public double calcularArea( ) {
       return lado*lado;
   }
} 

Classe: Main.java

package Interface1;
public class Main{
    public static void main(String[] args) {
        Area quadrado = new Quadrado(10);
        Area circulo = new Circulo(2);
        System.out.println(quadrado.calcularArea());
        System.out.println(circulo.calcularArea());
    }
}

EXEMPLO 2:

Interface: Check.java

package Interface2;
interface Check {
    public void message();
}

Classe: Interface.java

package Interface2;
public class Interface {
    public static void main(String[] args) {
        try {
            Check t = new Check() {
                public void message() {
                    System.out.println("Method defined in the interface");
                }
            };
            t.message();
        } catch (Exception ex) {
            System.out.println("" + ex.getMessage());
        }
    }
}

SAÍDA: Method defined in the interface 

Exemplo 6:

Interface: Eletronico.java
package Interface3;
public interface Eletronico {
    void ligar();
    void desligar();
}

Interface: Imprimivel.java
package Interface3;
public interface Imprimivel {
    void imprimir();
}

Classe: NotaFiscal.java

package Interface3;
public class NotaFiscal implements Imprimivel {
    private int numero;
    private double valor;
    public NotaFiscal(int numero, double valor) {
        this.numero = numero;
        this.valor = valor;
    }
    public void imprimir() {
        System.out.println("Número: " + this.getNumero() + ", Valor: " + this.getValor());
    }
    public double getValor() {
        return valor;
    }
    public void setValor(double valor) {
        this.valor = valor;
    }
    public int getNumero() {
        return numero;
    }
    public void setNumero(int numero) {
        this.numero = numero;
    }
}

Classe: NotaFiscalOnline.java

package Interface3;
public class NotaFiscalOnline {
    private int numero;
    private double valor;
    public NotaFiscalOnline(int numero, double valor) {
        this.numero = numero;
        this.valor = valor;
    }
    public double getValor() {
        return valor;
    }
    public void setValor(double valor) {
        this.valor = valor;
    }
    public int getNumero() {
        return numero;
    }
    public void setNumero(int numero) {
        this.numero = numero;
    }
}

Classe: Televisao.java

package Interface3;
public class Televisao implements Eletronico {
    // Temos obrigatóriamete que implementar os métodos
    // da interface Eletronico.
    public void ligar() {
        System.out.println("Liguei a televisão");
        // Aqui você implementaria os códigos para ligar a televisão
    }
    public void desligar() {
        System.out.println("Desliguei a televisão");
        // Aqui você implementaria os códigos para desligar a televisão
    }
}

Classe: Main.java

package Interface3;
public class Main {
    public static void main(String[] args) {
        // Instânciamos uma impressora
        Impressora impressora1510 = new Impressora();
        // Ligamos a impressora!
        impressora1510.ligar();
        // Fazemos um for para simular a criação de 10 notas fiscais
        for (int i = 1; i <= 10; i++) {
            // numero da nota atual recebe o valor de i
            int numeroNota = i;
            // Criamos um valor i * 10, só para esta demonstração
            // 10.0 , 20.0, 30.0, 40.0, 50.0 .... 100.0
            double valor = (double) (10 * i);
            // Criamos um nota fiscal aqui dentro do for...
            // utilizando o valores gerados com a ajuda da variável i
            NotaFiscal notaf = new NotaFiscal(numeroNota, valor);
            // Como passamos um objeto que implementa a classe Imprimivel para
            // o método da impressora que espera um objeto Imprimivel
            // não terá problemas...
            impressora1510.imprimirNotaFiscal(notaf);
        }
    }
}

SAÍDA:
Número: 1, Valor: 10.0
Número: 2, Valor: 20.0
Número: 3, Valor: 30.0
Número: 4, Valor: 40.0
Número: 5, Valor: 50.0
Número: 6, Valor: 60.0
Número: 7, Valor: 70.0
Número: 8, Valor: 80.0
Número: 9, Valor: 90.0
Número: 10, Valor: 100.0