Menu

Interface Java e tutorial de classe abstrata com exemplos

java interface abstract class tutorial with examples

Experimente Nosso Instrumento Para Eliminar Problemas

Este tutorial em vídeo explica o que é interface Java, como implementá-la e herança múltipla usando interfaces em Java com exemplos:

Em um de nossos tutoriais anteriores, discutimos a abstração em detalhes. Lá, discutimos classes abstratas e métodos abstratos. Sabemos que as classes abstratas fornecem abstração, pois também podemos ter algum método não abstrato na classe abstrata.

O recurso que fornece 100% de abstração em Java é chamado de “ Interface ”. Neste tutorial, discutiremos interfaces em Java.

=> Dê uma olhada no guia para iniciantes em Java aqui.

Interfaces Java e classes abstratas

O que você aprenderá:

Tutoriais em vídeo sobre interfaces e classes abstratas

Introdução às interfaces e classes abstratas em Java - Parte 1:

Visão geral das interfaces e classes abstratas em Java - Parte 2:

Abstração e herança em Java:

O que é uma interface em Java

Uma interface em Java é definida como um tipo abstrato que especifica o comportamento da classe. Uma interface é um tipo de protocolo que define regras sobre como uma classe específica deve se comportar.

Uma interface em Java pode conter métodos abstratos e constantes estáticas. Por padrão, todos os métodos da interface são públicos e abstratos.

Um exemplo simples de uma interface em Java é fornecido abaixo.

interface shape{ public static final String color = “Red”; public void calculateArea(); }

O exemplo acima define uma interface 'forma' que tem uma variável estática e um método abstrato 'calculArea ()'.

Uma interface é uma entidade que possui apenas métodos abstratos como seu corpo. Ele também pode conter variáveis ​​finais estáticas.

Assim, assim como a classe, uma interface também pode ter métodos e variáveis, mas observe que os métodos são abstratos (sem implementação) e as variáveis ​​são estáticas.

Listados abaixo estão algumas propriedades que devem ser mantidas em mente relacionadas às interfaces:

  • Interfaces são projetos para uma classe. Eles dizem à classe o que fazer por meio de seus métodos.
  • Uma interface especifica métodos abstratos e classes que implementam essa interface também devem implementar esses métodos.
  • Se uma classe que implementa a interface não define todos os métodos da interface, essa classe se torna uma classe abstrata.

A sintaxe geral da declaração da interface é fornecida abaixo.

interface { //constant or static fields declaration //abstract method declaration //default declarations }

Conforme mostrado na declaração acima, usamos uma palavra-chave Java “interface” que indica que estamos declarando uma interface agora.

melhor extensão bloqueador de pop-up para cromo

Uma palavra-chave ‘interface’ é seguida por interface_name e, em seguida, pelas chaves de abertura. Então, temos várias declarações de métodos abstratos, declaração de campos estáticos, etc. Finalmente, fechamos as chaves.

Por exemplo,se quisermos declarar uma interface ‘TestInterface’ com dois métodos, ou seja, method_one e method_two, a declaração de TestInterface será a seguinte:

interface TestInterface{ void method_one(); void method_two(); }

Usos da interface em Java

  • As interfaces em Java fornecem 100% de abstração, pois podem ter apenas métodos abstratos.
  • Usando interfaces, podemos obter várias heranças em Java, o que não é possível usando classes.
  • Para obter um acoplamento fraco, uma interface pode ser usada.

Como implementar uma interface em Java

Uma vez que a interface é declarada, podemos usá-la em uma classe usando a palavra-chave “implementa” na declaração da classe.

Esta palavra-chave ‘implementa’ aparece após o nome da classe, conforme mostrado abaixo:

class implements { //class body }

Implementar uma interface é o mesmo que assinar um contrato. Portanto, uma classe que implementa uma interface significa que ela assinou um contrato e concordou em implementar os métodos abstratos da interface ou, em outras palavras, executar o comportamento especificado pela interface.

Se a classe que implementa a interface não implementa o comportamento exato especificado na interface, a classe precisa ser declarada como abstrata.

Exemplo de implementação de interface

A seguir está um exemplo simples de uma interface em Java.

//interface declaration interface Polygon_Shape { void calculateArea(int length, int breadth); } //implement the interface class Rectangle implements Polygon_Shape { //implement the interface method public void calculateArea(int length, int breadth) { System.out.println('The area of the rectangle is ' + (length * breadth)); } } class Main { public static void main(String() args) { Rectangle rect = new Rectangle(); //declare a class object rect.calculateArea(10, 20); //call the method } }

Resultado:

Área de saída de exemplo de retângulo

O programa acima demonstra o exemplo simples de interfaces em Java. Aqui, declaramos uma interface chamada Polygon_Shape e a classe Rectangle a implementa.

Convenção de nomenclatura de interface em Java

As convenções de nomenclatura Java são as diretrizes de nomenclatura que devemos seguir como programadores para que possamos produzir código legível consistente. Java usa notações “TitleCase” para as classes de nomenclatura e interfaces. Ele usa notações “CamelCase” para variáveis, métodos, etc.

No que diz respeito à interface, o nome da interface está em caixa de título com a primeira letra de cada palavra do nome da interface em maiúscula. Os nomes de interface são selecionados de forma que geralmente sejam adjetivos. Mas quando as interfaces representam a família de classes como mapa ou lista, elas podem receber nomes de substantivos.

Alguns exemplos de nomes de interface válidos são fornecidos abaixo:

public interface Iterable {} public interface List {} public interface Serializable {} public interface Clonable {} public interface Runnable {}

Construtor de Interface

A próxima pergunta é se uma interface possui um construtor.

Sabemos que precisamos de objetos para invocar métodos. Para criar objetos, precisamos de construtores. Mas, no caso das interfaces em Java, os métodos não são implementados.

Os métodos das interfaces são todos abstratos. Portanto, não adianta chamar esses métodos a partir da interface. Em segundo lugar, como as interfaces são abstratas por padrão, não podemos criar objetos da interface. Portanto, não precisamos de construtores para Interface.

Métodos de Interface

Nesta seção, discutiremos como declarar métodos de interface. Por regra, uma interface pode ter apenas métodos públicos ou, por padrão, os métodos de interface são públicos. Nenhum outro modificador de acesso pode ser usado dentro da interface.

Portanto, quer o declaremos explicitamente ou não, cada método na interface é, por padrão, abstrato com visibilidade pública.

Portanto, se void printMethod () for o protótipo que pretendemos declarar em uma interface, as seguintes declarações serão as mesmas.

void printMethod(); public void printMethod(); abstract void printMethod (); public abstract void printMethod ();

Observe que não podemos usar os seguintes modificadores dentro da interface para os métodos de interface.

  • final
  • estático
  • Privado
  • protegido
  • sincronizado
  • nativo
  • strictfp

Agora vamos implementar um programa Java para demonstrar a visibilidade do método da interface.

//declare an interface interface TestInterface { void printMethod(); //default visibility is public. } //interface implementation class TestClass implements TestInterface { //if the access modifier is changed to any other, compiler generates error public void printMethod() { System.out.println('TestClass::printMethod()'); } } class Main { public static void main(String() args) { TestClass tc = new TestClass(); //create an object tc.printMethod(); //call concrete method } }

Resultado:

TestClass printMethod

Conforme já mencionado, por padrão, os métodos de interface são públicos. Portanto, quando não especificamos nenhum modificador de acesso para o método de interface, ele é público como no programa acima.

Suponha que alteremos a declaração do método da interface no programa acima da seguinte maneira:

private void printMethod ();

Então, isso significa que especificamos o método de interface printMethod () como privado. Quando compilamos o programa, obtemos o seguinte erro do compilador.

erro: modificador privado não permitido aqui

private void printMethod ();

O segundo caso que podemos testar é alterando o modificador do método implementado na classe TestClass de público para privado. Agora, o modificador padrão da classe é privado. Portanto, apenas removemos a palavra-chave pública do protótipo do método na classe da seguinte maneira:

void printMethod() { System.out.println('TestClass::printMethod()'); }

Agora, se compilarmos o programa, obteremos o seguinte erro.

erro: printMethod () em TestClass não pode implementar printMethod () em TestInterface
void printMethod ()
^
tentativa de atribuir privilégios de acesso mais fracos; era público

Portanto, o ponto a ser observado aqui é que não podemos alterar o modificador de acesso do método implementado da interface para qualquer outro modificador de acesso. Como os métodos de interface são por padrão públicos, quando são implementados por classes que implementam interfaces, esses métodos também devem ser públicos.

Campos de interface em Java

Os campos ou variáveis ​​declarados em uma interface são, por padrão, públicos, estáticos e finais. Isso significa que, uma vez declarado, seu valor não pode ser alterado.

Observe que, se os campos da interface forem definidos sem especificar nenhum desses modificadores, os compiladores Java assumem esses modificadores. Por exemplo, se não especificarmos um modificador público ao declarar o campo na interface, ele será assumido por padrão.

Quando uma interface é implementada por uma classe, ela fornece uma implementação para todos os métodos abstratos da interface. Da mesma forma, todos os campos declarados na interface também são herdados pela classe que implementa a interface. Assim, uma cópia do campo de interface está presente na classe de implementação.

Agora, todos os campos da interface são estáticos por padrão. Portanto, podemos acessá-los usando o nome da interface diretamente da mesma forma que acessamos os campos estáticos da classe usando o nome da classe e não o objeto.

O exemplo de programa Java abaixo mostra como podemos acessar os campos da interface.

//interface declaration interface TestInterface{ public static int value = 100; //interface field public void display(); } //Interface implementation class TestClass implements TestInterface{ public static int value = 5000; //class fields public void display() { System.out.println('TestClass::display () method'); } public void show() { System.out.println('TestClass::show () method'); } } public class Main{ public static void main(String args()) { TestClass testObj = new TestClass(); //print interface and class field values. System.out.println('Value of the interface variable (value): '+TestInterface.value); System.out.println('Value of the class variable (value): '+testObj.value); } }

Resultado:

Exemplo de campo de interface

Conforme mostrado no programa acima, os campos de interface podem ser acessados ​​usando um nome de Interface seguido por um operador de ponto (.) E a variável real ou nome de campo.

A interface genérica em Java

Discutimos os genéricos Java em nossos tutoriais anteriores. Além de ter classes, métodos, etc. genéricos, também podemos ter interfaces genéricas. As interfaces genéricas podem ser especificadas de maneira semelhante, da maneira como especificamos as classes genéricas.

As interfaces genéricas são declaradas com parâmetros de tipo que as tornam independentes de um tipo de dados.

A sintaxe geral da interface genérica é a seguinte:

exemplos de dispositivos de internet das coisas
interface { //interface methods and variables }

Agora, se quisermos usar a interface genérica acima em uma classe, podemos ter a definição de classe conforme mostrado abaixo:

class implements interface_name { //class body }

Observe que temos que especificar a mesma lista de parâmetros com a classe e com a interface.

O programa Java a seguir demonstra as interfaces genéricas em Java.

//generic interface declaration interface MinInterface>{ T minValue(); } //implementation for generic interface class MinClassImpl> implements MinInterface { T() intArray; MinClassImpl(T() o) { intArray = o; } public T minValue() { T v = intArray(0); for (int i = 1; i intMinValue = new MinClassImpl (intArray); MinClassImpl charMinValue = new MinClassImpl(charArray); //call interface method minValue for int type array System.out.println('Min value in intOfArray: ' + intMinValue.minValue()); //call interface method minValue for char type array System.out.println('Min value in charOfArray: ' + charMinValue.minValue()); }

Resultado:

Saída de exemplo de interface genérica

O programa acima implementa uma interface contendo um método para encontrar o valor mínimo na matriz. Esta é uma interface genérica. A classe implementa essa interface e substitui o método. No método principal, chamamos o método de interface para encontrar o valor mínimo em um inteiro e uma matriz de caracteres.

Várias interfaces em Java

Em nosso tópico de herança, vimos que Java não permite que uma classe herde de várias classes, pois isso resulta em uma ambigüidade chamada “Problema do Diamante”.

No entanto, uma classe pode herdar ou implementar mais de uma interface. Nesse caso, é conhecido como herança múltipla. Portanto, embora não tenhamos permissão para implementar herança múltipla em Java por meio de classes, podemos fazer isso usando interfaces.

O diagrama a seguir mostra a herança múltipla usando interfaces. Aqui, uma classe implementa duas interfaces, ou seja, Interface_one e Interface_two.

Múltiplas interfaces em Java

Observe que, quando uma classe implementa as interfaces múltiplas, os nomes das interfaces são separados por vírgulas na declaração da classe. Podemos implementar tantas interfaces, desde que possamos lidar com a complexidade.

O programa Java que demonstra várias interfaces é mostrado abaixo.

//Interface_One declaration interface Interface_One{ void print(); } //Interface_Two declaration interface Interface_Two{ void show(); } //multiple inheritance - DemoClass implementing Interface_One&Interface_Two class DemoClass implements Interface_One,Interface_Two{ public void print(){ //Override Interface_One print() System.out.println('Democlass::Interface_One_Print ()'); } public void show(){ //Override Interface_Two show() System.out.println('DemoClass::Interface_Two_Show ()'); } } public class Main{ public static void main(String args()){ DemoClass obj = new DemoClass(); //create DemoClass object and call methods obj.print(); obj.show(); } }

Resultado:

exemplo de múltiplas interfaces

como abrir arquivos mkv no windows

Conforme mostrado acima, implementamos duas interfaces. Em seguida, substituímos seus respectivos métodos e os chamamos no método principal.

A herança múltipla em Java fornece todos os benefícios que a herança múltipla fornece no C ++. Mas, ao contrário da herança múltipla usando classes, a herança múltipla usando interfaces não tem qualquer ambigüidade.

Herança da interface em Java: a interface estende a interface

Quando uma classe implementa uma interface, isso é feito usando o método ‘ implementos 'Palavra-chave. Em Java, uma interface pode herdar outra interface. Isso é feito usando o ' estende 'Palavra-chave. Quando uma interface estende outra interface, ela é chamada de “ Herança de interface ”Em Java.

interface estende interface

O programa Java para implementar a herança da interface é mostrado abaixo.

//Interface_One declaration interface Interface_One{ void print(); } //Interface_Two declaration; inherits from Interface_One interface Interface_Two extends Interface_One{ void show(); } //multiple inheritance - DemoClass implementing Interface_Two class DemoClass implements Interface_Two{ public void print(){ //Override Interface_Two print() System.out.println('Democlass public class Main{ public static void main(String args()){ DemoClass obj = new DemoClass(); //create DemoClass object and call methods obj.print(); obj.show(); } }

Resultado:

saída de exemplo de classe de demonstração

Modificamos o mesmo programa que usamos para herança múltipla usando interfaces para demonstrar a herança de interface. Aqui, estendemos Interface_one em Interface_two e, em seguida, implementamos Interface_two em uma classe. Como as interfaces são herdadas, ambos os métodos estão disponíveis para substituição.

perguntas frequentes

P # 1) Qual é o uso da Interface em Java?

Responda: Uma interface em Java é uma entidade usada para atingir 100% de abstração. Ele pode conter apenas métodos abstratos que podem ser substituídos pela classe que implementa a interface.

A interface de certa forma atua como um projeto da classe em que fornece à classe os protótipos do método abstrato e constantes estáticas e, em seguida, a classe tem que substituir esses métodos implementando a interface.

P # 2) Quais são as vantagens da Interface em Java?

Responda: Algumas das vantagens da Interface são as seguintes:

  1. A interface atua como um projeto da classe.
  2. A interface fornece 100% de abstração em Java, pois possui todos os métodos abstratos.
  3. As interfaces podem ser usadas para obter herança múltipla em Java. Java não permite herdar de mais de uma classe, mas uma classe pode implementar várias interfaces.

# 3) Uma interface pode ter métodos?

Responda: As interfaces podem ter protótipos de métodos e constantes estáticas e finais. Mas a partir do Java 8, as interfaces podem conter métodos estáticos e padrão.

P # 4) Podemos declarar a interface como final?

Responda: Não. Se declararmos uma interface como final, a classe não será capaz de implementá-la. Sem ser implementada por nenhuma classe, a interface não terá nenhum propósito.

Mais sobre interfaces

As interfaces são projetos como a classe, mas terão apenas a declaração do método. Não terá nenhum método de implementação. Todos os métodos na interface são abstratos públicos por padrão. A interface Java 1.8 pode ter métodos estáticos e padrão.

As interfaces são usadas principalmente em APIs.

Por exemplo: Considere que você está projetando o motor de um veículo.

Quando terminar com a parte de hardware, você deseja que algumas das funcionalidades do software sejam implementadas por um cliente que está usando seu motor. Então, nesse caso, você pode definir as funcionalidades do seu motor em uma interface.

Interface Engine { void changeGear(int a); void speedUp(int a); }

Regras a serem seguidas para Interface

  • A classe que está implementando a interface deve implementar todos os métodos na interface.
  • Uma interface pode conter variáveis ​​finais.
public class Vehicle implements Engine { int speed; int gear; @Override public void speedUp(int a) { this.speed=a; System.out.println('speed'+speed); } @Override public void changeGear(int a) { this.gear=a; System.out.println('gear'+gear); } public static void main(String() args) { // TODO Auto-generated method stub Vehicle objv=new Vehicle(); objv.changeGear(3); objv.speedUp(70); } }

Regras a serem seguidas para interface

Aqui, a classe Vehicle é a subclasse que está implementando a interface do mecanismo.

O que são classes abstratas?

Uma classe abstrata é como uma classe, mas terá métodos abstratos e métodos concretos. Métodos abstratos não têm uma implementação. Terá apenas a declaração do método.

Regras a serem seguidas para a aula abstrata

  • A classe abstrata não pode ser instanciada.
  • A classe filha que estende a classe abstrata deve implementar todos os métodos abstratos da classe pai ou a classe Criança deve ser declarada como uma classe abstrata.

Quando você deseja projetar uma implementação parcial, pode escolher uma classe abstrata.

Exemplo de programa de classe abstrata:

EmployeeDetails.java

public abstract class EmployeeDetails { private String name; private int emp_ID; public void commonEmpDetaills() { System.out.println('Name'+name); System.out.println('emp_ID'+emp_ID); } public abstract void confidentialDetails(int s,String p); }

EmployeeDetails

A classe que vai estender a classe abstrata.

HR.java

public class HR extends EmployeeDetails { private int salary; private String performance; @Override public void confidentialDetails(int s,String p) { this.salary=s; this.performance=p; System.out.println('salary=='+salary); System.out.println('performance=='+performance); } public static void main(String() args) { HR hr =new HR(); hr.confidentialDetails(5000,'good'); } }

hr-java

Pontos-chave a serem observados:

  • Em Interfaces, todos os métodos não terão implementação de método.
  • A classe que está implementando a interface deve implementar todos os métodos dessa interface específica.
  • As classes abstratas podem ter métodos abstratos, bem como métodos concretos normais. Métodos abstratos não têm uma implementação.
  • A classe que está estendendo a classe abstrata deve ter a implementação de todos os métodos abstratos da classe abstrata.
  • Se a subclasse não tem informações suficientes para implementar os métodos abstratos, a subclasse deve ser declarada como uma classe abstrata.

Conclusão

Neste tutorial, apresentamos os conceitos básicos de interfaces em Java. Discutimos a definição da interface, juntamente com a necessidade de interfaces. Exploramos sua sintaxe e definição básicas. Em seguida, discutimos como usar interfaces para as quais usamos a palavra-chave ‘implementa’.

Aprendemos como usar várias interfaces e herança de interface em Java. Usando várias interfaces, podemos implementar herança múltipla em Java. Herança de interface é quando uma interface estende outra interface.

=> Visite aqui para ver a série de treinamento Java para todos

Leitura recomendada

^