Una classe dichiarata con la parola chiave abstract è nota come classe astratta in Giava . Può avere metodi astratti e non astratti (metodo con il corpo).

Prima di apprendere la classe astratta Java, comprendiamo prima l'astrazione in Java.

dialetto ibernato

Astrazione in Java

Astrazione è un processo che nasconde i dettagli di implementazione e mostra solo le funzionalità all'utente.

Un altro modo, mostra solo le cose essenziali all'utente e nasconde i dettagli interni, ad esempio l'invio di SMS in cui si digita il testo e si invia il messaggio. Non conosci l'elaborazione interna relativa alla consegna del messaggio.

L'astrazione ti consente di concentrarti su ciò che oggetto fa invece di come lo fa.

Modi per raggiungere l'astrazione

Esistono due modi per ottenere l'astrazione in Java

1. Classe astratta (da 0 a 100%)
2. Interfaccia (100%)

Classe astratta in Java

Una classe dichiarata come astratta è nota come an classe astratta . Può avere metodi astratti e non astratti. È necessario estenderlo e implementarne il metodo. Non è possibile istanziarlo.

Punti da ricordare

• Una classe astratta deve essere dichiarata con una parola chiave astratta.
• Può avere metodi astratti e non astratti.
• Non è possibile istanziarlo.
• Può avere costruttori e anche metodi statici.
• Può avere metodi finali che forzeranno la sottoclasse a non modificare il corpo del metodo.

Esempio di classe astratta

 abstract class A{} 

Metodo astratto in Java

Un metodo dichiarato astratto e privo di implementazione è noto come metodo astratto.

Esempio di metodo astratto

 abstract void printStatus();//no method body and abstract 

Esempio di classe Abstract che dispone di un metodo astratto

In questo esempio Bike è una classe astratta che contiene solo un metodo astratto eseguito. La sua implementazione è fornita dalla classe Honda.

 abstract class Bike{ abstract void run(); } class Honda4 extends Bike{ void run(){System.out.println('running safely');} public static void main(String args[]){ Bike obj = new Honda4(); obj.run(); } } 

 running safely 

Comprendere lo scenario reale della classe Abstract

In questo esempio Shape è la classe astratta e la sua implementazione è fornita dalle classi Rectangle e Circle.

Per lo più, non conosciamo la classe di implementazione (che è nascosta all'utente finale) e un oggetto della classe di implementazione viene fornito da metodo di fabbrica .

UN metodo di fabbrica è un metodo che restituisce l'istanza della classe. Impareremo il metodo di fabbrica più tardi.

In questo esempio, se crei l'istanza della classe Rectangle, verrà richiamato il metodo draw() della classe Rectangle.

File: TestAbstraction1.java

 abstract class Shape{ abstract void draw(); } //In real scenario, implementation is provided by others i.e. unknown by end user class Rectangle extends Shape{ void draw(){System.out.println('drawing rectangle');} } class Circle1 extends Shape{ void draw(){System.out.println('drawing circle');} } //In real scenario, method is called by programmer or user class TestAbstraction1{ public static void main(String args[]){ Shape s=new Circle1();//In a real scenario, object is provided through method, e.g., getShape() method s.draw(); } } 

 drawing circle 

Un altro esempio di classe Abstract in Java

File: TestBank.java

 abstract class Bank{ abstract int getRateOfInterest(); } class SBI extends Bank{ int getRateOfInterest(){return 7;} } class PNB extends Bank{ int getRateOfInterest(){return 8;} } class TestBank{ public static void main(String args[]){ Bank b; b=new SBI(); System.out.println('Rate of Interest is: '+b.getRateOfInterest()+' %'); b=new PNB(); System.out.println('Rate of Interest is: '+b.getRateOfInterest()+' %'); }} 

 Rate of Interest is: 7 % Rate of Interest is: 8 % 

Classe astratta con costruttore, membro dati e metodi

Una classe astratta può avere un membro dati, un metodo astratto, un corpo del metodo (metodo non astratto), un costruttore e persino un metodo main().

File: TestAbstraction2.java

nomi di città negli Stati Uniti

 //Example of an abstract class that has abstract and non-abstract methods abstract class Bike{ Bike(){System.out.println('bike is created');} abstract void run(); void changeGear(){System.out.println('gear changed');} } //Creating a Child class which inherits Abstract class class Honda extends Bike{ void run(){System.out.println('running safely..');} } //Creating a Test class which calls abstract and non-abstract methods class TestAbstraction2{ public static void main(String args[]){ Bike obj = new Honda(); obj.run(); obj.changeGear(); } } 

 bike is created running safely.. gear changed 

Regola: se in una classe è presente un metodo astratto, quella classe deve essere astratta.

 class Bike12{ abstract void run(); } 

 compile time error 

Regola: se stai estendendo una classe astratta che ha un metodo astratto, devi fornire l'implementazione del metodo o rendere astratta questa classe.

Un altro scenario reale di classe astratta

La classe astratta può essere utilizzata anche per fornire alcune implementazioni di interfaccia . In tal caso, l'utente finale potrebbe non essere costretto a sovrascrivere tutti i metodi dell'interfaccia.

Nota: se sei un principiante di Java, impara prima l'interfaccia e salta questo esempio.

 interface A{ void a(); void b(); void c(); void d(); } abstract class B implements A{ public void c(){System.out.println('I am c');} } class M extends B{ public void a(){System.out.println('I am a');} public void b(){System.out.println('I am b');} public void d(){System.out.println('I am d');} } class Test5{ public static void main(String args[]){ A a=new M(); a.a(); a.b(); a.c(); a.d(); }} 

 Output:I am a I am b I am c I am d