Neste tutorial, aprenderemos sobre interfaces Java. Aprenderemos como implementar interfaces e quando usá-las em detalhes com a ajuda de exemplos.
Uma interface é uma classe totalmente abstrata que inclui um grupo de métodos sem corpo.
Em Java, uma interface define um conjunto de especificações que outras classes devem implementar. Por exemplo,
interface Language ( public void getName(); )
Aqui, usamos a interfacepalavra-chave para criar uma interface chamada Language. A interface de linguagem define uma especificação getName().
Agora, cada classe que usa essa interface deve implementar a getName()especificação.
Exemplo: Interface Java
// create an interface interface Language ( void getName(String name); ) // class implements interface class ProgrammingLanguage implements Language ( // implementation of abstract method public void getName(String name) ( System.out.println("Programming Language: " + name); ) ) class Main ( public static void main(String() args) ( ProgrammingLanguage language = new ProgrammingLanguage(); language.getName("Java"); ) )
Resultado
Linguagem de programação: Java
No exemplo acima, criamos uma interface chamada Language. A interface inclui um método abstrato getName().
Aqui, a classe ProgrammingLanguage implementa a interface e fornece a implementação para o método.
Não é obrigatório usar abstractpalavras-chave ao declarar métodos abstratos dentro de uma interface. Isso porque uma interface inclui apenas métodos abstratos, não métodos regulares.
Nota : Todos os métodos dentro de uma interface são implicitamente publice todos os campos são implicitamente public static final. Por exemplo,
interface Language ( // by default public static final String type = "programming language"; // by default public void getName(); )
Implementando uma Interface
Como classes abstratas, não podemos criar objetos de uma interface. No entanto, podemos implementar uma interface.
Usamos a implementspalavra-chave para implementar uma interface. Por exemplo,
// create an interface interface Polygon ( void getArea(int length, int breadth); ) // implement the Polygon interface class Rectangle implements Polygon ( // implementation of abstract method public void getArea(int length, int breadth) ( System.out.println("The area of the rectangle is " + (length * breadth)); ) ) class Main ( public static void main(String() args) ( // create an object Rectangle r1 = new Rectangle(); r1.getArea(5, 6); ) )
Resultado
A área do retângulo é 30
No exemplo acima, criamos uma interface chamada Polygon. A interface contém um método abstrato getArea().
Aqui, a classe Rectangle implementa Polygon. E fornece a implementação do getArea()método.
Observação : uma classe pode implementar várias interfaces. Por exemplo,
interface A ( // members of A ) interface B ( // members of B ) class C implements A, B ( // abstract members of A // abstract members of B )
Estendendo uma Interface
Semelhante às classes, as interfaces podem estender outras interfaces. A extendspalavra-chave é usada para estender interfaces. Por exemplo,
interface Line ( // members of Line interface ) // extending interface interface Polygon extends Line ( // members of Polygon interface // members of Line interface )
Aqui, a interface Polygon estende a interface Line. Agora, se alguma classe implementa Polygon, ela deve fornecer implementações para todos os métodos abstratos de Line e Polygon.
Observação : uma interface pode estender várias interfaces. Por exemplo,
interface A (… ) interface B (… ) interface C extends A, B (… )
Vantagens da interface em Java
Agora que sabemos o que são interfaces, vamos aprender por que as interfaces são usadas em Java.
- As interfaces fornecem especificações que uma classe (que as implementa) deve seguir.
Em nosso exemplo anterior, usamosgetArea()como uma especificação dentro da interface Polygon. Isso é como definir uma regra de que devemos ser capazes de obter a área de cada polígono.
Agora, qualquer classe que implemente a interface Polygon deve fornecer uma implementação para ogetArea()método. - Semelhante às classes abstratas, as interfaces nos ajudam a obter abstração em Java .
Aqui, sabemos quegetArea()calcula a área dos polígonos, mas a forma como a área é calculada é diferente para polígonos diferentes. Portanto, a implementação degetArea()é independente uma da outra. - As interfaces também são usadas para obter herança múltipla em Java. Por exemplo,
interface Line (… ) interface Polygon (… ) class Rectangle implements Line, Polygon (… )
Aqui, a classe Rectangle está implementando duas interfaces diferentes. É assim que alcançamos herança múltipla em Java.
métodos padrão em interfaces Java
Com o lançamento do Java 8, agora podemos adicionar métodos com implementação dentro de uma interface. Esses métodos são chamados de métodos padrão.
Para declarar métodos padrão dentro de interfaces, usamos a defaultpalavra - chave. Por exemplo,
public default void getSides() ( // body of getSides() )
Por que métodos padrão?
Vamos analisar um cenário para entender por que os métodos padrão são introduzidos em Java.
Suponha que precisamos adicionar um novo método em uma interface.
Podemos adicionar o método em nossa interface facilmente, sem implementação. No entanto, esse não é o fim da história. Todas as nossas classes que implementam essa interface devem fornecer uma implementação para o método.
Se um grande número de classes estava implementando essa interface, precisamos rastrear todas essas classes e fazer alterações nelas. Isso não é apenas tedioso, mas também sujeito a erros.
Para resolver isso, o Java introduziu métodos padrão. Os métodos padrão são herdados como métodos comuns.
Vamos dar um exemplo para entender melhor os métodos padrão.
Exemplo: método padrão na interface Java
interface Polygon ( void getArea(); // default method default void getSides() ( System.out.println("I can get sides of a polygon."); ) ) // implements the interface class Rectangle implements Polygon ( public void getArea() ( int length = 6; int breadth = 5; int area = length * breadth; System.out.println("The area of the rectangle is " + area); ) // overrides the getSides() public void getSides() ( System.out.println("I have 4 sides."); ) ) // implements the interface class Square implements Polygon ( public void getArea() ( int length = 5; int area = length * length; System.out.println("The area of the square is " + area); ) ) class Main ( public static void main(String() args) ( // create an object of Rectangle Rectangle r1 = new Rectangle(); r1.getArea(); r1.getSides(); // create an object of Square Square s1 = new Square(); s1.getArea(); s1.getSides(); ) )
Resultado
A área do retângulo é 30 Eu tenho 4 lados. A área do quadrado é 25 Posso obter os lados de um polígono.
No exemplo acima, criamos uma interface chamada Polygon. Possui um método padrão getSides()e um método abstrato getArea().
Aqui, criamos duas classes Rectangle e Square que implementam Polygon.
A classe Rectangle fornece a implementação do getArea()método e substitui o getSides()método. No entanto, a classe Square fornece apenas a implementação do getArea()método.
Agora, ao chamar o getSides()método usando o objeto Rectangle, o método substituído é chamado. Porém, no caso do objeto Square, o método padrão é chamado.
Métodos privados e estáticos na interface
O Java 8 também adicionou outro recurso para incluir métodos estáticos dentro de uma interface.
Semelhante a uma classe, podemos acessar métodos estáticos de uma interface usando suas referências. Por exemplo,
// create an interface interface Polygon ( staticMethod()(… ) ) // access static method Polygon.staticMethod();
Note: With the release of Java 9, private methods are also supported in interfaces.
We cannot create objects of an interface. Hence, private methods are used as helper methods that provide support to other methods in interfaces.
Practical Example of Interface
Let's see a more practical example of Java Interface.
// To use the sqrt function import java.lang.Math; interface Polygon ( void getArea(); // calculate the perimeter of a Polygon default void getPerimeter(int… sides) ( int perimeter = 0; for (int side: sides) ( perimeter += side; ) System.out.println("Perimeter: " + perimeter); ) ) class Triangle implements Polygon ( private int a, b, c; private double s, area; // initializing sides of a triangle Triangle(int a, int b, int c) ( this.a = a; this.b = b; this.c = c; s = 0; ) // calculate the area of a triangle public void getArea() ( s = (double) (a + b + c)/2; area = Math.sqrt(s*(s-a)*(s-b)*(s-c)); System.out.println("Area: " + area); ) ) class Main ( public static void main(String() args) ( Triangle t1 = new Triangle(2, 3, 4); // calls the method of the Triangle class t1.getArea(); // calls the method of Polygon t1.getPerimeter(2, 3, 4); ) )
Output
Area: 2.9047375096555625 Perimeter: 9
In the above program, we have created an interface named Polygon. It includes a default method getPerimeter() and an abstract method getArea().
We can calculate the perimeter of all polygons in the same manner so we implemented the body of getPerimeter() in Polygon.
Now, all polygons that implement Polygon can use getPerimeter() to calculate perimeter.
No entanto, a regra para calcular a área é diferente para polígonos diferentes. Portanto, getArea()é incluído sem implementação.
Qualquer classe que implemente Polygon deve fornecer uma implementação de getArea().
