A Java, la classe abstracta es declara amb la paraula clau abstracta. Pot tenir mètodes abstractes i no abstractes (mètodes amb cossos). Un resum és un modificador de Java aplicable a classes i mètodes en Java però no per a variables . En aquest article, aprendrem l'ús de classes abstractes a Java.
Què és la classe abstracta a Java?
La classe abstracta de Java és una classe que no es pot iniciar per ella mateixa, necessita ser subclassificada per una altra classe per utilitzar les seves propietats. Una classe abstracta es declara utilitzant la paraula clau abstracta a la seva definició de classe.
Il·lustració de la classe abstracta
abstract class Shape { int color; // An abstract function abstract void draw(); }> A Java, els següents alguns observacions importants sobre les classes abstractes són els següents:
- No es pot crear una instància d'una classe abstracta.
- Els constructors estan permesos.
- Podem tenir una classe abstracta sense cap mètode abstracte.
- Hi pot haver un mètode final en classe abstracta, però qualsevol mètode abstracte a classe (classe abstracta) no es pot declarar com a final o, en termes més senzills, el mètode final no pot ser abstracte en si mateix, ja que produirà un error: Combinació il·legal de modificadors: abstracte i final
- Podem definir mètodes estàtics en una classe abstracta
- Podem utilitzar el paraula clau abstracta per declarar classes de primer nivell (classe exterior) i classes internes com a abstracte
- Si a classe conté almenys un mètode abstracte llavors és obligatori declarar una classe com a abstracta
- Si el Classe infantil no pot proporcionar implementació a tots els mètodes abstractes de l' Classe de pares llavors ho hauríem de declarar Classe infantil com a abstracta de manera que la classe Child del següent nivell hauria de proporcionar implementació al mètode abstracte restant
Exemples de classe abstracta de Java
1. Exemple de classe abstracta que té el mètode abstracte
A continuació es mostra la implementació del tema anterior:
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();> >}> }> |
>
>Sortida
avinash 21 222.2>
2. Classe abstracta amb constructor, membre de dades i mètodes
Elements que la classe abstracta pot tenir
- membre de dades
- mètode abstracte
- cos del mètode (mètode no abstracte)
- constructor
- mètode main().
A continuació es mostra la implementació del tema anterior:
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();> >}> }> |
>
>Sortida
Learning Subject C , Java , C++ Preparing Right Now!>
Propietats de la classe Abstract
Ampliem aquestes observacions i justifiquem-les amb l'ajuda de programes java nets de la següent manera.
Observació 1
A Java, igual que en C++, no es pot crear una instància d'una classe abstracta, però podem tenir referències al tipus de classe abstracta. És com es mostra a continuació mitjançant el programa Java net.
Exemple
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();> >}> }> |
>
>Sortida
python snake vs anaconda
Derived fun() called>
Observació 2
Igual que C++, an classe abstracta pot contenir constructors en Java. I es crida un constructor d'una classe abstracta quan es crea una instància d'una classe heretada. És com es mostra al programa següent de la següent manera:
Exemple:
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();> >}> }> |
>
>Sortida
Base Constructor Called Derived Constructor Called Derived fun() called>
Observació 3
A Java, podem tenir una classe abstracta sense cap mètode abstracte . Això ens permet crear classes que no es poden instanciar però que només es poden heretar . Es mostra com es mostra a continuació amb l'ajuda d'un programa java net.
Exemple:
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();> >}> }> |
>
>Sortida
Function of Base class is called>
Observació 4
També poden tenir classes abstractes final mètodes (mètodes que no es poden anul·lar)
Exemple:
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();> >}> >}> }> |
>
>Sortida
Base fun() called>
Observació 5
Per a cap classe java abstracta no podem crear un objecte, és a dir, per a una classe abstracta la instanciació no és possible.
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();> >}> }> |
>
>
Sortida:
Observació 6
Similar a la interfície podem definir mètodes estàtics en una classe abstracta això es pot cridar independentment sense objecte.
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();> >}> }> |
>
>Sortida
Geeks for Geeks>
Observació 7
Podem utilitzar el paraula clau abstracta per declarar les classes de primer nivell (classe externa) així com les classes internes com a abstractes
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();> >}> }> |
>
>Sortida
Inside abstract method implementation>
Observació 8
Si a classe conté almenys un mètode abstracte aleshores és obligatori que declarem la classe com a abstracta en cas contrari, obtindrem un error en temps de compilació, si una classe conté almenys un mètode abstracte, la implementació no està completa per a aquesta classe i, per tant, no es recomana crear un objecte per tal de restringir la creació d'objectes per a aquestes classes parcials. fem servir paraula clau abstracta.
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();> >}> }> |
>
>Sortida
Estructures de control Python
Hello>
Observació 9
Si el Nen La classe no pot proporcionar implementació a tots els mètodes abstractes de la classe Parent, llavors hauríem de declarar aquesta classe Fill com a abstracta de manera que la classe Fill de nivell següent proporcioni implementació al mètode abstracte restant.
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();> >}> }> |
>
>Sortida
Inside m1 Inside m2 Inside m3>
En C++, si una classe en té almenys una funció virtual pura , aleshores la classe esdevé abstracta. A diferència de C++, a Java, s'utilitza una paraula clau abstracta separada per fer un resum de classe.
Conclusió
Els punts a recordar d'aquest article s'esmenten a continuació:
- Una classe abstracta és una classe que no es pot iniciar per ella mateixa, necessita ser subclassificada per una altra classe per utilitzar les seves propietats.
- Es pot crear una classe abstracta utilitzant paraules clau abstractes.
- Podem tenir una classe abstracta sense cap mètode abstracte.
Preguntes freqüents de la classe abstracta
1. Què és una classe abstracta a Java?
Una classe abstracta en Java és una classe que no es pot iniciar per si sola però que una altra classe pot utilitzar-la com a subclasse.
2. Quin és el propòsit de la classe abstracta?
El propòsit principal de la classe abstracta és crear una classe base de la qual es poden derivar moltes altres classes.
3. Quin és el principal avantatge de la classe abstracta?
Una classe abstracta proporciona les dades que s'amaguen a Java.
4. Per què la classe abstracta és més ràpida que la interfície?
Una classe abstracta és més ràpida que una interfície perquè la interfície implica una cerca abans de cridar a qualsevol mètode anul·lat a Java, mentre que la classe abstracta es pot utilitzar directament.
També, Llegir
- Diferència entre la classe abstracta i la interfície a Java
- Diferència entre la classe abstracta i els mètodes abstractes
- Constructors a la classe abstracta de Java