Java - Interfacce
Un'interfaccia è un tipo di riferimento in Java. È simile alla classe. È una raccolta di metodi astratti. Una classe implementa un'interfaccia, ereditando così i metodi astratti dell'interfaccia.
Insieme ai metodi astratti, un'interfaccia può anche contenere costanti, metodi predefiniti, metodi statici e tipi annidati. I corpi dei metodi esistono solo per metodi predefiniti e metodi statici.
Scrivere un'interfaccia è simile alla scrittura di una classe. Ma una classe descrive gli attributi e i comportamenti di un oggetto. E un'interfaccia contiene comportamenti implementati da una classe.
A meno che la classe che implementa l'interfaccia non sia astratta, tutti i metodi dell'interfaccia devono essere definiti nella classe.
Un'interfaccia è simile a una classe nei seguenti modi:
Un'interfaccia può contenere un numero qualsiasi di metodi.
Un'interfaccia è scritta in un file con estensione .java estensione, con il nome dell'interfaccia che corrisponde al nome del file.
Il codice byte di un'interfaccia appare in un file .class file.
Le interfacce vengono visualizzate nei pacchetti e il file bytecode corrispondente deve trovarsi in una struttura di directory che corrisponda al nome del pacchetto.
Tuttavia, un'interfaccia è diversa da una classe in diversi modi, tra cui:
Non è possibile creare un'istanza di un'interfaccia.
Un'interfaccia non contiene alcun costruttore.
Tutti i metodi in un'interfaccia sono astratti.
Un'interfaccia non può contenere campi istanza. Gli unici campi che possono apparire in un'interfaccia devono essere dichiarati sia statici che finali.
Un'interfaccia non è estesa da una classe; è implementato da una classe.
Un'interfaccia può estendere più interfacce.
Dichiarazione di interfacce
Il interfaceparola chiave viene utilizzata per dichiarare un'interfaccia. Ecco un semplice esempio per dichiarare un'interfaccia:
Esempio
Di seguito è riportato un esempio di interfaccia:
/* File name : NameOfInterface.java */
import java.lang.*;
// Any number of import statements
public interface NameOfInterface {
// Any number of final, static fields
// Any number of abstract method declarations\
}
Le interfacce hanno le seguenti proprietà:
Un'interfaccia è implicitamente astratta. Non è necessario utilizzare l'estensioneabstract parola chiave durante la dichiarazione di un'interfaccia.
Ogni metodo in un'interfaccia è anche implicitamente astratto, quindi la parola chiave abstract non è necessaria.
I metodi in un'interfaccia sono implicitamente pubblici.
Esempio
/* File name : Animal.java */
interface Animal {
public void eat();
public void travel();
}
Implementazione delle interfacce
Quando una classe implementa un'interfaccia, puoi pensare alla classe come alla firma di un contratto, che accetta di eseguire i comportamenti specifici dell'interfaccia. Se una classe non esegue tutti i comportamenti dell'interfaccia, la classe deve dichiararsi astratta.
Una classe utilizza l'estensione implementsparola chiave per implementare un'interfaccia. La parola chiave implements appare nella dichiarazione della classe che segue la parte extends della dichiarazione.
Esempio
/* File name : MammalInt.java */
public class MammalInt implements Animal {
public void eat() {
System.out.println("Mammal eats");
}
public void travel() {
System.out.println("Mammal travels");
}
public int noOfLegs() {
return 0;
}
public static void main(String args[]) {
MammalInt m = new MammalInt();
m.eat();
m.travel();
}
}
Questo produrrà il seguente risultato:
Produzione
Mammal eats
Mammal travels
Quando si sovrascrivono i metodi definiti nelle interfacce, ci sono diverse regole da seguire:
Le eccezioni verificate non dovrebbero essere dichiarate su metodi di implementazione diversi da quelli dichiarati dal metodo di interfaccia o da sottoclassi di quelli dichiarati dal metodo di interfaccia.
La firma del metodo di interfaccia e lo stesso tipo o sottotipo restituito dovrebbero essere mantenuti quando si sovrascrivono i metodi.
Una stessa classe di implementazione può essere astratta e, in tal caso, i metodi di interfaccia non devono essere implementati.
Quando l'implementazione si interfaccia, ci sono diverse regole:
Una classe può implementare più di un'interfaccia alla volta.
Una classe può estendere solo una classe, ma implementare molte interfacce.
Un'interfaccia può estendere un'altra interfaccia, in modo simile a come una classe può estendere un'altra classe.
Estensione delle interfacce
Un'interfaccia può estendere un'altra interfaccia nello stesso modo in cui una classe può estendere un'altra classe. Ilextends la parola chiave viene utilizzata per estendere un'interfaccia e l'interfaccia figlio eredita i metodi dell'interfaccia padre.
La seguente interfaccia Sports è estesa dalle interfacce Hockey e Football.
Esempio
// Filename: Sports.java
public interface Sports {
public void setHomeTeam(String name);
public void setVisitingTeam(String name);
}
// Filename: Football.java
public interface Football extends Sports {
public void homeTeamScored(int points);
public void visitingTeamScored(int points);
public void endOfQuarter(int quarter);
}
// Filename: Hockey.java
public interface Hockey extends Sports {
public void homeGoalScored();
public void visitingGoalScored();
public void endOfPeriod(int period);
public void overtimePeriod(int ot);
}
L'interfaccia Hockey ha quattro metodi, ma ne eredita due da Sports; quindi, una classe che implementa Hockey deve implementare tutti e sei i metodi. Allo stesso modo, una classe che implementa Football deve definire i tre metodi di Football e i due metodi di Sports.
Estensione di più interfacce
Una classe Java può estendere solo una classe genitore. L'ereditarietà multipla non è consentita. Le interfacce non sono classi, tuttavia, e un'interfaccia può estendere più di un'interfaccia padre.
La parola chiave extends viene utilizzata una volta e le interfacce padre vengono dichiarate in un elenco separato da virgole.
Ad esempio, se l'interfaccia Hockey estendesse sia Sport che Eventi, verrebbe dichiarata come:
Esempio
public interface Hockey extends Sports, Event
Interfacce di codifica
L'utilizzo più comune dell'estensione delle interfacce si verifica quando l'interfaccia padre non contiene alcun metodo. Ad esempio, l'interfaccia MouseListener nel pacchetto java.awt.event ha esteso java.util.EventListener, che è definito come -
Esempio
package java.util;
public interface EventListener
{}
Un'interfaccia senza metodi al suo interno è indicata come tagginginterfaccia. Ci sono due scopi di progettazione di base per la codifica delle interfacce:
Creates a common parent- Come con l'interfaccia EventListener, che è estesa da dozzine di altre interfacce nell'API Java, è possibile utilizzare un'interfaccia di tagging per creare un genitore comune in un gruppo di interfacce. Ad esempio, quando un'interfaccia estende EventListener, la JVM sa che questa particolare interfaccia verrà utilizzata in uno scenario di delega degli eventi.
Adds a data type to a class- Questa situazione è da dove viene il termine, tagging. Una classe che implementa un'interfaccia di etichettatura non ha bisogno di definire alcun metodo (poiché l'interfaccia non ne ha), ma la classe diventa un tipo di interfaccia attraverso il polimorfismo.