Cos'è l'interfaccia in Java e come implementarla?

' Interfaccia è un livello avanzato per ottenere l'astrazione nel linguaggio di programmazione Java. L'interfaccia Java aiuta in riduzione della complessità nel codice e semplifica il leggibilità . In questo articolo, ti spiegherò l'interfaccia Java attraverso il seguente docket.

• Cos'è un'interfaccia Java?
• Perché abbiamo bisogno di un'interfaccia?
• Dichiarazione di un'interfaccia Java: sintassi
• Esempio di interfaccia Java
• Annidamento dell'interfaccia Java
• Differenza tra classe e interfaccia
• Vantaggi e svantaggi dell'interfaccia
• Punti chiave sull'interfaccia Java

Cos'è un'interfaccia Java?

Interfaccia del computer è noto come confine che separa due o più sistemi. Scambia i dati tra i componenti in un sistema che potrebbe segnali, comandi o protocolli.

Java Abstraction fornisce la funzionalità di un particolare metodo nascondendo la logica di implementazione scritta all'interno del metodo. Allo stesso modo, Java Interface è anche una classe astratta che include la dichiarazione del metodo ma non la sua definizione. Una classe attrezzi un'interfaccia per ereditare i metodi astratti. Insieme ai metodi astratti, un file interfaccia può anche includere costanti, metodi statici, interfacce annidate e metodi predefiniti.

Somiglianze tra una classe e un'interfaccia.

Un'interfaccia è completamente simile a una normale classe in Java. Un'interfaccia include i metodi astratti e questi metodi sono progettati per essere implementati. Questo processo è semplicemente uguale all'ereditarietà, che è normale quando si tratta di classi. Discuteremo di più sulle somiglianze.

• Come una classe, un'interfaccia può anche contenere il numero di metodi richiesto.
• Simile alle classi, l'interfaccia è anche scritta con un file .Giava file di estensione.
• Sorprendentemente, il bytecode per un'interfaccia sarà apparso in un file .classe file.
• Un'interfaccia viene mostrata sotto forma di pacchetto e il rispettivo bytecode si trova in una directory che corrisponde al nome del pacchetto.

Perché abbiamo bisogno di un'interfaccia?

Java non supporta Eredità multiple, per questo motivo, non consentirà alle classi di estendere più di una classe in un'istanza. Classi per bambini non poteva ereditare le proprietà di più classi genitore in una singola istanza, come risulta Problema del diamante. Per superare questo problema, Interfaccia è introdotto. Cerchiamo di capire questo problema attraverso un esempio.

Supponiamo di avere due piani, uno solo può trasportare passeggeri, l'altro solo posizione. Ora, dobbiamo ereditare le proprietà sia dell'aereo cargo che dell'aereo passeggeri. Java non supporterebbe questa soluzione in quanto finisce in ambiguità tra i due piani.

strumenti utilizzati nell'analisi dei big data

Ma se riesci a renderlo possibile facendo sentire Java che eredita un piano e implementazione i metodi presenti nell'altro piano. È come un aereo commerciale che trasporta sia i passeggeri che i bagagli. L'interfaccia è come creare un aereo più grande che potrebbe svolgere entrambi i compiti senza interferire con i componenti l'uno dell'altro, ma semplicemente prendendo in prestito i metodi dal Classe di interfaccia.

// Codice di classe A.

pacchetto multiplo di classe A {void msg () {System.out.println ('Hello')}}

// Codice di classe B.

pacchetto multiplo di classe B {void msg () {System.out.println ('Welcome')}}

Codice di classe C.

pacchetto multiplo di classe C estende A, B {// Questo non sarà accettato da Java, genererà un errore e il codice non verrà eseguito. public static void main (String args []) {C obj = new C () obj.msg ()}}

Produzione:

Errore. Questo particolare approccio genera un'eccezione. Java non supporta le eredità multiple. Questo errore è noto come Problema del diamante 

Proviamo una soluzione utilizzando un'interfaccia, Classi per bambini può accedere ai metodi da Genitore multiplo classi in una singola istanza.

// Codice interfaccia

pacchetto MIS soluzione di interfaccia pubblica {public void Hello () public void Welcome ()}

// Codice classe

pacchetto MIS public class classA implementa la soluzione {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 ()}}

Produzione:

Ciao mondo

Benvenuto in Edureka

Dichiarazione di un'interfaccia Java: sintassi

interfaccia nome_interfaccia {// dichiara campi costanti // declare metodi () // metodi predefiniti}

Facciamo un esempio su Java Interface

Esempio di interfaccia Java

Creiamo una semplice calcolatrice basata sull'interfaccia Java.

// Codice interfaccia

pacchetto basicoperations public interface maths {public void add () public void sub () public void mul () public void div ()}

// Codice classe

pacchetto basicoperations import java.util.Scanner public class student1 implementa la matematica {@Override public void add () {Scanner kb = new Scanner (System.in) System.out.println ('Inserisci due valori interi per eseguire l'addizione') int a = kb.nextInt () int b = kb.nextInt () int s = a + b System.out.println ('Sum of' + a + 'e' + b + 'è' + s)} @Override public void sub () {Scanner kb = new Scanner (System.in) System.out.println ('Immettere due valori interi per eseguire la sottrazione') int a = kb.nextInt () int b = kb.nextInt () int s = ab System.out.println ('Difference of' + a + 'and' + b + 'is' + s)} @Override public void mul () {Scanner kb = new Scanner (System.in) System.out.println ('Enter qualsiasi moltiplicazione di due valori interi ') int a = kb.nextInt () int b = kb.nextInt () int s = a * b System.out.println (' Prodotto di '+ a +' e '+ b +' è '+ s)} @Override public void div () {Scanner kb = new Scanner (System.in) System.out.println ('Immettere una divisione di due valori interi qualsiasi') int a = kb.nextInt () int b = kb.nextInt () int s = a / b System.out.p rintln ('Quotient of' + a + 'and' + b + 'is' + s)} public static void main (String [] args) {student1 Edureka1 = new student1 () Edureka1.add () Edureka1.sub () Edureka1. mul () Edureka1.div ()}}

Produzione:

Avanzando ulteriormente, impareremo a nidificare un'interfaccia Java.

Annidamento dell'interfaccia Java

Nidificazione dell'interfaccia è un processo di dichiarazione di un'interfaccia all'interno di un'altra Interfaccia esistente o dichiarare un'interfaccia all'interno di un file Classe. L'interfaccia annidata è anche nota come Interfaccia interna.

Non è possibile accedere all'interfaccia nidificata direttamente . Quindi, l'annidamento viene implementato per risolvere gli spazi dei nomi raggruppandoli con i relativi Interfacce e Classi. Con questa procedura,possiamo chiamare il Interfaccia annidata tramite la Classe esterna o Interfaccia esterna nome seguito da a punto (.) , e Nome dell'interfaccia.

Proviamo alcuni esempi basati su Nidificazione dell'interfaccia. Per prima cosa, proviamo a nidificare un file Interfaccia Java dentro un altro Interfaccia Java come mostrato di seguito:

// Codice interfaccia

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

// Codice classe

pacchetto Nest class NestedInterfaceDemo implementa OuterInterface.InnerInterface {public void InnerMethod () {int n = 10, t1 = 0, t2 = 1 System.out.print ('First' + n + 'terms:') for (int i = 1 i & lt = n ++ i) {System.out.print (t1 + '+') int sum = t1 + t2 t1 = t2 t2 = sum} System.out.println ('nPrinting dal metodo InnerInterface annidato ...! n ')} public static void main (String args []) {OuterInterface.InnerInterface obj = new NestedInterfaceDemo () obj.InnerMethod ()}}

Produzione:

Primi 10 termini: 0 + 1 + 1 + 2 + 3 + 5 + 8 + 13 + 21 + 34 + Stampa dal metodo InnerInterface annidato ...!

Ora, proviamo a nidificare un file Interfaccia Java all'interno di un Classe Java.

// Codice interfaccia

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

// Codice classe

pacchetto Nest2 classe NestedInterfaceDemo2 implementa EdurekaClass.EdurekaInterface {public void NestedMethod () {String input = 'Edureka' byte [] strAsByteArray = input.getBytes () byte [] risultato = nuovo byte [strAsByteArray.length] per (int i = 0 iByArray .length i ++) risultato [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 ()}}

Produzione:

akerudE

Sebbene un'interfaccia sia quasi simile a una classe, ci sono alcune differenze tra di loro, discutiamo delle loro differenze.

Differenza tra Java Class e Java Interface

Vantaggi e svantaggi dell'interfaccia Java

Vantaggi:

• Supporta l'interfaccia Java Ereditarietà multipla.
• Java Interface consente ai programmatori di spezzare i complessi approcci di programmazione e semplificare il dipendenze tra gli oggetti.
• Java Interface rende il file membri dei dati e metodi in un'applicazione da accoppiare in modo lasco.

Svantaggi:

• L'uso dell'interfaccia Java riduce il file velocità di esecuzione dell'applicazione.
• Le interfacce Java nell'applicazione vengono utilizzate ripetutamente in larga misura o quasi del tutto.

Punti chiave sull'interfaccia Java

• Nessuno dei metodi dichiarati nell'interfaccia ha un corpo che gli permetta di fornire un'astrazione completa.
• Non è possibile creare un oggetto di un'interfaccia. Quindi, l'istanza di un'interfaccia non è possibile.
• Una classe può implementare un'interfaccia utilizzando la parola chiave implements. Vediamolo attraverso un esempio.

// Codice interfaccia

pacchetto extInterface interfaccia pubblica extInterface {public void method1 () public void method2 ()}

// Codice classe

funzione fibonacci c ++

pacchetto extInterface import java.util.Scanner classe Edureka implementa extInterface {public void method1 () {System.out.println ('implementation of method1') Scanner scanner = new Scanner (System.in) System.out.println ('Enter number per trovare la radice quadrata in Java: ') double square = scanner.nextDouble () double squareRoot = Math.sqrt (square) System.out.printf (' Square root of number:% f is:% f% n ', square, squareRoot)} public void method2 () {System.out.println ('implementation of method2')} public static void main (String arg []) {extInterface obj = new Edureka () obj.method1 ()}}

Produzione:

implementazione del metodo 1 Immettere il numero per trovare la radice quadrata in Java: 16 Radice quadrata del numero: 16.0 è: 4.0

• Una classe può implementare più eredità in una singola istanza. Cerchiamo di capirlo attraverso il seguente codice.

// Codice interfaccia 1

pacchetto ExtendInt interfaccia pubblica Interface1 {public void armstrong ()}

// Codice interfaccia 2

package ExtendInt public interface 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 while (n & gt0) {a = n% 10 n = n / 10 c = c + (a * a * a)} if (temp == c) System.out.println ('armstrong number') else System.out.println ('Not armstrong number') System.out.println ('Extending to Interface 1')} public void prime () {int i, m = 0, flag = 0 int n = 3 // input m = n / 2 if (n == 0 || n == 1) {System.out.println (n + 'is not prime number')} else {for (i = 2i & lt = mi ++) {if (n% i == 0) {System .out.println (n + 'non è un numero primo') flag = 1 interruzione}} if (flag == 0) {System.out.println (n + 'è un numero primo')}} System.out.println ('Estensione to Interface 2 ')} public static void main (String args []) {Interface2 obj = new Edureka2 () obj.prime () Interface1 obj1 = new Edureka2 () obj1.armstrong ()}}

Produzione:

3 è il numero primo che si estende all'interfaccia 2 numero armstrong che si estende all'interfaccia 1

• L'interfaccia Java richiede che le variabili dichiarate siano inizializzate al momento della dichiarazione.
• I modificatori di accesso per un'interfaccia sono impostati su public static e final per impostazione predefinita. Cerchiamo di capire questo con un esempio

// Codice interfaccia

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

• Tutte le dichiarazioni precedenti sono vere e valide all'interno di un'interfaccia.
• Java Interface è in grado di estendere un numero qualsiasi di interfacce, ma non può mai implementarne una.
• Una classe Java può implementare un numero qualsiasi di interfacce.
• La classe Java non può implementare interfacce con lo stesso nome di metodo e tipo di restituzione diverso.
• Se sono presenti due o più metodi con lo stesso nome di metodo, esistono in più interfacce, è sufficiente implementare il metodo una volta sola. Cerchiamo di capirlo con un esempio pratico.

// Codice interfaccia

pacchetto stessa interfaccia pubblica A {public void display ()} // Pacchetto codice interfaccia stessa interfaccia pubblica B {public void display ()} // Pacchetto codice classe stessa classe stessi implementa A, B {public void display () {System.out .println ('visualizzazione dei dati')} public static void main (String [] args) {same print = new same () print.display ()}}

Produzione:

Benvenuto in Edureka E-Learning

Con questo, arriviamo alla fine di questo articolo. Spero che tu abbia compreso l'importanza di Interfaccia, Sintassi, funzionalità, Nidificazione dell'interfaccia, Punti chiave dell'interfaccia Java e operazioni eseguite utilizzando gli stessi.

Ora che hai compreso le basi di Java, controlla il file da Edureka, una società di formazione online affidabile con una rete di oltre 250.000 studenti soddisfatti sparsi in tutto il mondo. Il corso di formazione e certificazione Java J2EE e SOA di Edureka è progettato per studenti e professionisti che desiderano diventare sviluppatori Java. Il corso è progettato per darti un vantaggio nella programmazione Java e formarti per concetti Java sia di base che avanzati insieme a vari framework Java come Hibernate & Primavera .

Hai domande per noi? Menzionalo nella sezione commenti di questo blog 'Java Interface' e ti risponderemo il prima possibile.