Classe e metodo astratti Java (con esempio)

In questo tutorial, impareremo a conoscere classi e metodi astratti Java con l'aiuto di esempi. Impareremo anche l'astrazione in Java.

Classe astratta Java

La classe astratta in Java non può essere istanziata (non possiamo creare oggetti di classi astratte). Usiamo la abstractparola chiave per dichiarare una classe astratta. Per esempio,

 // create an abstract class abstract class Language ( // fields and methods )… // try to create an object Language // throws an error Language obj = new Language(); 

Una classe astratta può avere sia metodi regolari che metodi astratti. Per esempio,

 abstract class Language ( // abstract method abstract void method1(); // regular method void method2() ( System.out.println("This is regular method"); ) )

Per conoscere i metodi non astratti, visita i metodi Java. Qui impareremo i metodi astratti.

Metodo astratto Java

Un metodo che non ha il suo corpo è noto come metodo astratto. Usiamo la stessa abstractparola chiave per creare metodi astratti. Per esempio,

 abstract void display();

Ecco display()un metodo astratto. Il corpo di display()è sostituito da ;.

Se una classe contiene un metodo astratto, la classe dovrebbe essere dichiarata astratta. In caso contrario, genererà un errore. Per esempio,

 // error // class should be abstract class Language ( // abstract method abstract void method1(); )

Esempio: classe e metodo Java Abstract

Sebbene le classi astratte non possano essere istanziate, possiamo creare sottoclassi da esse. Possiamo quindi accedere ai membri della classe astratta utilizzando l'oggetto della sottoclasse. Per esempio,

 abstract class Language ( // method of abstract class public void display() ( System.out.println("This is Java Programming"); ) ) class Main extends Language ( public static void main(String() args) ( // create an object of Main Main obj = new Main(); // access method of abstract class // using object of Main class obj.display(); ) )

Produzione

 Questa è la programmazione Java

Nell'esempio precedente, abbiamo creato una classe astratta denominata Language. La classe contiene un metodo regolare display().

Abbiamo creato la classe Main che eredita la classe astratta. Notare la dichiarazione,

 obj.display();

In questo caso obj è l'oggetto della classe figlia Main. Stiamo chiamando il metodo della classe astratta usando l'oggetto obj.

Implementazione di metodi astratti

Se la classe astratta include un metodo astratto, tutte le classi figlie ereditate dalla superclasse astratta devono fornire l'implementazione del metodo astratto. Per esempio,

 abstract class Animal ( abstract void makeSound(); public void eat() ( System.out.println("I can eat."); ) ) class Dog extends Animal ( // provide implementation of abstract method public void makeSound() ( System.out.println("Bark bark"); ) ) class Main ( public static void main(String() args) ( // create an object of Dog class Dog d1 = new Dog(); d1.makeSound(); d1.eat(); ) )

Produzione

 Corteccia di corteccia che posso mangiare.

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

Abbiamo ereditato una sottoclasse Dog dalla superclasse Animal. Qui, la sottoclasse Dog fornisce l'implementazione per il metodo astratto makeSound().

Abbiamo quindi utilizzato l'oggetto d1 della classe Dog per chiamare i metodi makeSound()e eat().

Nota : se la classe Dog non fornisce l'implementazione del metodo abstract makeSound(), anche Dog dovrebbe essere dichiarato astratto. Questo perché la sottoclasse Dog eredita makeSound()da Animal.

Accede al Costruttore di classi astratte

Una classe astratta può avere costruttori come la classe normale. E possiamo accedere al costruttore di una classe astratta dalla sottoclasse usando la superparola chiave. Per esempio,

 abstract class Animal ( Animal() (… . ) ) class Dog extends Animal ( Dog() ( super();… ) )

Qui abbiamo usato l' super()interno del costruttore di Dog per accedere al costruttore di Animal.

Notare che superdovrebbe essere sempre la prima istruzione del costruttore della sottoclasse. Visita la parola chiave super Java per saperne di più.

Astrazione Java

L'uso principale di classi e metodi astratti è ottenere l'astrazione in Java.

L'astrazione è un concetto importante della programmazione orientata agli oggetti che ci consente di nascondere dettagli non necessari e mostrare solo le informazioni necessarie.

Questo ci consente di gestire la complessità omettendo o nascondendo i dettagli con un'idea più semplice e di livello superiore.

Un esempio pratico di astrazione possono essere i freni delle motociclette. Sappiamo cosa fa il freno. Quando applichiamo il freno, la moto si ferma. Tuttavia, il funzionamento del freno ci viene tenuto nascosto.

Il vantaggio principale di nascondere il funzionamento del freno è che ora il produttore può implementare il freno in modo diverso per le diverse moto, tuttavia, ciò che il freno fa sarà lo stesso.

Facciamo un esempio che ci aiuti a comprendere meglio l'astrazione Java.

Esempio 3: Java Abstraction

 abstract class Animal ( abstract void makeSound(); ) class Dog extends Animal ( // implementation of abstract method public void makeSound() ( System.out.println("Bark bark."); ) ) class Cat extends Animal ( // implementation of abstract method 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(); ) )

Uscita :

 Corteccia di corteccia miagola

In the above example, we have created a superclass Animal. The superclass Animal has an abstract method makeSound().

The makeSound() method cannot be implemented inside Animal. It is because every animal makes different sounds. So, all the subclasses of Animal would have different implementation of makeSound().

So, the implementation of makeSound() in Animal is kept hidden.

Here, Dog makes its own implementation of makeSound() and Cat makes its own implementation of makeSound().

Note: We can also use interfaces to achieve abstraction in Java. To learn more, visit Java Interface.

Key Points to Remember

• We use the abstract keyword to create abstract classes and methods.
• An abstract method doesn't have any implementation (method body).
• Anche una classe contenente metodi astratti dovrebbe essere astratta.
• Non possiamo creare oggetti di una classe astratta.
• Per implementare le caratteristiche di una classe astratta, ereditiamo le sottoclassi da essa e creiamo gli oggetti della sottoclasse.
• Una sottoclasse deve sovrascrivere tutti i metodi astratti di una classe astratta. Tuttavia, se la sottoclasse è dichiarata astratta, non è obbligatorio sovrascrivere i metodi astratti.
• Possiamo accedere agli attributi e ai metodi statici di una classe astratta utilizzando il riferimento della classe astratta. Per esempio,

   Animal.staticMethod();