Classi astratte e metodi astratti Java

In questo tutorial, impareremo l'astrazione in Java. Impareremo le classi astratte e i metodi in Java, nonché come usarli nei nostri programmi.

Classe astratta Java

Le classi astratte sono classi non istanziabili (non possiamo creare oggetti di classi astratte). In Java, usiamo la parola chiave abstract per dichiarare una classe astratta.

abstract class Animal {
　　　//Proprietà e metodi
}

Se si tenta di creare un'istanza di una classe astratta, si otterrà un errore di compilazione. Ad esempio:

Animal a1 = new Animal()

Questo genererà un errore di compilazione:

　L'animale è astratto; non può essere istanziato

Nonostante non possiamo istanziare la classe astratta, possiamo crearne sottoclassi. Possiamo creare oggetti di sottoclasse per accedere ai membri della classe astratta.

Prima di conoscerlo meglio, dobbiamo capire il metodo astratto.

Metodo astratto Java

Usiamo la stessa parola chiave abstract per creare un metodo astratto. Dichiariamo un metodo astratto senza implementarlo. Ad esempio,

abstract void makeSound();

Qui, makeSound() è un metodo astratto.

Le classi astratte possono contenere metodi astratti e non astratti. Questo è un esempio.

abstract class Animal {
　　　public void displayInfo() {
　　　　　　System.out.println("Sono un animale.");
　　　}
　　　abstract void makeSound();
}

Nell'esempio sopra, abbiamo creato una classe astratta Animal. Questa classe contiene un metodo astratto makeSound() e un metodo non astratto displayInfo().

Ereditarietà di classe astratta

Le classi astratte non possono essere istanziate. Per accedere ai membri di una classe astratta, dobbiamo ereditare essa.

Esempio 1: Ereditarietà di classe astratta

abstract class Animal {
　public void displayInfo() {
　　　System.out.println("Sono un animale.");
　}
}
class Dog extends Animal {
}
class Main {
　public static void main(String[] args) {
　　　Dog d1 = new Dog();
　　　d1.displayInfo();
　}
}

Output:

Sono un animale.

Nell'esempio sopra, abbiamo creato una classe astratta Animal. Non possiamo creare un oggetto della classe Animal. Per accedere al metodo displayInfo() della classe Animal, abbiamo ereditato la sottoclasse Dog di Animal.

Poi, utilizziamo l'oggetto d1 di Dog per accedere al metodo displayInfo().

Sovrascrittura di un metodo astratto

In Java, è necessario sovrascrivere i metodi astratti della superclasse nella sottoclasse. Questo è perché la sottoclasse eredita i metodi astratti della superclasse.

　Poiché la nostra sottoclasse contiene metodi astratti, dobbiamo sovrascriverli.

Attenzione:Se la sottoclasse è anche dichiarata astratta, non è necessario forzare la sovrascrittura del metodo astratto.

Esempio 2: Sovrascrittura di un metodo astratto

abstract class Animal {
　　　abstract void makeSound();
　　　public void eat() {
　　　　　　System.out.println("Posso mangiare.");
　　　}
}
class Dog extends Animal {
　　　public void makeSound() {
　　　　　　System.out.println("Guau guau");
　　　}
}
class Main {
　　　public static void main(String[] args) {
　　　　　　Dog d1 = new Dog();
　　　　　　d1.makeSound();
　　　　　　d1.eat();
　　　}
}

Output:

Guau guau.
Posso mangiare.

Nell'esempio sopra, abbiamo creato una classe astratta Animal. Questa classe contiene un metodo astratto makeSound() e un metodo non astratto eat().

　Poi abbiamo creato l'oggetto Dog d1. Utilizzando questo oggetto, abbiamo chiamato i metodi d1.displayInfo() e d1.eat().

Accedere al costruttore di una classe astratta

Simile a classi non astratte, utilizziamo la parola chiave super per accedere al costruttore di una classe astratta dalla sottoclasse. Ad esempio,

abstract class Animal {
　　　Animal() {
　　　　　　...
　　　}
}
class Dog extends Animal {
　　　Dog() {
　　　　　　super();
　　　　　　...
　　　}
}

Qui, utilizziamo super() nel costruttore di Dog per accedere al costruttore della classe Animal.

Attenzione, super dovrebbe essere sempre la prima istruzione nel costruttore della sottoclasse. AccessoParole chiave JavaPer saperne di più.

Perché utilizzare l'astrazione in Java?

L'astrazione è un concetto importante dell'ingegneria del software orientata agli oggetti. L'astrazione mostra solo le informazioni necessarie, mantenendo nascoste tutte le dettagli inutili. Ci permette di gestire la complessità attraverso l'uso di idee più semplici e avanzate, omettendo o nascondendo dettagli.

Un esempio pratico di astrazione può essere il freno di una motocicletta. Conosciamo la funzione della frenata. Quando premo il freno, la motocicletta si ferma. Ma il funzionamento del freno ci è nascosto.

Uno dei principali vantaggi dell'astrazione della funzione del freno è che ora i produttori possono utilizzare freni diversi per diversi motocicli, ma il ruolo del freno è lo stesso.

Facciamo un esempio per aiutarci a comprendere meglio l'astrazione in Java.

Esempio 3: Abstract Java

abstract class Animal {
　　　abstract void makeSound();
}
class Dog extends Animal {
　　　public void makeSound() {
　　　　　　System.out.println("Bark bark.");
　　　}
}
class Cat extends Animal {
　　　public void makeSound() {
　　　　　　System.out.println("Meows ");
　　　}
}
class Main {
　　　public static void main(String[] args) {
　　　　　　Dog d1 = new Dog();
　　　　　　d1.makeSound();
　　　　　　Cat c1 = new Cat();
　　　　　　c1.makeSound();
　　　}
}

Output:

Bark bark
Meows

Nel esempio sopra, abbiamo creato una superclasse Animal. La superclasse Animal ha un metodo astratto makeSound().

Il metodo makeSound() non può essere implementato all'interno di Animal. Questo perché ogni animale emette suoni diversi. Pertanto, tutte le sottoclassi di Animal hanno implementazioni diverse del metodo makeSound().

Non possiamo implementare makeSound() in Animal in modo che sia corretto per tutti i sottoinsiemi di Animal. Pertanto, l'implementazione di makeSound() in Animal rimane in stato nascosto.

　Nell'esempio sopra, Dog ha implementato il proprio makeSound() implementation, Cat ha implementato il proprio makeSound().

Punti da ricordare

• Usiamo la parola chiave abstract per creare classi e metodi astratti.

• I metodi astratti non hanno alcuna implementazione (corpo del metodo).

• La classe che contiene i metodi astratti dovrebbe essere astratta.

• Non possiamo creare un oggetto della classe astratta.

• Per implementare le funzionalità della classe astratta, inheritiamo il sottoinsieme e creiamo un oggetto del sottoinsieme.

• Il sottoinsieme deve sovrascrivere tutti i metodi astratti della classe astratta. Tuttavia, se il sottoinsieme è dichiarato astratto, non è necessario sovrascrivere i metodi astratti.

• Possiamo utilizzare un riferimento di classe astratta per accedere alle proprietà e ai metodi statici della classe astratta. Ad esempio,

  Animal.staticMethod();

Interfaccia Java

In Java, un'interfaccia è simile a una classe astratta. Tuttavia, un'interfaccia non ha metodi non astratti. Nel prossimo tutorial, impareremo di più sulle interfacce.