Menu

Tutorial sull'interfaccia Java e sulla classe astratta con esempi

  • Principale
  • Altro
  • Tutorial sull'interfaccia Java e sulla classe astratta con esempi

java interface abstract class tutorial with examples

Prova Il Nostro Strumento Per Eliminare I Problemi

Questo video tutorial spiega cos'è l'interfaccia Java, come implementarla e l'ereditarietà multipla utilizzando le interfacce in Java con esempi:

In uno dei nostri tutorial precedenti, abbiamo discusso in dettaglio l'astrazione. Lì abbiamo discusso di classi astratte e metodi astratti. Sappiamo che le classi astratte forniscono l'astrazione poiché possiamo anche avere qualche metodo non astratto nella classe astratta.

La funzione che fornisce l'astrazione al 100% in Java si chiama ' Interfaccia '. In questo tutorial, discuteremo interfacce in Java.

=> Dai un'occhiata alla guida per principianti di Java qui.

Interfacce Java e classi astratte

Cosa imparerai:

Video tutorial su interfacce e classi astratte

Introduzione alle interfacce e alle classi astratte in Java - Parte 1:

Panoramica delle interfacce e delle classi astratte in Java - Parte 2:

Astrazione ed ereditarietà in Java:

Che cos'è un'interfaccia in Java

Un'interfaccia in Java è definita come un tipo astratto che specifica il comportamento della classe. Un'interfaccia è una sorta di protocollo che imposta regole su come dovrebbe comportarsi una particolare classe.

Un'interfaccia in Java può contenere metodi astratti e costanti statiche. Per impostazione predefinita, tutti i metodi nell'interfaccia sono pubblici e astratti.

Di seguito viene fornito un semplice esempio di interfaccia in Java.

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

L'esempio precedente definisce un'interfaccia 'forma' che ha una variabile statica e un metodo astratto 'calcolaArea ()'.

Un'interfaccia è un'entità che ha solo metodi astratti come corpo. Può anche contenere variabili finali statiche.

Quindi, proprio come una classe, un'interfaccia può anche avere metodi e variabili, ma nota che i metodi sono astratti (senza implementazione) e le variabili sono statiche.

Di seguito sono elencate alcune proprietà che dovrebbero essere tenute a mente relative alle interfacce:

  • Le interfacce sono modelli per una classe. Dicono alla classe cosa fare attraverso i loro metodi.
  • Un'interfaccia specifica metodi astratti e classi che implementano quell'interfaccia dovrebbero implementare anche quei metodi.
  • Se una classe che implementa l'interfaccia non definisce tutti i metodi dell'interfaccia, quella classe diventa una classe astratta.

Di seguito viene fornita la sintassi generale della dichiarazione dell'interfaccia.

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

Come mostrato nella dichiarazione sopra, usiamo una parola chiave Java 'interfaccia' che indica che stiamo dichiarando un'interfaccia ora.

come aggiungere elementi di array in java

Una parola chiave 'interfaccia' è seguita da nome_interfaccia e quindi dalle parentesi graffe di apertura. Quindi abbiamo varie dichiarazioni di metodi astratti, dichiarazioni di campi statici, ecc. Infine, chiudiamo le parentesi graffe.

Per esempio,se vogliamo dichiarare un'interfaccia 'TestInterface' con due metodi, cioè method_one e method_two, la dichiarazione di TestInterface sarà la seguente:

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

Usi dell'interfaccia in Java

  • Le interfacce in Java forniscono un'astrazione al 100% in quanto possono avere solo metodi astratti.
  • Utilizzando le interfacce, possiamo ottenere più eredità in Java che non è possibile utilizzando le classi.
  • Per ottenere un accoppiamento libero, è possibile utilizzare un'interfaccia.

Come implementare un'interfaccia in Java

Una volta dichiarata l'interfaccia, possiamo usarla in una classe utilizzando la parola chiave 'implements' nella dichiarazione di classe.

Questa parola chiave 'implementa' viene visualizzata dopo il nome della classe come mostrato di seguito:

class implements { //class body }

L'implementazione di un'interfaccia equivale alla firma di un contratto. Quindi una classe che implementa un'interfaccia significa che ha firmato un contratto e ha accettato di implementare i metodi astratti dell'interfaccia o in altre parole di eseguire il comportamento specificato dall'interfaccia.

Se la classe che implementa l'interfaccia non implementa il comportamento esatto specificato nell'interfaccia, la classe deve essere dichiarata astratta.

Esempio di implementazione dell'interfaccia

Di seguito è riportato un semplice esempio di un'interfaccia in 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 } }

Produzione:

Esempio di output dell

Il programma sopra mostra il semplice esempio di interfacce in Java. Qui, dichiariamo un'interfaccia denominata Polygon_Shape e quindi la classe Rectangle la implementa.

Convenzione di denominazione dell'interfaccia in Java

Le convenzioni di denominazione Java sono le linee guida di denominazione che dobbiamo seguire come programmatori in modo da poter produrre codice coerente leggibile. Java utilizza le notazioni 'TitleCase' per le classi di denominazione e le interfacce. Utilizza le notazioni 'CamelCase' per variabili, metodi, ecc.

Per quanto riguarda l'interfaccia, il nome dell'interfaccia è nel titolo con la prima lettera di ogni parola del nome dell'interfaccia in maiuscolo. I nomi delle interfacce sono selezionati in modo tale che di solito siano aggettivi. Ma quando le interfacce rappresentano la famiglia di classi come map o list, possono essere denominate in base a nomi.

Di seguito vengono forniti alcuni esempi di nomi di interfaccia validi:

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

Costruttore di interfaccia

La domanda successiva è se un'interfaccia ha un costruttore?

Sappiamo che abbiamo bisogno di oggetti per invocare metodi. Per creare oggetti abbiamo bisogno di costruttori. Ma nel caso delle interfacce in Java, i metodi non sono implementati.

I metodi delle interfacce sono tutti astratti. Quindi non serve chiamare questi metodi dall'interfaccia. In secondo luogo, poiché le interfacce sono astratte per impostazione predefinita, non possiamo creare oggetti dell'interfaccia. Quindi non abbiamo bisogno di costruttori per Interface.

Metodi di interfaccia

In questa sezione, discuteremo come dichiarare i metodi di interfaccia. Per regola, un'interfaccia può avere solo metodi pubblici o, per impostazione predefinita, i metodi dell'interfaccia sono pubblici. Nessun altro modificatore di accesso può essere utilizzato all'interno dell'interfaccia.

Quindi, che lo dichiariamo esplicitamente o meno, ogni metodo nell'interfaccia è per impostazione predefinita astratto con visibilità pubblica.

Quindi se void printMethod () è il prototipo che intendiamo dichiarare in un'interfaccia, le seguenti dichiarazioni sono le stesse.

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

Nota che non possiamo usare i seguenti modificatori all'interno dell'interfaccia per i metodi di interfaccia.

  • finale
  • statico
  • Privato
  • protetto
  • sincronizzato
  • nativo
  • strictfp

Ora implementiamo un programma Java per dimostrare la visibilità del metodo di interfaccia.

//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 } }

Produzione:

TestClass printMethod

Come già accennato, per impostazione predefinita, i metodi di interfaccia sono pubblici. Quindi, quando non specifichiamo alcun modificatore di accesso per il metodo di interfaccia, allora è pubblico come nel programma sopra.

Supponiamo di modificare la dichiarazione del metodo di interfaccia nel programma sopra come segue:

private void printMethod ();

Quindi questo significa che abbiamo specificato il metodo di interfaccia printMethod () come privato. Quando compiliamo il programma, otteniamo il seguente errore del compilatore.

errore: modificatore privato non consentito qui

private void printMethod ();

Il secondo caso che possiamo testare è cambiare il modificatore del metodo implementato nella classe TestClass da public a private. Ora il modificatore predefinito nella classe è privato. Quindi rimuoviamo semplicemente la parola chiave public dal prototipo del metodo nella classe come segue:

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

Ora, se compiliamo il programma, otteniamo il seguente errore.

errore: printMethod () in TestClass non può implementare printMethod () in TestInterface
void printMethod ()
^
tentare di assegnare privilegi di accesso più deboli; era pubblico

Quindi il punto da notare qui è che non possiamo cambiare il modificatore di accesso del metodo implementato dell'interfaccia con nessun altro modificatore di accesso. Poiché i metodi di interfaccia sono pubblici per impostazione predefinita, quando vengono implementati da classi che implementano interfacce, anche questi metodi dovrebbero essere pubblici.

Campi dell'interfaccia in Java

I campi o le variabili dichiarati in un'interfaccia sono per impostazione predefinita public, static e final. Ciò significa che una volta dichiarato il loro valore non può essere modificato.

Notare che se i campi dell'interfaccia vengono definiti senza specificare nessuno di questi modificatori, i compilatori Java assumono questi modificatori. Per esempio, se non specifichiamo un modificatore pubblico quando dichiariamo il campo nell'interfaccia, allora viene assunto per impostazione predefinita.

Quando un'interfaccia viene implementata da una classe, fornisce un'implementazione per tutti i metodi astratti dell'interfaccia. Allo stesso modo, anche tutti i campi dichiarati nell'interfaccia vengono ereditati dalla classe che implementa l'interfaccia. Quindi una copia del campo interfaccia è presente nella classe di implementazione.

Ora tutti i campi dell'interfaccia sono per impostazione predefinita statici. Quindi possiamo accedervi usando direttamente il nome dell'interfaccia così come accediamo ai campi statici della classe usando il nome della classe e non l'oggetto.

Il programma Java di esempio riportato di seguito mostra come è possibile accedere ai campi dell'interfaccia.

//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); } }

Produzione:

Esempio di campo dell

Come mostrato nel programma sopra, è possibile accedere ai campi dell'interfaccia utilizzando un nome dell'interfaccia seguito da un operatore punto (.) E quindi la variabile o il nome del campo effettivo.

L'interfaccia generica in Java

Abbiamo discusso i generici di Java nei nostri tutorial precedenti. Oltre ad avere classi, metodi, ecc. Generici, possiamo anche avere interfacce generiche. Le interfacce generiche possono essere specificate in modo simile nel modo in cui specifichiamo classi generiche.

Le interfacce generiche sono dichiarate con parametri di tipo che le rendono indipendenti da un tipo di dati.

La sintassi generale dell'interfaccia generica è la seguente:

come rimuovere l'elemento dell'array in java
interface { //interface methods and variables }

Ora, se vogliamo usare l'interfaccia generica sopra in una classe, allora possiamo avere la definizione della classe come mostrato di seguito:

class implements interface_name { //class body }

Nota che dobbiamo specificare lo stesso param-list con la classe come con l'interfaccia.

Il seguente programma Java dimostra le interfacce generiche in 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()); }

Produzione:

Output di esempio dell

Il programma precedente implementa un'interfaccia contenente un metodo per trovare il valore minimo nell'array. Questa è un'interfaccia generica. La classe implementa questa interfaccia e sovrascrive il metodo. Nel metodo principale, chiamiamo il metodo dell'interfaccia per trovare il valore minimo in un numero intero e un array di caratteri.

Interfacce multiple in Java

Nel nostro argomento sull'ereditarietà, abbiamo visto che Java non consente a una classe di ereditare da più classi poiché si traduce in un'ambiguità chiamata 'problema del diamante'.

Tuttavia, una classe può ereditare o implementare più di un'interfaccia. In questo caso, è noto come ereditarietà multipla. Quindi, sebbene non ci sia consentito implementare l'ereditarietà multipla in Java tramite le classi, possiamo farlo utilizzando le interfacce.

Il diagramma seguente mostra l'ereditarietà multipla utilizzando le interfacce. Qui una classe implementa due interfacce, ovvero Interface_one e Interface_two.

Interfacce multiple in Java

Si noti che quando una classe implementa più interfacce, i nomi delle interfacce sono separati da virgole nella dichiarazione della classe. Possiamo implementare quante più interfacce possiamo gestire la complessità.

Di seguito è mostrato il programma Java che dimostra più interfacce.

//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(); } }

Produzione:

esempio di interfacce multiple

domande e risposte dell'intervista al server sql per 5 anni di esperienza

Come mostrato sopra, implementiamo due interfacce. Quindi sovrascriviamo i rispettivi metodi e li chiamiamo nel metodo principale.

L'ereditarietà multipla in Java offre tutti i vantaggi offerti dall'ereditarietà multipla in C ++. Ma a differenza dell'ereditarietà multipla che utilizza le classi, l'ereditarietà multipla che utilizza le interfacce è priva di ambiguità.

Ereditarietà dell'interfaccia in Java: l'interfaccia estende l'interfaccia

Quando una classe implementa un'interfaccia, viene eseguita utilizzando il ' attrezzi ' parola chiave. In Java, un'interfaccia può ereditare un'altra interfaccia. Questo viene fatto utilizzando il ' si estende ' parola chiave. Quando un'interfaccia estende un'altra interfaccia viene chiamata ' Eredità dell'interfaccia 'In Java.

l

Di seguito è mostrato il programma Java per implementare l'ereditarietà dell'interfaccia.

//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(); } }

Produzione:

output di esempio della classe demo

Abbiamo modificato lo stesso programma che abbiamo usato per l'ereditarietà multipla utilizzando interfacce per dimostrare l'ereditarietà dell'interfaccia. Qui, estendiamo Interface_one in Interface_two e poi implementiamo Interface_two in una classe. Poiché le interfacce vengono ereditate, entrambi i metodi sono disponibili per l'override.

Domande frequenti

D # 1) Qual è l'uso dell'interfaccia in Java?

Risposta: Un'interfaccia in Java è un'entità utilizzata per ottenere l'astrazione al 100%. Può contenere solo metodi astratti che possono essere sovrascritti dalla classe che implementa l'interfaccia.

L'interfaccia in un certo senso si comporta come un modello della classe in cui fornisce alla classe i prototipi del metodo astratto e le costanti statiche e quindi la classe deve sovrascrivere quei metodi implementando l'interfaccia.

D # 2) Quali sono i vantaggi dell'interfaccia in Java?

Risposta: Alcuni dei vantaggi di Interface sono i seguenti:

  1. L'interfaccia funge da modello della classe.
  2. L'interfaccia fornisce un'astrazione al 100% in Java poiché ha tutti i metodi astratti.
  3. Le interfacce possono essere utilizzate per ottenere più eredità in Java. Java non consente di ereditare da più di una classe ma una classe può implementare più interfacce.

# 3) Un'interfaccia può avere metodi?

Risposta: Le interfacce possono avere prototipi di metodi e costanti statiche e finali. Ma a partire da Java 8, le interfacce possono contenere metodi statici e predefiniti.

Q # 4) Possiamo dichiarare l'interfaccia come finale?

Risposta: No. Se dichiariamo un'interfaccia come finale, la classe non sarà in grado di implementarla. Senza essere implementata da nessuna classe, l'interfaccia non servirà a nessuno scopo.

Ulteriori informazioni sulle interfacce

Le interfacce sono progetti come class, ma avranno solo la dichiarazione del metodo. Non avrà alcun metodo di implementazione. Tutti i metodi nell'interfaccia sono astratti pubblici per impostazione predefinita. L'interfaccia Java 1.8 può avere metodi statici e predefiniti.

Le interfacce vengono utilizzate principalmente nelle API.

Per esempio: Considera che stai progettando il motore di un veicolo.

Quando hai finito con la parte hardware, vuoi che alcune delle funzionalità del software siano implementate da un cliente che sta usando il tuo motore. Quindi, in quel caso, puoi definire le funzionalità del tuo motore in un'interfaccia.

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

Regole da seguire per Interface

  • La classe che sta implementando l'interfaccia dovrebbe implementare tutti i metodi nell'interfaccia.
  • Un'interfaccia può contenere variabili finali.
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); } }

Regole da seguire per l

Qui la classe Vehicle è la sottoclasse che implementa l'interfaccia del motore.

Cosa sono le classi astratte?

Una classe astratta è come una classe ma avrà metodi astratti e metodi concreti. I metodi astratti non hanno un'implementazione. Avrà solo la dichiarazione del metodo.

Regole da seguire per la classe astratta

  • La classe astratta non può essere istanziata.
  • La classe figlia che estende la classe astratta dovrebbe implementare tutti i metodi astratti della classe genitore o la classe Child dovrebbe essere dichiarata come classe astratta.

Quando vuoi progettare un'implementazione parziale, puoi optare per una classe astratta.

Esempio di programma di classe astratto:

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

La classe che estenderà la classe astratta.

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

Punti chiave da notare:

  • In Interfaces, tutti i metodi non avranno l'implementazione del metodo.
  • La classe che sta implementando l'interfaccia dovrebbe implementare tutti i metodi in quella particolare interfaccia.
  • Le classi astratte possono avere metodi astratti così come normali metodi concreti. I metodi astratti non hanno un'implementazione.
  • La classe che sta estendendo la classe astratta dovrebbe avere l'implementazione per tutti i metodi astratti nella classe astratta.
  • Se la sottoclasse non dispone di informazioni sufficienti per implementare i metodi astratti, la sottoclasse dovrebbe essere dichiarata come una classe astratta.

Conclusione

In questo tutorial, abbiamo presentato i concetti di base delle interfacce in Java. Abbiamo discusso la definizione dell'interfaccia, insieme alla necessità di interfacce. Abbiamo esplorato la loro sintassi e definizione di base. Quindi abbiamo discusso di come utilizzare le interfacce per le quali utilizziamo la parola chiave 'implements'.

Abbiamo imparato come utilizzare più interfacce e l'ereditarietà dell'interfaccia in Java. Utilizzando più interfacce possiamo implementare più eredità in Java. L'ereditarietà dell'interfaccia si ha quando un'interfaccia estende un'altra interfaccia.

=> Visita qui per vedere la serie di formazione Java per tutti

Lettura consigliata

^