La parola chiave abstract viene utilizzata per ottenere l'astrazione in Java. È un modificatore non di accesso che viene utilizzato per creare classi e metodi astratti.

Il ruolo di una classe astratta è contenere metodi astratti. Tuttavia, può contenere anche metodi non astratti. Il metodo dichiarato con la parola chiave abstract e non ha alcuna implementazione è noto come metodo astratto.

stringa ad esso

Sintassi:-

 abstract class Employee { abstract void work(); } 

Nota: non possiamo dichiarare metodi astratti in classi non astratte.

Regole delle parole chiave astratte

Non farlo

• Una parola chiave astratta non può essere utilizzata con variabili e costruttori.
• Se una classe è astratta, non può essere istanziata.
• Se un metodo è astratto, non contiene il corpo.
• Non possiamo usare la parola chiave abstract con the finale .
• Non possiamo dichiarare metodi astratti come privato .
• Non possiamo dichiarare metodi astratti come statico .
• Un metodo astratto non può essere sincronizzato.

Cosa fare

• Una parola chiave astratta può essere utilizzata solo con classe e metodo.
• Una classe astratta può contenere costruttori e metodi statici.
• Se una classe estende la classe astratta, deve anche implementare almeno uno dei metodi astratti.
• Una classe astratta può contenere il metodo principale e il metodo finale.
• Una classe astratta può contenere metodi astratti sovraccarichi.
• Possiamo dichiarare astratta la classe interna locale.
• Possiamo dichiarare il metodo astratto con una clausola Throw.

Esempi di parole chiave astratte

Esempio 1: classe astratta contenente il metodo astratto

 abstract class Vehicle { abstract void bike(); } class Honda extends Vehicle { @Override void bike() { System.out.println('Bike is running'); } } public class AbstractExample1 { public static void main(String[] args) { Honda obj=new Honda(); obj.bike(); } } 

Produzione:

 Bike is running 

Esempio 2: classe astratta contenente il metodo astratto e non astratto

 abstract class Vehicle { abstract void bike(); void car() { System.out.println('Car is running'); } } class Honda extends Vehicle { @Override void bike() { System.out.println('Bike is running'); } } public class AbstractExample2 { public static void main(String[] args) { Honda obj=new Honda(); obj.bike(); obj.car(); } } 

Produzione:

 Bike is running Car is running 

Esempio 3: classe astratta contenente il costruttore

 abstract class Vehicle { String msg; Vehicle(String msg) { this.msg=msg; } void display() { System.out.println(msg); } } class Honda extends Vehicle { Honda(String msg) { super(msg); } } public class AbstractExample3 { public static void main(String[] args) { Honda obj=new Honda('Constructor is invoked'); obj.display(); } } 

Produzione:

 Constructor is invoked 

Esempio 4: classe astratta contenente metodi astratti sovraccarichi

 abstract class Vehicle { abstract void display(); abstract void display(String msg); } class Honda extends Vehicle { @Override void display() { System.out.println('abstract method is invoked'); } @Override void display(String msg) { System.out.println(msg); } } public class AbstractExample4 { public static void main(String[] args) { Honda obj=new Honda(); obj.display(); obj.display('overloaded abstract method is invoked'); } } 

Produzione:

 abstract method is invoked overloaded abstract method is invoked 

Esempio 5: classe astratta interna

 class Vehicle { abstract class Car { abstract void display(); } class Honda extends Car { @Override void display() { System.out.println('inner abstract class is invoked'); } } } public class AbstractExample5 { public static void main(String[] args) { Vehicle obj=new Vehicle(); Vehicle.Car c=obj.new Honda(); c.display(); } } 

Produzione:

logica di trasferimento dei registri

 inner abstract class is invoked 

Esempio 6: classe astratta nidificata

 abstract class Vehicle { abstract class Car { abstract void display(); } } class Honda extends Vehicle { class FourWheller extends Car { @Override void display() { System.out.println('nested abstract class is invoked'); } } } public class AbstractExample6 { public static void main(String[] args) { Vehicle obj=new Honda(); Honda h=(Honda)obj; Honda.FourWheller fw=h.new FourWheller(); fw.display(); } } 

Produzione:

 nested abstract class is invoked