Abstraktia avainsanaa käytetään abstraktion saavuttamiseen Javassa. Se on ei-pääsy-muokkaus, jota käytetään abstraktien luokan ja menetelmän luomiseen.

Abstraktin luokan tehtävänä on sisältää abstrakteja menetelmiä. Se voi kuitenkin sisältää myös ei-abstrakteja menetelmiä. Menetelmä, joka on ilmoitettu abstraktilla avainsanalla ja jolla ei ole toteutusta, tunnetaan abstraktina menetelmänä.

Syntaksi:-

 abstract class Employee { abstract void work(); } 

Huomautus - Emme voi ilmoittaa abstrakteja menetelmiä ei-abstraktissa luokassa.

Abstraktin avainsanan säännöt

Älä

• Abstraktia avainsanaa ei voi käyttää muuttujien ja rakentajien kanssa.
• Jos luokka on abstrakti, sitä ei voi ilmentää.
• Jos menetelmä on abstrakti, se ei sisällä kehoa.
• Emme voi käyttää abstraktia avainsanaa kanssa lopullinen .
• Emme voi julistaa abstrakteja menetelmiä yksityinen .
• Emme voi julistaa abstrakteja menetelmiä staattinen .
• Abstraktia menetelmää ei voi synkronoida.

Tehtävä

• Abstraktia avainsanaa voidaan käyttää vain luokan ja menetelmän kanssa.
• Abstrakti luokka voi sisältää konstruktoreita ja staattisia menetelmiä.
• Jos luokka laajentaa abstraktia luokkaa, sen tulee myös toteuttaa ainakin yksi abstrakti menetelmä.
• Abstrakti luokka voi sisältää päämenetelmän ja lopullisen menetelmän.
• Abstrakti luokka voi sisältää ylikuormitettuja abstrakteja menetelmiä.
• Voimme julistaa paikallisen sisäluokan abstraktiksi.
• Voimme ilmoittaa abstraktin menetelmän heittolausekkeella.

Esimerkkejä abstraktista avainsanasta

Esimerkki 1: Abstrakti luokka, joka sisältää abstraktin menetelmän

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

Lähtö:

 Bike is running 

Esimerkki 2: Abstrakti luokka, joka sisältää abstraktin ja ei-abstraktin menetelmän

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

Lähtö:

 Bike is running Car is running 

Esimerkki 3: Abstrakti luokka, joka sisältää konstruktorin

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

Lähtö:

 Constructor is invoked 

Esimerkki 4: Abstrakti luokka, joka sisältää ylikuormitettuja abstrakteja menetelmiä

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

Lähtö:

 abstract method is invoked overloaded abstract method is invoked 

Esimerkki 5: Sisäinen abstrakti luokka

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

Lähtö:

 inner abstract class is invoked 

Esimerkki 6: Sisäkkäinen abstrakti luokka

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

Lähtö:

 nested abstract class is invoked