O que é interface em Java e como implementá-la?

' Interface é um nível avançado de obtenção de abstração na linguagem de programação Java. A interface Java ajuda no redução da complexidade no código e simplifica o legibilidade . Neste artigo, explicarei a você a interface Java por meio do seguinte súmula.

• O que é uma interface Java?
• Por que precisamos de uma interface?
• Declarando uma interface Java: Sintaxe
• Exemplo de interface Java
• Aninhando a interface Java
• Diferença entre classe e interface
• Vantagens e desvantagens da interface
• Pontos-chave na interface Java

O que é uma interface Java?

Interface de Computador é conhecido como um limite que separa dois ou mais sistemas. Ele troca dados entre os componentes de um sistema que podem ser sinais, comandos ou protocolos.

O Java Abstraction fornece a funcionalidade de um método específico, ocultando a lógica de implementação escrita dentro do método. Da mesma forma, a Interface Java também é uma classe abstrata que inclui a Declaração de Método, mas não sua definição. Uma aula implementos uma interface para herdar os métodos abstratos. Junto com métodos abstratos, um interface também pode incluir constantes, métodos estáticos, interfaces aninhadas e métodos padrão.

Semelhanças entre uma classe e uma interface.

Uma interface é completamente semelhante a uma classe normal em Java. Uma interface inclui os métodos abstratos e esses métodos são projetados para serem implementados. Esse processo é simplesmente igual à herança, o que é normal quando se trata de classes. Discutiremos mais sobre semelhanças.

• Da mesma forma que uma classe, uma interface também pode conter quantos métodos forem necessários.
• Semelhante às classes, a interface também é escrita com um .Java arquivo de extensão.
• Surpreendentemente, o bytecode para uma interface terá aparecido em um .classe Arquivo.
• Uma interface é mostrada na forma de um pacote e seu respectivo bytecode está em um diretório que corresponde ao nome do pacote.

Por que precisamos de uma interface?

Java não suporta Múltiplas heranças, devido a isso, ele não permitirá que as classes estendam mais de uma classe em uma instância. Aulas infantis não poderia herdar as propriedades de várias classes pai em uma única instância, pois resulta em Problema do diamante. Para superar esse problema, Interface é introduzido. Vamos entender esse problema por meio de um exemplo.

Vamos supor que temos dois aviões, um só pode carregar passageiros, o outro apenas posição. Agora, precisamos herdar as propriedades do avião de carga e do avião de passageiros. Java não suportaria esta solução, pois acaba em ambiguidade entre os dois planos.

Mas, se você puder tornar isso possível, fazendo com que Java sinta que está herdando um plano e implementando os métodos presentes no outro plano. É como um avião comercial que leva passageiros e bagagem de carga. A Interface é como fazer um plano maior que poderia fazer ambas as tarefas sem interferir com os componentes um do outro, em vez disso, apenas pegando emprestado os métodos do Classe de interface.

java como usar isso

// Código Classe A

pacote de várias classes A {void msg () {System.out.println ('Hello')}}

// Código Classe B

pacote múltiplo classe B {void msg () {System.out.println ('Bem-vindo')}}

Código Classe C

package multiple class C extends A, B {// Isso não será aceito pelo Java, gerará um erro e o código não será executado. public static void main (String args []) {C obj = new C () obj.msg ()}}

Resultado:

Erro. Essa abordagem específica lança uma exceção. Java não oferece suporte a várias heranças. Este erro é conhecido como Problema de Diamante 

Vamos tentar uma solução usando uma interface, Aulas infantis pode acessar os métodos de Pais múltiplos classes em uma única instância.

// Código de interface

pacote de solução de interface pública MIS {public void Hello () public void Welcome ()}

// Class Code

pacote MIS public class classA implementa a solução {public void Hello () {java.lang.System.out.println ('Hello world')} public void Welcome () {java.lang.System.out.println ('Welcome to Edureka ')} public static void main (String [] args) {classA Edureka = new classA () Edureka.Hello () Edureka.Welcome ()}}

Resultado:

Olá Mundo

Bem vindo a edureka

Declarando uma interface Java: Sintaxe

interface nome_da_interface {// declara campos constantes // declara métodos () // métodos padrão}

Vejamos um exemplo na interface Java

Exemplo de interface Java

Vamos criar uma calculadora simples baseada na interface Java.

// Código de interface

pacote basicoperations interface pública matemática {public void add () public void sub () public void mul () public void div ()}

// Class Code

package basicoperations import java.util.Scanner public class student1 implementa maths {@Override public void add () {Scanner kb = new Scanner (System.in) System.out.println ('Insira quaisquer dois valores inteiros para realizar a adição') int a = kb.nextInt () int b = kb.nextInt () int s = a + b System.out.println ('Soma de' + a + 'e' + b + 'é' + s)} @Override public void sub () {Scanner kb = new Scanner (System.in) System.out.println ('Insira quaisquer dois valores inteiros para realizar a subtração') int a = kb.nextInt () int b = kb.nextInt () int s = ab System.out.println ('Diferença de' + a + 'e' + b + 'é' + s)} @Override public void mul () {Scanner kb = new Scanner (System.in) System.out.println ('Enter qualquer multiplicação de dois valores inteiros ') int a = kb.nextInt () int b = kb.nextInt () int s = a * b System.out.println (' Produto de '+ a +' e '+ b +' é '+ s)} @Override public void div () {Scanner kb = new Scanner (System.in) System.out.println ('Digite qualquer divisão de dois valores inteiros') int a = kb.nextInt () int b = kb.nextInt () int s = a / b System.out.p rintln ('Quociente de' + a + 'e' + b + 'é' + s)} public static void main (String [] args) {student1 Edureka1 = new student1 () Edureka1.add () Edureka1.sub () Edureka1. mul () Edureka1.div ()}}

Resultado:

Avançando ainda mais, aprenderemos a aninhar uma interface Java.

Aninhando a interface Java

Interface Nesting é um processo de declaração de uma interface dentro de outra Interface Existente ou declarar uma interface dentro de um Classe. A interface aninhada também é conhecida como um Interface interna.

como lançar duplo para int

A interface aninhada não pode ser acessada diretamente . Portanto, o aninhamento é implementado a fim de resolver os namespaces agrupando-os com seus Interfaces e Aulas. Por este procedimento,podemos chamar o Interface Aninhada através de Classe Externa ou Interface Externa nome seguido por um ponto (.) , e Nome da interface.

Vamos tentar alguns exemplos baseados em Interface Nesting. Primeiro, vamos tentar aninhar um Interface Java dentro de outro Interface Java como mostrado abaixo:

// Código de interface

package Nest public interface OuterInterface {void display () interface InnerInterface {void InnerMethod ()}}

// Class Code

pacote Nest classe NestedInterfaceDemo implementa OuterInterface.InnerInterface {public void InnerMethod () {int n = 10, t1 = 0, t2 = 1 System.out.print ('Primeiro' + n + 'termos:') para (int i = 1 i & lt = n ++ i) {System.out.print (t1 + '+') int sum = t1 + t2 t1 = t2 t2 = sum} System.out.println ('nPrinting from Nested InnerInterface method ...! n ')} public static void main (String args []) {OuterInterface.InnerInterface obj = new NestedInterfaceDemo () obj.InnerMethod ()}}

Resultado:

Primeiros 10 termos: 0 + 1 + 1 + 2 + 3 + 5 + 8 + 13 + 21 + 34 + Impressão do método de interface interna aninhada ...!

Agora, vamos tentar aninhar um Interface Java dentro de um Classe Java.

// Código de interface

pacote Nest2 public class EdurekaClass {interface EdurekaInterface {void NestedMethod ()}}

// Class Code

pacote Nest2 class NestedInterfaceDemo2 implementa EdurekaClass.EdurekaInterface {public void NestedMethod () {String input = 'Edureka' byte [] strAsByteArray = input.getBytes () byte [] result = novo byte [strAsByteArray.lengthB i .length i ++) result [i] = strAsByteArray [strAsByteArray.length-i-1] System.out.println (new String (result))} public static void main (String args []) {EdurekaClass.EdurekaInterface obj = new NestedInterfaceDemo2 () obj.NestedMethod ()}}

Resultado:

akerudE

Embora uma interface seja quase semelhante a uma classe, existem algumas diferenças entre elas. Vamos discutir suas diferenças.

Diferença entre classe Java e interface Java

Vantagens e desvantagens da interface Java

Vantagens:

• Suporte para interface Java Herança múltipla.
• A interface Java permite aos programadores quebrar as abordagens de programação complexas e simplificar o dependências entre os objetos.
• Interface Java torna o membros de dados e métodos em um aplicativo a ser acoplado livremente.

Desvantagens:

• O uso da interface Java derruba o velocidade de execução do aplicativo.
• As interfaces Java no aplicativo são usadas repetidamente em grande parte ou quase não são usadas.

Pontos-chave na interface Java

• Nenhum dos métodos declarados na interface possui um corpo que o torne uma abstração completa.
• Não é possível criar um objeto de uma interface. Portanto, a instanciação de uma interface não é possível.
• Uma classe pode implementar uma interface usando a palavra-chave implements. Vamos ver isso por meio de um exemplo.

// Código de interface

pacote extInterface public interface extInterface {public void method1 () public void method2 ()}

// Class Code

pacote extInterface import java.util.Scanner class Edureka implementa extInterface {public void method1 () {System.out.println ('implementação do método1') Scanner scanner = new Scanner (System.in) System.out.println ('Digite o número para encontrar a raiz quadrada em Java: ') double square = scanner.nextDouble () double squareRoot = Math.sqrt (square) System.out.printf (' Raiz quadrada do número:% f é:% f% n ', quadrado, squareRoot)} public void method2 () {System.out.println ('implementação do método2')} public static void main (String arg []) {extInterface obj = new Edureka () obj.method1 ()}}

Resultado:

implementação do método1 Insira o número para encontrar a raiz quadrada em Java: 16 A raiz quadrada do número: 16,0 é: 4,0

• Uma classe pode implementar várias heranças em uma única instância. Vamos entender isso por meio do código a seguir.

// Código da interface 1

pacote ExtendInt interface pública Interface1 {public void armstrong ()}

// Código da interface 2

pacote ExtendInt interface pública Interface2 {public void prime ()} // Class Code package ExtendInt public class Edureka2 implementa Interface1, Interface2 {public void armstrong () {int c = 0, a, temp int n = 153 // input temp = n enquanto (n & gt0) {a = n% 10 n = n / 10 c = c + (a * a * a)} if (temp == c) System.out.println ('número armstrong') else System.out.println ('Não é número armstrong') System.out.println ('Extending to Interface 1')} public void prime () {int i, m = 0, flag = 0 int n = 3 // insira m = n / 2 se (n == 0 || n == 1) {System.out.println (n + 'não é um número primo')} else {for (i = 2i & lt = mi ++) {if (n% i == 0) {Sistema .out.println (n + 'não é um número primo') sinalizador = 1 quebra}} if (sinalizador == 0) {System.out.println (n + 'é número primo')}} System.out.println ('Estendendo para a Interface 2 ')} public static void main (String args []) {Interface2 obj = new Edureka2 () obj.prime () Interface1 obj1 = new Edureka2 () obj1.armstrong ()}}

Resultado:

3 é o número primo estendendo-se para a interface 2 número armstrong Estendendo-se para a interface 1

• A interface Java requer que as variáveis ​​declaradas sejam inicializadas no momento da declaração.
• Modificadores de acesso para uma interface são definidos como public static e final por padrão. Vamos entender isso por um exemplo

// Código de interface

package test public interface Try {// public int a = 10 // public static final int a = 10 // static int a = 0 // final int a = 10 // int a = 10}

• Todas as declarações acima são verdadeiras e válidas dentro de uma Interface.
• A interface Java é capaz de estender qualquer número de interfaces, mas nunca pode implementar uma.
• Uma classe Java pode implementar qualquer número de interfaces.
• A classe Java não pode implementar interfaces com o mesmo nome de método e tipo de retorno diferente.
• Se houver dois ou mais métodos com o mesmo nome de método, existindo em várias interfaces, implementar o método uma vez é o suficiente. Vamos entender isso com um exemplo prático.

// Código de interface

pacote mesma interface pública A {public void display ()} // Código de interface pacote mesma interface pública B {public void display ()} // Pacote de código de classe mesma classe implementa A, B {public void display () {System.out .println ('exibindo dados')} public static void main (String [] args) {same print = new same () print.display ()}}

Resultado:

Bem-vindo ao Edureka E-Learning

Com isso, chegamos ao final deste artigo. Espero que você tenha entendido a importância da interface, sintaxe, funcionalidade, aninhamento de interface, pontos-chave da interface Java e operações realizadas com eles.

Agora que você entendeu o básico de Java, verifique o pela Edureka, uma empresa de aprendizagem online confiável com uma rede de mais de 250.000 alunos satisfeitos espalhados por todo o mundo. O curso de certificação e treinamento Java J2EE e SOA da Edureka é projetado para estudantes e profissionais que desejam ser um desenvolvedor Java. O curso foi desenvolvido para dar a você uma vantagem na programação Java e treiná-lo para os conceitos básicos e avançados de Java, juntamente com vários frameworks Java como Hibernate Primavera .

Tem alguma questão para nós? Mencione-o na seção de comentários deste blog “Interface Java” e entraremos em contato com você o mais breve possível.