Cos’è un’interfaccia in Java?

Proprio come contrappunto a questa domanda : cos’è un’interfaccia in Java?

Un’interfaccia è una forma speciale di una class astratta che non implementa alcun metodo. In Java, crei un’interfaccia come questa:

interface Interface { void interfaceMethod(); } 

Poiché l’interfaccia non è in grado di implementare alcun metodo, è implicito che l’intera cosa, inclusi tutti i metodi, sia pubblica e astratta (l’abstract in termini Java significa “non implementato da questa class”). Quindi l’interfaccia sopra è identica all’interfaccia seguente:

 public interface Interface { abstract public void interfaceMethod(); } 

Per utilizzare questa interfaccia, è sufficiente implementare l’interfaccia. Molte classi possono implementare un’interfaccia e una class può implementare molte interfacce:

 interface InterfaceA { void interfaceMethodA(); } interface InterfaceB { void interfaceMethodB(); } public class ImplementingClassA implements InterfaceA, InterfaceB { public void interfaceMethodA() { System.out.println("interfaceA, interfaceMethodA, implementation A"); } public void interfaceMethodB() { System.out.println("interfaceB, interfaceMethodB, implementation A"); } } public class ImplementingClassB implements InterfaceA, InterfaceB { public void interfaceMethodA() { System.out.println("interfaceA, interfaceMethodA, implementation B"); } public void interfaceMethodB() { System.out.println("interfaceB, interfaceMethodB, implementation B"); } } 

Ora, se volessi, potresti scrivere un metodo come questo:

 public void testInterfaces() { ImplementingClassA u = new ImplementingClassA(); ImplementingClassB v = new ImplementingClassB(); InterfaceA w = new ImplementingClassA(); InterfaceA x = new ImplementingClassB(); InterfaceB y = new ImplementingClassA(); InterfaceB z = new ImplementingClassB(); u.interfaceMethodA(); // prints "interfaceA, interfaceMethodA, implementation A" u.interfaceMethodB(); // prints "interfaceB, interfaceMethodB, implementation A" v.interfaceMethodA(); // prints "interfaceA, interfaceMethodA, implementation B" v.interfaceMethodB(); // prints "interfaceB, interfaceMethodB, implementation B" w.interfaceMethodA(); // prints "interfaceA, interfaceMethodA, implementation A" x.interfaceMethodA(); // prints "interfaceA, interfaceMethodA, implementation B" y.interfaceMethodB(); // prints "interfaceB, interfaceMethodB, implementation A" z.interfaceMethodB(); // prints "interfaceB, interfaceMethodB, implementation B" } 

Tuttavia, non potresti mai fare quanto segue:

 public void testInterfaces() { InterfaceA y = new ImplementingClassA(); InterfaceB z = new ImplementingClassB(); y.interfaceMethodB(); // ERROR! z.interfaceMethodA(); // ERROR! } 

Il motivo per cui non si può fare questo è che y è di tipo interfaceA e non c’è interfaceMethodB() interfaceA . Allo stesso modo, z è di tipo interfaceB e non c’è interfaceMethodA() interfaceB .

Ho detto prima che le interfacce sono solo una forma speciale di una class astratta. Per illustrare questo punto, guarda il seguente codice.

 interface Interface { void abstractMethod(); } abstract public class AbstractClass { abstract public void abstractMethod(); } 

Si erediterebbe da queste classi quasi esattamente allo stesso modo:

 public class InheritsFromInterface implements Interface { public void abstractMethod() { System.out.println("abstractMethod()"); } } public class InteritsFromAbstractClass extends AbstractClass { public void abstractMethod() { System.out.println("abstractMethod()"); } } 

In effetti, potresti anche cambiare l’interfaccia e la class astratta in questo modo:

 interface Interface { void abstractMethod(); } abstract public class AbstractClass implements Interface { abstract public void abstractMethod(); } public class InheritsFromInterfaceAndAbstractClass extends AbstractClass implements Interface { public void abstractMethod() { System.out.println("abstractMethod()"); } } 

Tuttavia, ci sono due differenze tra le interfacce e le classi astratte.

La prima differenza è che le interfacce non possono implementare metodi.

 interface Interface { public void implementedMethod() { System.out.println("implementedMethod()"); } } 

L’interfaccia sopra genera un errore del compilatore perché ha un’implementazione per implementedMethod() . Se volevi implementare il metodo ma non essere in grado di creare un’istanza della class, dovresti farlo in questo modo:

 abstract public class AbstractClass { public void implementedMethod() { System.out.println("implementedMethod()"); } } 

Non è una class molto astratta perché nessuno dei suoi membri è astratto, ma è legale Java.

L’altra differenza tra interfacce e classi astratte è che una class può ereditare da più interfacce, ma può ereditare solo da una class astratta.

 abstract public class AbstractClassA { } abstract public class AbstractClassB { } public class InheritsFromTwoAbstractClasses extends AbstractClassA, AbstractClassB { } 

Il codice sopra genera un errore del compilatore, non perché le classi sono tutte vuote, ma perché InheritsFromTwoAbstractClasses prova ad ereditare da due classi astratte, che è illegale. Quanto segue è perfettamente legale.

 interface InterfaceA { } interface InterfaceB { } public class InheritsFromTwoInterfaces implements InterfaceA, InterfaceB { } 

La prima differenza tra interfacce e classi astratte è la ragione della seconda differenza . Dai un’occhiata al seguente codice.

 interface InterfaceA { void method(); } interface InterfaceB { void method(); } public class InheritsFromTwoInterfaces implements InterfaceA, InterfaceB { void method() { System.out.println("method()"); } } 

Non ci sono problemi con il codice sopra perché InterfaceA e InterfaceB non hanno nulla da hide. È facile dire che una chiamata al method stamperà “method ()”.

Ora guarda il seguente codice:

 abstract public class AbstractClassA { void method() { System.out.println("Hello"); } } abstract public class AbstractClassB { void method() { System.out.println("Goodbye"); } } public class InheritsFromTwoAbstractClasses extends AbstractClassA, AbstractClassB { } 

Questo è esattamente lo stesso del nostro altro esempio, eccetto il fatto che siamo autorizzati ad implementare metodi in classi astratte, lo abbiamo fatto, e poiché non dobbiamo implementare metodi già implementati in una class ereditaria, non lo abbiamo fatto. Ma potresti aver notato, c’è un problema. Cosa succede quando chiamiamo il new InheritsFromTwoAbstractClasses().method() ? Stampa “Ciao” o “Arrivederci”? Probabilmente non lo sai, e nemmeno il compilatore Java. Un altro linguaggio, C ++ ha permesso questo tipo di ereditarietà e hanno risolto questi problemi in modi che erano spesso molto complicati. Per evitare questo tipo di problemi, Java ha deciso di rendere questa “eredità multipla” illegale.

Lo svantaggio della soluzione Java che non è ansible fare quanto segue:

 abstract public class AbstractClassA { void hi() { System.out.println("Hello"); } } abstract public class AbstractClassB { void bye() { System.out.println("Goodbye"); } } public class InheritsFromTwoAbstractClasses extends AbstractClassA, AbstractClassB { } 

AbstractClassA e AbstractClassB sono “mixin” o classi che non sono intese per essere istanziate ma aggiungono funzionalità alle classi che sono “miscelate” attraverso l’ereditarietà. Non c’è ovviamente alcun problema nel capire cosa succede se chiami il new InheritsFromTwoAbstractClasses().hi() o il new InheritsFromTwoAbstractClasses().bye() , ma non puoi farlo perché Java non lo consente.

(So ​​che questo è un post lungo, quindi se ci sono errori in esso per favore fatemelo sapere e li correggerò.)

Un’interfaccia in java è un progetto di una class. Ha solo costanti statiche e metodi astratti. L’interfaccia in java è un meccanismo per ottenere un’astrazione completa. Ci possono essere solo metodi astratti nell’interfaccia java non il corpo del metodo. Viene utilizzato per ottenere un’astrazione completa e l’ereditarietà multipla in Java. Un’interfaccia è una raccolta di metodi astratti. Una class implementa un’interfaccia, ereditando in tal modo i metodi astratti dell’interfaccia. Un’interfaccia non è una class. Scrivere un’interfaccia è simile a scrivere una class, ma sono due concetti diversi. Una class descrive gli attributi e i comportamenti di un object. Un’interfaccia contiene comportamenti (metodi astratti) implementati da una class. A meno che la class che implementa l’interfaccia sia astratta, tutti i metodi dell’interfaccia devono essere definiti nella class. Dal momento che l’ereditarietà multipla non è consentita in java, l’interfaccia è l’unico modo per implementare l’ereditarietà multipla. Ecco un esempio per capire l’interfaccia

 interface Printable{ void print(); } interface Showable{ void print(); } class testinterface1 implements Printable,Showable{ public void print(){System.out.println("Hello");} public static void main(String args[]){ testinterface1 obj = new testinterface1(); obj.print(); } } 

L’interfaccia è il progetto di una class.

C’è un concetto di oop chiamato Astrazione dei dati in base al fatto che ci sono due categorie: una è una class astratta e l’altra è un’interfaccia .

La class astratta raggiunge solo un’astrazione parziale, ma l’interfaccia raggiunge la piena astrazione.

Nell’interfaccia ci sono solo metodi astratti e variabili finali … puoi estendere qualsiasi numero di interfaccia e puoi implementare qualsiasi numero di classi.

Se una class implementa l’interfaccia, la class deve implementare anche i metodi astratti

L’interfaccia non può essere istanziata.

 interface A() { void print() } 

Questa domanda ha 6 anni e molte cose hanno cambiato la definizione di interfaccia nel corso degli anni.

Dalla pagina di documentazione di Oracle (versione post Java 8):

Nel linguaggio di programmazione Java, un’interfaccia è un tipo di riferimento, simile a una class, che può contenere solo costanti, firme del metodo, metodi predefiniti, metodi statici e tipi nidificati . I corpi dei metodi esistono solo per metodi predefiniti e metodi statici. Le interfacce non possono essere istanziate, possono solo essere implementate da classi o estese da altre interfacce.

Dai un’occhiata alle domande relative a SE per una spiegazione migliore:

C’è più di un’interfaccia che avere i metodi corretti

Qual è la differenza tra un’interfaccia e una class astratta?

Come una class, un’interfaccia può avere metodi e variabili, ma i metodi dichiarati nell’interfaccia sono per default astratti (solo firma del metodo, nessun corpo).

  • Le interfacce specificano cosa deve fare una class e non come. È il progetto della class.
  • Un’interfaccia riguarda funzionalità come un giocatore può essere un’interfaccia e qualsiasi class che implementa Player deve essere in grado (o deve implementare) move (). Quindi specifica un insieme di metodi che la class deve implementare.

  • Se una class implementa un’interfaccia e non fornisce i corpi del metodo per tutte le funzioni specificate nell’interfaccia, la class deve essere dichiarata astratta.

Le interfacce sono utilizzate per implementare l’astrazione . Quindi sorge la domanda perché utilizzare le interfacce quando abbiamo classi astratte?

Il motivo è che le classi astratte possono contenere variabili non finali, mentre le variabili nell’interfaccia sono finali, pubbliche e statiche .

Nuove funzionalità aggiunte nelle interfacce in JDK 8

  1. Prima di JDK 8, l’interfaccia non poteva definire l’implementazione. Ora possiamo aggiungere l’implementazione predefinita per i metodi di interfaccia. Questa implementazione di default ha un uso speciale e non influenza l’intenzione dietro le interfacce.

    Supponiamo di dover aggiungere una nuova funzione in un’interfaccia esistente. Ovviamente il vecchio codice non funzionerà in quanto le classi non hanno implementato quelle nuove funzioni. Quindi, con l’aiuto dell’implementazione predefinita, daremo un corpo predefinito per le funzioni appena aggiunte. Quindi i vecchi codici continueranno a funzionare.

  2. In JDK 8, ora possiamo definire metodi statici in interfacce che possono essere chiamate indipendentemente senza un object. Nota: questi metodi non sono ereditati.

Cos’è
Un’interfaccia è un tipo di riferimento, proprio come una class . Questi sono i due principali tipi di riferimento in Java.

Cosa contiene
Un’interfaccia può contenere un sottoinsieme di ciò che una class normale può contenere. Questo include tutto ciò che è static , sia i metodi e le variabili, sia static dichiarazioni di metodi non static . Non è consentito avere variabili non static .
Una dichiarazione di un metodo differisce da un metodo normale in diverse cose; eccone uno come esempio:

 [public] [abstract] ReturnType methodName(); 

Queste dichiarazioni possono essere contrassegnate come public e abstract , come rappresentato con [optional braces] . Non è necessario farlo, poiché è l’impostazione predefinita. private , protected , package-private (aka. nothing) e il modificatore final non sono consentiti e contrassegnati come errori del compilatore. Non hanno implementazione, quindi c’è un punto e virgola al posto delle parentesi graffe.

A partire da Java 8, possono contenere metodi non static con un’implementazione, che devono essere contrassegnati con il modificatore default . Tuttavia, si applicano le stesse restrizioni degli altri modificatori (aggiungendo che strictfp è ora valido e l’ abstract non esiste più).

Per cosa è utile
Uno dei suoi usi è che sia usato come faccia per un servizio. Quando due parti lavorano insieme per formare un tipo di rapporto tra richiedente e fornitore di servizi, il fornitore di servizi fornisce il volto del servizio (per quanto riguarda l’aspetto del servizio) sotto forma di interfaccia.
Uno dei concetti OOP è “Abstraction” che significa hide il funzionamento complesso dei sistemi e mostrare solo ciò che è necessario per capire il sistema. Questo aiuta a visualizzare il funzionamento di un sistema complesso. Questo può essere ottenuto attraverso l’ interfaccia in cui ciascun modulo è visualizzato (e anche implementato) per funzionare attraverso l’interfaccia di un altro modulo

Un’interfaccia è un costrutto simile a una class che contiene solo costanti e metodi astratti (Introduzione alla programmazione java, nd). Inoltre, può estendere più di un’interfaccia, ad esempio una Superclass. Java consente solo l’ereditarietà singola per l’estensione di class, ma consente più estensioni per le interfacce (Introduzione alla programmazione Java, nd) Ad esempio,

 public class NewClass extends BaseClass implements Interface1, ..., InterfaceN { ... } 

In secondo luogo, le interfacce possono essere utilizzate per specificare il comportamento degli oggetti in una class. Tuttavia, non possono contenere metodi astratti. Inoltre, un’interfaccia può ereditare altre interfacce usando la parola chiave extends.

 public interface NewInterface extends Interface1, ... , InterfaceN { } 

Riferimento

Introduzione alla programmazione Java. Interfacce e classi astratte (nd). Recuperato il 10 marzo 2017 da https://viewer.gcu.edu/7NNUKW

In generale, preferiamo le interfacce quando ci sono due più implementazioni che abbiamo. Dove Interface funge da protocollo.

Codifica per interfacciare, non implementazioni La codifica per interfaccia fa coppia liberamente.

Un’interfaccia è un tipo di riferimento in Java . È simile alla class. È una raccolta di metodi astratti. Una class implementa un’interfaccia, ereditando in tal modo i metodi astratti dell’interfaccia. Insieme ai metodi astratti, un’interfaccia può contenere anche costanti, metodi predefiniti, metodi statici e tipi annidati. per maggiori dettagli

Interface è un contratto. Un semplice esempio è un inquilino e proprietario che sono le due parti e il contratto è il contratto di locazione . L’accordo di affitto contiene varie clausole che gli inquilini devono seguire. Allo stesso modo Interface è un contatto che contiene vari metodi (Dichiarazione) che la Parte deve implementare (fornire i corpi dei metodi). La prima parte è la class che implementa l’interfaccia e la seconda parte è Client e il modo di usare e l’interfaccia è “Riferimento di Interface “e” Object of Implementing class “: di seguito sono 3 componenti: (spiegato con l’aiuto di esempio)

Componente 1] Interfaccia: il contratto

 interface myInterface{ public void myMethod(); } 

Componente 2] Classe di implementazione: numero di partito 1

  class myClass implements myInterface { @Override public void myMethod() { System.out.println("in MyMethod"); } } 

Componente 3] Codice cliente: numero di partito 2

  Client.java public class Client { public static void main(String[] args) { myInterface mi = new myClass(); // Reference of Interface = Object of Implementing Class mi.myMethod(); // this will print in MyMethod } }