Interfaces

Interface é um recurso da orientação a objeto utilizado em Java que define ações que devem ser obrigatoriamente executadas, mas que cada classe pode executar de forma diferente. Interfaces contém valores, constantes ou assinaturas de métodos que devem ser implementados (sobrescritos) dentro de uma classe, ou seja, interface é um contrato no qual a classe que assina o contrato (implements) será obrigada a implementar esses métodos (sobrescrevê-los). Não possui atributos, não possui instãncia.

Conclusão: a implementação de uma interface é uma classe que desenvolve, implementa, sobrescreve as assinaturas do métodos declarados na respectiva interface.

Interfaces e polimorfismo

O conceito de polimorfismo também pode ser aplicado a objetos de classes que implementam interfaces. Quando uma classe implementa uma interface, ela deve implementar todos os métodos que a interface contém a fim de ser uma classe concreta, ou seja, da qual se podem gerar instâncias (objetos).

Ao implementar uma interface, uma classe permite que os objetos criados a partir dela possam apresentar o comportamento da interface implementada, podendo ser considerados como instâncias daquela interface.

As constantes são public, static e final.
Os métodos são public e abstract.

Exemplos:

Criação da interface: NomeInterface.java

interface NomeInterface {

boolean metodoI(int senha);

}

Criação da classe que implementa a interface: ClasseA.java

class ClasseA implements NomeInterface {

private int senha;
 
   
  public boolean metodoI(int senha) {
    if(this.senha != senha) {
     

    return false;
    }
 
    return true;
  }
 
}

Observação:
class
SubClasseA extends SuperClasseA implements NomeInterface {
...
}

As classes ClasseA e SuperClasseA implementam a interface NomeInterface, logo, elas serão obrigadas a implementarem (desenvolverem) os métodos da respectiva interface, este é o contrato.

Quando se cria uma variável do tipo NomeInterface, se está criando uma referência para qualquer objeto de uma classe que implemente NomeInterface, direta ou indiretamente:

NomeInterface var = new ClasseA( );

var.metodoI( );

Ao chamar o método metodoI( ), não se precisa preocupar em qual classe ele pertence, pois, tais classes têm a mesma interface implementada, com isso, a referência var.metodoI( ) irá corresponder a classe que tem a implementação (desenvolvimento do método) para o respectivo método chamado. Esta escolha é parecido com  a escolha do construtor de uma classe com vários contrutores, a classe é inicializada conforme a correspondencia dos parâmentos do construtor.

O mais comum quando se tem várias classe que são implementadas por uma mesma interface, é  criar uma outra classe que tenha um método, cuja parâmetro é do tipo da interface, com isso, é possível  referência através do parâmento, o método da interface.

  class NovaClasse {

     void login(NomeInterface a) {
     int senha = // pega senha de um lugar, ou de um scanner de polegar
     boolean ok =  a.MetodoI(senha);
  }
}

Uma interface pode definir uma série de métodos, mas nunca conter implementação deles. Ela só expõe o que o objeto deve fazer, e não como ele faz, nem o que ele tem. Como ele faz vai ser definido em uma implementação dessa interface.

As principais vantagens conseguidas através de seu uso são uma manutenção mais simples do código e uma maior reusabilidade do mesmo, aproveitando melhor os benefícios da programação orientada a objetos. Aumenta o polimorfismo, tem-se mais uma forma de referência  uma classe.

As interfaces permitem um encapsulamento de comportamento, ocultando qual classe está realizando uma tarefa específica. Isso é possível porque a classe que implementa uma interface é obrigada a seguir o protocolo definido nesta.

Logo de plano já se observa uma grande vantagem na utilização de interface, se várias classe tiverem a mesma implementação, ou seja, a mesma interface, uma mesma assinatura de método seria igual para todas, com isso, tem-se uma mesma referência para várias classes.

A maneira como os objetos se comunicam num sistema orientado a objetos é muito mais importante do que como eles executam. O que um objeto faz é mais importante do que como ele faz.

Métodos de uma interface são sempre públicos e abstratos.

Herança entre interfaces

Diferentemente das classes, uma interface pode herdar de mais de uma interface. É como um contrato que depende que outros contratos sejam fechados antes deste valer. Você não herda métodos e atributos, mas sim responsabilidades.Uma classe pode extender suas funcionalidades obtendo as características de outra classe num processo que se chama de herança.

Uma interface não é herdada, mas sim, implementada. Porque todo o código dos métodos da interface deve ser escrito dentro da classe que o chama. Dessa forma, obtemos as assinaturas dos métodos da interface em uma classe usando a palavra-chave implements.


Regras de Interfaces Java  (interface)

Declaração de Interfaces

Uma interface é como uma classe 100% abstrata;
As interfaces são implicitamente abstract, colocar esse modificador é opcional;
Uma interface só pode ser public ou default;
Uma interface NÃO pode ter o modificador private ou protected;
Uma interface pode estender várias interfaces (isso mesmo, a palavra usada é extends);
Uma interface NÃO pode implementar outra interface ou classe (parece estranho, mas uma interface estende outras interfaces);

Classes que Implementam
Uma classe concreta (não abstract) que implementa uma interface deve fornecer implementações para todos os seus métodos;
Uma classe abstract quem implementa uma interface não é obrigada a implementar seus métodos, mas a primeira classe concreta da arvore de herança deve implementá-los;
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;

Regras dos Métodos
Todos os métodos de uma interface são implicitamente public e abstract;
E já que os métodos são abstract eles devem terminam com ponto-e-vírgula (;);
Os métodos declarados em uma interface não podem ser static;
Os métodos da interface não podem ser marcados com final, native, strictfp ou synchronized;

Regras das Variáveis (Constantes)
Todas as variáveis de uma interface são public, static e final, sendo assim, todas as variáveis são constantes (toda constante deve ser inicializada);
As declarações public, static e final são opcionais;

Diferença classe abstrata e interface

Uma interface Java é uma classe abstrata onde todos os métodos são "implicitamente" abstract e public, e todos os atributos são "implicitamente" static e final.

Em outras palavras, uma interface Java aproxima-se da especificação de uma "classe abstrata pura", com uma pequena diferença: os métodos das classes abstratas podem ou não ser implementados nas classes que a estendem, já os métodos das interfaces tem que ser obrigatoriamente implementados nas classes que as implementam.

Uma interface serve para estabelecer um padrão que é obedecido pela classe que a implementa. Quando uma classe implementa uma interface, garante que todas as funcionalidades especificadas pela interface serão oferecidas pela classe. - See more at:

Exemplo 1:

Interface: Area.java

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: Principal.java

package Interface1;
public class Principal {
    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());
    }
}

run:
100.0
12.566370614359172


Exemplo 2:

Interface: Shape.java

package Interface2;
interface Shape
 {
     public   String baseclass="shape";
     public void Draw();
      }

Classe: Circle.java

 class Circle implements Shape
 {
    public void Draw() {
        System.out.println("Drawing Circle here");
    }  
 }

Classe: Main.java

package Interface2;
public class Main {
    public static void main(String[] args) {
          Shape circleshape=new Circle();
             circleshape.Draw();
    }
}

run:
Drawing Circle here

Exemplo 3:
Inteface InterfaceTeste.java

package Interface3;
public interface InterfaceTeste {
       public void metodo1();
       public void metodo2();
       public void metodo3();
}

Classe: ClasseTeste.java

package Interface3; 
public class ClasseTeste implements InterfaceTeste {
    public void metodo1() {
       System.out.println("Implementei o método 1");
    }
    public void metodo2() {
        System.out.println("Implementei o método 2");
    }
    public void metodo3() {
         System.out.println("Implementei o método 3");
    }
}

Classe: Principal.java

package Interface3;
public class Principal {
    public static void main(String[] args) {
        InterfaceTeste a = new ClasseTeste();
        a.metodo1();
        a.metodo2();
        a.metodo2();
    }
}

run:
Implementei o método 1
Implementei o método 2
Implementei o método 2


Exemplo 4:
Inteface: ShapeA.java

package Interface4;
interface ShapeA {
    public String baseclass = "shape1";
    public void Draw1();
}

Interface: ShapeB.java

package Interface4;
interface ShapeB extends ShapeA {
    public String baseclass = "shape2";
    public void Draw2();
}

Classe: Circle.java

package Interface4;
class Circle implements ShapeB {
    public void Draw1() {
        String baseclass = "shape1";
        System.out.println("Drawing Circle here:" + baseclass);
    }
    public void Draw2() {
        String baseclass = "shape2";
        System.out.println("Drawing Circle here:" + baseclass);
    }
}

Classe: Main.java

package Interface4;
public class Main {
    public static void main(String[] args) {      
          ShapeB circleshape=new Circle();
             circleshape.Draw1();
             circleshape.Draw2();
    }
}

run:
Drawing Circle here:shape1
Drawing Circle here:shape2


Exemplo 5:
Interface: Check.java

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

Classe: Interface.java

package Interface5;
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());
        }
    }
}

run:
Method defined in the interface


Exemplo 6:

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

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

Classe: NotaFiscal.java

package Interface6;
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 Interface6;
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 Interface6;
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 Interface6;
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);
        }
    }
}
run:
Impressora ligada!
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