Java valodā abstraktā klase tiek deklarēta ar abstraktu atslēgvārdu. Tam var būt gan abstraktas, gan neabstraktas metodes (metodes ar ķermeņiem). Abstrakts ir Java modifikators, kas piemērojams klasēm un metodēm Java, bet ne mainīgajiem . Šajā rakstā mēs iemācīsimies izmantot abstraktās klases Java.
Kas ir abstraktā klase Java valodā?
Java abstraktā klase ir klase, kuru nevar iniciēt pati, tā ir jāiedala citai klasei, lai izmantotu tās rekvizītus. Abstrakta klase tiek deklarēta, tās klases definīcijā izmantojot abstraktu atslēgvārdu.
Abstraktas klases ilustrācija
abstract class Shape { int color; // An abstract function abstract void draw(); }> Java, daži šādi svarīgi novērojumi par abstraktajām klasēm ir šādas:
- Abstraktas klases gadījumu nevar izveidot.
- Konstruktori ir atļauti.
- Mums var būt abstrakta klase bez jebkādas abstraktas metodes.
- Var būt a galīgā metode abstraktajā klasē, bet jebkura abstraktā metode klasē (abstraktā klase) nevar tikt deklarēta kā galīga vai vienkāršāk sakot galīgā metode pati nevar būt abstrakta, jo tā radīs kļūdu: Nelegāla modifikatoru kombinācija: abstraktā un galīgā
- Mēs varam definēt statiskās metodes abstraktā klasē
- Mēs varam izmantot abstrakts atslēgvārds par deklarēšanu augstākā līmeņa nodarbības (Ārējā klase), kā arī iekšējās klases kā abstrakts
- Ja klasē satur vismaz viena abstrakta metode tad obligāti ir jāpaziņo klase kā abstrakta
- Ja Bērnu klase nespēj nodrošināt visu abstrakto metožu ieviešanu Vecāku klase tad mums tas būtu jāpaziņo Bērnu klase kā abstrakts lai nākamā līmeņa bērnu klasei būtu jānodrošina atlikušās abstraktās metodes ieviešana
Java abstraktās klases piemēri
1. Abstract Class, kurai ir abstraktā metode, piemērs
Zemāk ir aprakstīta iepriekš minētās tēmas īstenošana:
Java
// Abstract class> abstract> class> Sunstar {> >abstract> void> printInfo();> }> // Abstraction performed using extends> class> Employee>extends> Sunstar {> >void> printInfo()> >{> >String name =>'avinash'>;> >int> age =>21>;> >float> salary =>222>.2F;> >System.out.println(name);> >System.out.println(age);> >System.out.println(salary);> >}> }> // Base class> class> Base {> >public> static> void> main(String args[])> >{> >Sunstar s =>new> Employee();> >s.printInfo();> >}> }> |
>
>Izvade
avinash 21 222.2>
2. Abstraktā klase ar konstruktoru, datu locekli un metodēm
Abstraktās klases elementi var būt
- datu dalībnieks
- abstraktā metode
- metodes pamatteksts (neabstraktā metode)
- konstruktors
- galvenā() metode.
Zemāk ir aprakstīta iepriekš minētās tēmas īstenošana:
Java
// Java Program to implement Abstract Class> // having constructor, data member, and methods> import> java.io.*;> abstract> class> Subject {> >Subject() {> >System.out.println(>'Learning Subject'>);> >}> > >abstract> void> syllabus();> > >void> Learn(){> >System.out.println(>'Preparing Right Now!'>);> >}> }> class> IT>extends> Subject {> >void> syllabus(){> >System.out.println(>'C , Java , C++'>);> >}> }> class> GFG {> >public> static> void> main(String[] args) {> >Subject x=>new> IT();> > >x.syllabus();> >x.Learn();> >}> }> |
>
>Izvade
Learning Subject C , Java , C++ Preparing Right Now!>
Abstraktās klases īpašības
Apskatīsim šos novērojumus un attaisnosim tos ar tīru java programmu palīdzību šādi.
Novērojums 1
Java, tāpat kā C++, nevar izveidot abstraktas klases gadījumu, tomēr mums var būt atsauces uz abstraktās klases tipu. Tas ir, kā parādīts zemāk, izmantojot tīro Java programmu.
Piemērs
Java
// Java Program to Illustrate> // that an instance of Abstract> // Class can not be created> // Class 1> // Abstract class> abstract> class> Base {> >abstract> void> fun();> }> // Class 2> class> Derived>extends> Base {> >void> fun()> >{> >System.out.println(>'Derived fun() called'>);> >}> }> // Class 3> // Main class> class> Main {> >// Main driver method> >public> static> void> main(String args[])> >{> >// Uncommenting the following line will cause> >// compiler error as the line tries to create an> >// instance of abstract class. Base b = new Base();> >// We can have references of Base type.> >Base b =>new> Derived();> >b.fun();> >}> }> |
>
>Izvade
faktoriāls c
Derived fun() called>
2. novērojums
Tāpat kā C++, an abstraktā klase var saturēt konstruktori Java valodā. Un abstraktas klases konstruktors tiek izsaukts, kad tiek izveidots mantotās klases gadījums. Tas ir, kā parādīts tālāk esošajā programmā:
Piemērs:
Java
// Java Program to Illustrate Abstract Class> // Can contain Constructors> // Class 1> // Abstract class> abstract> class> Base {> >// Constructor of class 1> >Base()> >{> >// Print statement> >System.out.println(>'Base Constructor Called'>);> >}> >// Abstract method inside class1> >abstract> void> fun();> }> // Class 2> class> Derived>extends> Base {> >// Constructor of class2> >Derived()> >{> >System.out.println(>'Derived Constructor Called'>);> >}> >// Method of class2> >void> fun()> >{> >System.out.println(>'Derived fun() called'>);> >}> }> // Class 3> // Main class> class> GFG {> >// Main driver method> >public> static> void> main(String args[])> >{> >// Creating object of class 2> >// inside main() method> >Derived d =>new> Derived();> >d.fun();> >}> }> |
>
>Izvade
Base Constructor Called Derived Constructor Called Derived fun() called>
3. novērojums
Java, mēs varam būt abstrakta klase bez abstraktas metodes . Tas mums ļauj izveidot klases, kuras nevar izveidot, bet kuras var tikai mantot . Tas ir, kā parādīts tālāk, izmantojot tīru java programmu.
Piemērs:
Java
// Java Program to illustrate Abstract class> // Without any abstract method> // Class 1> // An abstract class without any abstract method> abstract> class> Base {> >// Demo method. This is not an abstract method.> >void> fun()> >{> >// Print message if class 1 function is called> >System.out.println(> >'Function of Base class is called'>);> >}> }> // Class 2> class> Derived>extends> Base {> >// This class only inherits the Base class methods and> >// properties> }> // Class 3> class> Main {> >// Main driver method> >public> static> void> main(String args[])> >{> >// Creating object of class 2> >Derived d =>new> Derived();> >// Calling function defined in class 1 inside main()> >// with object of class 2 inside main() method> >d.fun();> >}> }> |
>
>Izvade
Function of Base class is called>
4. novērojums
Var būt arī abstraktās nodarbības galīgais metodes (metodes, kuras nevar ignorēt)
Piemērs:
Java
// Java Program to Illustrate Abstract classes> // Can also have Final Methods> // Class 1> // Abstract class> abstract> class> Base {> >final> void> fun()> >{> >System.out.println(>'Base fun() called'>);> >}> }> // Class 2> class> Derived>extends> Base {> > }> // Class 3> // Main class> class> GFG {> >// Main driver method> >public> static> void> main(String args[])> >{> >{> >// Creating object of abstract class> >Base b =>new> Derived();> >// Calling method on object created above> >// inside main method> >b.fun();> >}> >}> }> |
>
>Izvade
Base fun() called>
5. novērojums
Nevienai abstraktai java klasei mums nav atļauts izveidot objektu, t.i., abstraktai klasei instantiācija nav iespējama.
Java
// Java Program to Illustrate Abstract Class> // Main class> // An abstract class> abstract> class> GFG {> >// Main driver method> >public> static> void> main(String args[])> >{> >// Trying to create an object> >GFG gfg =>new> GFG();> >}> }> |
>
>
Izvade:
6. novērojums
Līdzīgi kā interfeiss mēs varam definēt statiskās metodes abstraktā klasē ka var izsaukt neatkarīgi bez objekta.
Java
// Java Program to Illustrate> // Static Methods in Abstract> // Class Can be called Independently> // Class 1> // Abstract class> abstract> class> Helper {> >// Abstract method> >static> void> demofun()> >{> >// Print statement> >System.out.println(>'Geeks for Geeks'>);> >}> }> // Class 2> // Main class extending Helper class> public> class> GFG>extends> Helper {> >// Main driver method> >public> static> void> main(String[] args)> >{> >// Calling method inside main()> >// as defined in above class> >Helper.demofun();> >}> }> |
>
>Izvade
Geeks for Geeks>
7. novērojums
Mēs varam izmantot abstrakts atslēgvārds augstākā līmeņa klašu (Ārējā klase), kā arī iekšējo klašu pasludināšanai par abstraktām
Java
import> java.io.*;> abstract> class> B {> >// declaring inner class as abstract with abstract> >// method> >abstract> class> C {> >abstract> void> myAbstractMethod();> >}> }> class> D>extends> B {> >class> E>extends> C {> >// implementing the abstract method> >void> myAbstractMethod()> >{> >System.out.println(> >'Inside abstract method implementation'>);> >}> >}> }> public> class> Main {> >public> static> void> main(String args[])> >{> >// Instantiating the outer class> >D outer =>new> D();> >// Instantiating the inner class> >D.E inner = outer.>new> E();> >inner.myAbstractMethod();> >}> }> |
>
instantiēta java
>Izvade
Inside abstract method implementation>
Novērojums 8
Ja klase satur vismaz vienu abstraktu metodi tad klase ir obligāti jāpaziņo par abstraktu pretējā gadījumā mēs saņemsim kompilēšanas laika kļūdu. Ja klasē ir vismaz viena abstrakta metode, tad šīs klases ieviešana nav pabeigta, un tāpēc nav ieteicams izveidot objektu, lai ierobežotu objektu izveidi šādām daļējām klasēm mēs izmantojam abstrakts atslēgvārds.
Java
/*package whatever //do not write package name here */> import> java.io.*;> // here if we remove the abstract> // keyword then we will get compile> // time error due to abstract method> abstract> class> Demo {> >abstract> void> m1();> }> class> Child>extends> Demo {> >public> void> m1()> >{> >System.out.print(>'Hello'>);> >}> }> class> GFG {> >public> static> void> main(String[] args)> >{> >Child c =>new> Child();> >c.m1();> >}> }> |
>
>Izvade
Hello>
Novērojums 9
Ja Bērns klase nespēj nodrošināt visu vecākklases abstrakto metožu ieviešanu, tad mums šī Child klase jāpaziņo kā abstrakta, lai nākamā līmeņa Child klasei būtu jānodrošina atlikušās abstraktās metodes ieviešana.
Java
// Java Program to demonstrate> // Observation> import> java.io.*;> abstract> class> Demo {> >abstract> void> m1();> >abstract> void> m2();> >abstract> void> m3();> }> abstract> class> FirstChild>extends> Demo {> >public> void> m1() {> >System.out.println(>'Inside m1'>);> >}> }> class> SecondChild>extends> FirstChild {> >public> void> m2() {> >System.out.println(>'Inside m2'>);> >}> >public> void> m3() {> >System.out.println(>'Inside m3'>);> >}> }> class> GFG {> >public> static> void> main(String[] args)> >{> >// if we remove the abstract keyword from FirstChild> >// Class and uncommented below obj creation for> >// FirstChild then it will throw> >// compile time error as did't override all the> >// abstract methods> >// FirstChild f=new FirstChild();> >// f.m1();> >SecondChild s =>new> SecondChild();> >s.m1();> >s.m2();> >s.m3();> >}> }> |
>
>Izvade
Inside m1 Inside m2 Inside m3>
C++ valodā, ja klasē ir vismaz viens tīra virtuāla funkcija , tad klase kļūst abstrakta. Atšķirībā no C++, Java, lai izveidotu klases abstraktu, tiek izmantots atsevišķs atslēgvārda abstract.
Secinājums
Tālāk ir minēti punkti, kas jāatceras no šī raksta:
- Abstraktā klase ir klase, kuru nevar iniciēt pati, tā ir jāiedala citai klasei, lai izmantotu tās īpašības.
- Abstraktu klasi var izveidot, izmantojot abstraktus atslēgvārdus.
- Mums var būt abstrakta klase bez jebkādas abstraktas metodes.
Abstract klases FAQ
1. Kas ir abstraktā klase Java?
Abstraktā klase Java ir klase, kuru nevar iniciēt pati par sevi, bet cita klase to var izmantot kā apakšklasi.
2. Kāds ir abstraktās klases mērķis?
Abstraktās klases galvenais mērķis ir izveidot bāzes klasi, no kuras var iegūt daudzas citas klases.
3. Kāda ir abstraktās klases galvenā priekšrocība?
Abstraktā klase nodrošina datu slēpšanu Java.
4. Kāpēc abstraktā klase ir ātrāka par interfeisu?
Abstraktā klase ir ātrāka nekā saskarne, jo saskarne ietver meklēšanu pirms jebkuras Java metodes ignorēšanas, turpretim abstrakto klasi var izmantot tieši.
Arī Lasīt
- Atšķirība starp abstrakto klasi un interfeisu Java
- Atšķirība starp abstrakto klasi un abstraktajām metodēm
- Konstruktori Java abstraktajā klasē