În Java, clasa abstractă este declarată cu cuvântul cheie abstract. Poate avea atât metode abstracte, cât și non-abstracte (metode cu corpuri). Un rezumat este un modificator Java aplicabil pentru clase și metode în Java dar nu pentru variabile . În acest articol, vom învăța cum se utilizează clasele abstracte în Java.
Ce este clasa abstractă în Java?
Clasa abstractă Java este o clasă care nu poate fi inițiată de la sine, trebuie să fie subclasată de o altă clasă pentru a-și folosi proprietățile. O clasă abstractă este declarată folosind cuvântul cheie abstract din definiția clasei sale.
Ilustrație a clasei Abstracte
abstract class Shape { int color; // An abstract function abstract void draw(); }> În Java, următoarele unele observatii importante despre clasele abstracte sunt următoarele:
- O instanță a unei clase abstracte nu poate fi creată.
- Constructorii au voie.
- Putem avea o clasă abstractă fără nicio metodă abstractă.
- Poate exista o metoda finala în clasa abstractă, dar orice metodă abstractă din clasă (clasa abstractă) nu poate fi declarată finală sau, în termeni mai simpli, metoda finală nu poate fi abstractă în sine, deoarece va produce o eroare: Combinație ilegală de modificatori: abstract și final
- Putem defini metode statice într-o clasă abstractă
- Putem folosi cuvânt cheie abstract pentru declarare clasele de nivel superior (clasa exterioară), precum și clasele interioare ca abstract
- În cazul în care o clasă conţine cel puţin o singură metodă abstractă atunci obligatoriu ar trebui să declare o clasă ca abstractă
- Dacă Clasa de copii nu poate oferi implementare tuturor metodelor abstracte ale Clasa de părinți atunci ar trebui să declarăm că Clasa de copii ca abstract astfel încât clasa Child de nivelul următor ar trebui să ofere implementare metodei abstracte rămase
Exemple de clasă abstractă Java
1. Exemplu de clasă abstractă care are metoda abstractă
Mai jos este implementarea subiectului de mai sus:
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();> >}> }> |
>
>Ieșire
avinash 21 222.2>
2. Clasă abstractă având constructor, membru de date și metode
Elemente pe care le poate avea clasa abstractă
- membru de date
- metoda abstracta
- corpul metodei (metoda non-abstractă)
- constructor
- metoda main().
Mai jos este implementarea subiectului de mai sus:
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();> >}> }> |
>
>Ieșire
Learning Subject C , Java , C++ Preparing Right Now!>
Proprietățile clasei Abstract
Să detaliem aceste observații și să le justificăm cu ajutorul programelor java curate, după cum urmează.
Observația 1
În Java, la fel ca în C++, o instanță a unei clase abstracte nu poate fi creată, totuși putem avea referințe la tipul de clasă abstractă. Este așa cum se arată mai jos prin programul Java curat.
Exemplu
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();> >}> }> |
>
>Ieșire
hibernare dialect
Derived fun() called>
Observația 2
La fel ca C++, an clasa abstractă poate contine constructorii în Java. Și un constructor al unei clase abstracte este apelat atunci când este creată o instanță a unei clase moștenite. Este așa cum se arată în programul de mai jos, după cum urmează:
Exemplu:
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();> >}> }> |
>
>Ieșire
Base Constructor Called Derived Constructor Called Derived fun() called>
Observația 3
În Java, putem avea o clasă abstractă fără vreo metodă abstractă . Acest lucru ne permite creați clase care nu pot fi instanțiate, ci pot fi doar moștenite . Este așa cum se arată mai jos, cu ajutorul unui program java curat.
Exemplu:
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();> >}> }> |
>
>Ieșire
Function of Base class is called>
Observația 4
Clasele abstracte pot avea, de asemenea final metode (metode care nu pot fi anulate)
Exemplu:
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();> >}> >}> }> |
>
>Ieșire
Base fun() called>
Observația 5
Pentru orice clasă java abstractă nu avem voie să creăm un obiect, adică pentru o clasă abstractă, instanțierea nu este posibilă.
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();> >}> }> |
>
>
Ieșire:
Observația 6
Similar cu interfața putem defini metode statice într-o clasă abstractă acea poate fi numit independent fără obiect.
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();> >}> }> |
>
>Ieșire
Geeks for Geeks>
Observația 7
Putem folosi cuvânt cheie abstract pentru declararea claselor de nivel superior (clasa exterioară), precum și a claselor interioare ca abstracte
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();> >}> }> |
>
>
obiect în programarea javaIeșire
Inside abstract method implementation>
Observația 8
În cazul în care o clasa conține cel puțin o metodă abstractă apoi obligatoriu să declarăm clasa ca abstractă în caz contrar, vom obține o eroare de compilare, dacă o clasă conține cel puțin o metodă abstractă, atunci implementarea nu este completă pentru acea clasă și, prin urmare, nu este recomandat să creați un obiect, astfel încât să restricționați crearea de obiecte pentru astfel de clase parțiale folosim cuvânt cheie abstract.
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();> >}> }> |
>
>Ieșire
Hello>
Observația 9
Dacă Copil clasa nu poate oferi implementare tuturor metodelor abstracte ale clasei Parent, atunci ar trebui să declarăm acea clasă Child ca abstractă, astfel încât clasa Child de la nivelul următor să ofere implementare metodei abstracte rămase.
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();> >}> }> |
>
>Ieșire
Inside m1 Inside m2 Inside m3>
În C++, dacă o clasă are cel puțin una funcție virtuală pură , atunci clasa devine abstractă. Spre deosebire de C++, în Java, un cuvânt cheie abstract este folosit pentru a face un abstract de clasă.
Concluzie
Punctele de reținut din acest articol sunt menționate mai jos:
- O clasă abstractă este o clasă care nu poate fi inițiată de la sine, trebuie să fie subclasată de o altă clasă pentru a-și folosi proprietățile.
- O clasă abstractă poate fi creată folosind cuvinte cheie abstracte.
- Putem avea o clasă abstractă fără nicio metodă abstractă.
Întrebări frecvente ale clasei Abstract
1. Ce este o clasă abstractă în Java?
O clasă abstractă în Java este o clasă care nu poate fi inițiată singură, dar poate fi folosită ca subclasă de către o altă clasă.
2. Care este scopul clasei abstracte?
Scopul principal al clasei abstracte este de a crea o clasă de bază din care pot fi derivate multe alte clase.
3. Care este principalul avantaj al clasei abstracte?
O clasă abstractă oferă ascunderea datelor în Java.
4. De ce clasa abstractă este mai rapidă decât interfața?
O clasă abstractă este mai rapidă decât o interfață, deoarece interfața implică o căutare înainte de a apela orice metodă suprascrisă în Java, în timp ce clasa abstractă poate fi utilizată direct.
De asemenea, Citeste
- Diferența dintre clasa abstractă și interfața în Java
- Diferența dintre clasa abstractă și metodele abstracte
- Constructori în Java Abstract Class