In Java wordt de abstracte klasse gedeclareerd met het abstracte trefwoord. Het kan zowel abstracte als niet-abstracte methoden hebben (methoden met lichamen). Een abstract is een Java-modifier die van toepassing is op klassen en methoden in Java, maar niet voor variabelen . In dit artikel zullen we het gebruik van abstracte klassen in Java leren.
Wat is abstracte klasse in Java?
De abstracte Java-klasse is een klasse die niet op zichzelf kan worden geïnitieerd; deze moet door een andere klasse worden onderverdeeld om de eigenschappen ervan te kunnen gebruiken. Een abstracte klasse wordt gedeclareerd met behulp van het abstracte sleutelwoord in de klassendefinitie.
Illustratie van abstracte klasse
abstract class Shape { int color; // An abstract function abstract void draw(); }> Op Java de volgende belangrijke observaties over abstracte klassen zijn als volgt:
- Er kan geen exemplaar van een abstracte klasse worden gemaakt.
- Constructeurs zijn toegestaan.
- We kunnen een abstracte klasse hebben zonder enige abstracte methode.
- Er kan sprake zijn van een uiteindelijke methode in abstracte klasse, maar elke abstracte methode in klasse (abstracte klasse) kan niet als definitief worden verklaard of, in eenvoudiger bewoordingen, de uiteindelijke methode kan zelf niet abstract zijn, omdat dit een fout zal opleveren: Illegale combinatie van modificatoren: abstract en definitief
- We kunnen statische methoden definiëren in een abstracte klasse
- Wij kunnen gebruik maken van de abstract trefwoord voor het declareren klassen op het hoogste niveau (buitenklasse) en binnenklassen als abstract
- Als een klas bevat tenminste één abstracte methode dan moet verplicht een klasse als abstract worden verklaard
- Als de Kind klasse is niet in staat om implementatie te bieden aan alle abstracte methoden van de Ouderklas dan moeten we dat bekend maken Kindklasse als abstract zodat de Child-klasse van het volgende niveau de implementatie van de resterende abstracte methode zou moeten bieden
Voorbeelden van Java Abstract-klasse
1. Voorbeeld van een abstracte klasse met een abstracte methode
Hieronder vindt u de implementatie van het bovenstaande onderwerp:
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();> >}> }> |
>
>Uitvoer
avinash 21 222.2>
2. Samenvatting Klasse met constructor, gegevenslid en methoden
Elementen die abstracte klasse kan hebben
- gegevens lid
- abstracte methode
- methode body (niet-abstracte methode)
- bouwer
- main() methode.
Hieronder vindt u de implementatie van het bovenstaande onderwerp:
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();> >}> }> |
>
>Uitvoer
Learning Subject C , Java , C++ Preparing Right Now!>
Eigenschappen van de abstracte klasse
Laten we deze observaties nader toelichten en ze als volgt rechtvaardigen met behulp van schone Java-programma's.
Observatie 1
In Java kan, net als in C++, geen instantie van een abstracte klasse worden gemaakt, maar we kunnen wel verwijzingen naar het abstracte klassetype hebben. Het is zoals hieronder weergegeven via het schone Java-programma.
Voorbeeld
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();> >}> }> |
>
>Uitvoer
geïnstantieerde Java
Derived fun() called>
Observatie 2
Zoals C++, een abstracte klasse kan bevatten constructeurs op Java. En een constructor van een abstracte klasse wordt aangeroepen wanneer een instantie van een overgeërfde klasse wordt gemaakt. Het is zoals weergegeven in het onderstaande programma als volgt:
Voorbeeld:
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();> >}> }> |
>
>Uitvoer
Base Constructor Called Derived Constructor Called Derived fun() called>
Observatie 3
Op Java kunnen we dat hebben een abstracte klasse zonder enige abstracte methode . Dit stelt ons in staat maak klassen die niet kunnen worden geïnstantieerd, maar alleen kunnen worden geërfd . Het is zoals hieronder weergegeven als volgt met behulp van een schoon Java-programma.
Voorbeeld:
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();> >}> }> |
>
>Uitvoer
Function of Base class is called>
Observatie 4
Er kunnen ook abstracte klassen zijn laatste methoden (methoden die niet kunnen worden overschreven)
Voorbeeld:
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();> >}> >}> }> |
>
>Uitvoer
Base fun() called>
Observatie 5
Voor elke abstracte Java-klasse mogen we geen object maken, dat wil zeggen dat voor een abstracte klasse instantiatie niet mogelijk is.
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();> >}> }> |
>
>
Uitgang:
zoek in tekenreeks c++
Observatie 6
Vergelijkbaar met de interface we kunnen statische methoden definiëren in een abstracte klasse Dat kan onafhankelijk worden opgeroepen zonder object.
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();> >}> }> |
>
>Uitvoer
Geeks for Geeks>
Observatie 7
Wij kunnen gebruik maken van de abstract trefwoord voor het verklaren van klassen op het hoogste niveau (buitenklasse) en binnenklassen als abstract
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();> >}> }> |
>
>Uitvoer
Inside abstract method implementation>
Observatie 8
Als een klasse bevat ten minste één abstracte methode Dan verplicht dat we de klasse als abstract verklaren anders krijgen we een compileerfout. Als een klasse ten minste één abstracte methode bevat, is de implementatie voor die klasse niet voltooid, en daarom wordt het niet aanbevolen om een object te maken, om het maken van objecten voor dergelijke gedeeltelijke klassen te beperken we gebruiken abstract trefwoord.
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();> >}> }> |
>
>Uitvoer
Hello>
Observatie 9
Als de Kind klasse niet in staat is om implementatie te bieden voor alle abstracte methoden van de klasse Parent, dan moeten we die klasse Child als abstract declareren, zodat de klasse Child op het volgende niveau implementatie moet bieden voor de resterende abstracte methode.
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();> >}> }> |
>
>Uitvoer
Inside m1 Inside m2 Inside m3>
In C++, als een klasse er minstens één heeft puur virtuele functie , dan wordt de klasse abstract. In tegenstelling tot C++ wordt in Java een afzonderlijk trefwoordsamenvatting gebruikt om een klassesamenvatting te maken.
Conclusie
Punten om te onthouden uit dit artikel worden hieronder vermeld:
- Een abstracte klasse is een klasse die niet op zichzelf kan worden geïnitieerd; deze moet door een andere klasse worden onderverdeeld om de eigenschappen ervan te kunnen gebruiken.
- Er kan een abstracte klasse worden gemaakt met behulp van abstracte trefwoorden.
- We kunnen een abstracte klasse hebben zonder enige abstracte methode.
Veelgestelde vragen over de abstracte les
1. Wat is een abstracte klasse in Java?
Een abstracte klasse in Java is een klasse die niet op zichzelf kan worden geïnitieerd, maar die als subklasse door een andere klasse kan worden gebruikt.
2. Wat is het abstracte doel van de les?
Het belangrijkste doel van de abstracte klasse is het creëren van een basisklasse waaruit vele andere klassen kunnen worden afgeleid.
3. Wat is het belangrijkste voordeel van abstracte klasse?
Een abstracte klasse biedt de mogelijkheid om gegevens te verbergen in Java.
4. Waarom is abstracte klasse sneller dan interface?
Een abstracte klasse is sneller dan een interface omdat de interface een zoekopdracht omvat voordat een overschreven methode in Java wordt aangeroepen, terwijl abstracte klasse direct kan worden gebruikt.
Lees ook
- Verschil tussen abstracte klasse en interface in Java
- Verschil tussen abstracte klasse en abstracte methoden
- Constructeurs in Java Abstract Class