In Java wird eine abstrakte Klasse mit dem Schlüsselwort abstract deklariert. Es kann sowohl abstrakte als auch nicht abstrakte Methoden (Methoden mit Körpern) haben. Ein Abstract ist ein Java-Modifikator, der auf Klassen und Methoden in Java anwendbar ist nicht für Variablen . In diesem Artikel lernen wir die Verwendung abstrakter Klassen in Java kennen.
Was ist eine abstrakte Klasse in Java?
Die abstrakte Java-Klasse ist eine Klasse, die nicht von sich selbst initiiert werden kann. Sie muss von einer anderen Klasse untergeordnet werden, um ihre Eigenschaften nutzen zu können. Eine abstrakte Klasse wird mit dem Schlüsselwort abstract in ihrer Klassendefinition deklariert.
Illustration der abstrakten Klasse
abstract class Shape { int color; // An abstract function abstract void draw(); }> In Java sind die folgenden einige wichtige Beobachtungen Über abstrakte Klassen lauten wie folgt:
- Eine Instanz einer abstrakten Klasse kann nicht erstellt werden.
- Konstrukteure sind erlaubt.
- Wir können eine abstrakte Klasse ohne abstrakte Methode haben.
- Es kann eine geben endgültige Methode in der abstrakten Klasse, aber jede abstrakte Methode in der Klasse (abstrakte Klasse) kann nicht als final deklariert werden, oder, einfacher ausgedrückt, die finale Methode kann selbst nicht abstrakt sein, da sie einen Fehler ergibt: Unzulässige Kombination von Modifikatoren: abstrakt und final
- Wir können statische Methoden in einer abstrakten Klasse definieren
- Wir können das nutzen abstraktes Schlüsselwort für die Erklärung Klassen der obersten Ebene (äußere Klasse) sowie innere Klassen als abstrakt
- Wenn ein Klasse enthält mindestens eine abstrakte Methode dann sollte obligatorisch eine Klasse als abstrakt deklariert werden
- Wenn die Kinderklasse ist nicht in der Lage, alle abstrakten Methoden von zu implementieren Elternklasse dann sollten wir das erklären Untergeordnete Klasse als Zusammenfassung sodass die untergeordnete Klasse der nächsten Ebene die Implementierung der verbleibenden abstrakten Methode bereitstellen sollte
Beispiele für die abstrakte Java-Klasse
1. Beispiel einer abstrakten Klasse mit der abstrakten Methode
Nachfolgend finden Sie die Umsetzung des oben genannten Themas:
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();> >}> }> |
>
>Ausgabe
avinash 21 222.2>
2. Abstrakte Klasse mit Konstruktor, Datenelement und Methoden
Elemente, die eine abstrakte Klasse haben kann
- Datenelement
- abstrakte Methode
- Methodenkörper (nicht abstrakte Methode)
- Konstrukteur
- main()-Methode.
Nachfolgend finden Sie die Umsetzung des oben genannten Themas:
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();> >}> }> |
>
>Ausgabe
Learning Subject C , Java , C++ Preparing Right Now!>
Eigenschaften der Abstract-Klasse
Lassen Sie uns diese Beobachtungen näher erläutern und sie mit Hilfe sauberer Java-Programme wie folgt begründen.
Beobachtung 1
In Java kann, genau wie in C++, keine Instanz einer abstrakten Klasse erstellt werden, wir können jedoch Verweise auf den Typ einer abstrakten Klasse haben. Es ist wie unten gezeigt über das saubere Java-Programm.
Beispiel
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();> >}> }> |
>
>Ausgabe
spitzer Winkel
Derived fun() called>
Beobachtung 2
Wie C++, ein abstrakte Klasse enthalten kann Konstrukteure in Java. Und ein Konstruktor einer abstrakten Klasse wird aufgerufen, wenn eine Instanz einer geerbten Klasse erstellt wird. Im folgenden Programm ist es wie folgt dargestellt:
Beispiel:
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();> >}> }> |
>
>Ausgabe
Base Constructor Called Derived Constructor Called Derived fun() called>
Beobachtung 3
In Java können wir haben eine abstrakte Klasse ohne abstrakte Methode . Das ermöglicht es uns Erstellen Sie Klassen, die nicht instanziiert, sondern nur vererbt werden können . Mit Hilfe eines sauberen Java-Programms sieht es wie folgt aus.
Beispiel:
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();> >}> }> |
>
>Ausgabe
Function of Base class is called>
Beobachtung 4
Abstrakte Klassen können auch haben Finale Methoden (Methoden, die nicht überschrieben werden können)
Beispiel:
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();> >}> >}> }> |
>
>Ausgabe
Base fun() called>
Beobachtung 5
Für jede abstrakte Java-Klasse dürfen wir kein Objekt erstellen, d. h. für eine abstrakte Klasse ist keine Instanziierung möglich.
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();> >}> }> |
>
>
Ausgabe:
Beobachtung 6
Ähnlich der Schnittstelle Wir können statische Methoden in einer abstrakten Klasse definieren Das kann unabhängig ohne Objekt aufgerufen werden.
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();> >}> }> |
>
>Ausgabe
Geeks for Geeks>
Beobachtung 7
Wir können das nutzen abstraktes Schlüsselwort zum Deklarieren von Klassen der obersten Ebene (äußere Klasse) sowie inneren Klassen als abstrakt
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();> >}> }> |
>
>Ausgabe
Inside abstract method implementation>
Beobachtung 8
Wenn ein Die Klasse enthält mindestens eine abstrakte Methode Dann Es ist zwingend erforderlich, dass wir die Klasse als abstrakt deklarieren Andernfalls erhalten wir einen Fehler bei der Kompilierung. Wenn eine Klasse mindestens eine abstrakte Methode enthält, ist die Implementierung für diese Klasse nicht vollständig. Daher wird nicht empfohlen, ein Objekt zu erstellen, um die Objekterstellung für solche Teilklassen einzuschränken wir gebrauchen abstraktes Schlüsselwort.
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();> >}> }> |
>
>Ausgabe
Hello>
Beobachtung 9
Wenn die Kind Wenn die Klasse nicht in der Lage ist, alle abstrakten Methoden der übergeordneten Klasse zu implementieren, sollten wir diese untergeordnete Klasse als abstrakt deklarieren, sodass die untergeordnete Klasse der nächsten Ebene die Implementierung für die verbleibende abstrakte Methode bereitstellen sollte.
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();> >}> }> |
schwebendes CSS
>
>Ausgabe
Inside m1 Inside m2 Inside m3>
In C++, wenn eine Klasse mindestens eine hat rein virtuelle Funktion , dann wird die Klasse abstrakt. Im Gegensatz zu C++ wird in Java ein separates Schlüsselwort abstract verwendet, um eine Klasse abstrakt zu machen.
Abschluss
Nachfolgend sind die Punkte aufgeführt, die Sie in diesem Artikel beachten sollten:
- Eine abstrakte Klasse ist eine Klasse, die nicht von sich selbst initiiert werden kann. Sie muss von einer anderen Klasse untergeordnet werden, um ihre Eigenschaften nutzen zu können.
- Eine abstrakte Klasse kann mithilfe abstrakter Schlüsselwörter erstellt werden.
- Wir können eine abstrakte Klasse ohne abstrakte Methode haben.
FAQs zum Abstract-Kurs
1. Was ist eine abstrakte Klasse in Java?
Eine abstrakte Klasse in Java ist eine Klasse, die nicht alleine initiiert werden kann, sondern von einer anderen Klasse als Unterklasse verwendet werden kann.
2. Was ist der Zweck der abstrakten Klasse?
Der Hauptzweck der abstrakten Klasse besteht darin, eine Basisklasse zu erstellen, von der viele andere Klassen abgeleitet werden können.
3. Was ist der Hauptvorteil der abstrakten Klasse?
Eine abstrakte Klasse bietet die Möglichkeit, Daten in Java zu verbergen.
4. Warum ist eine abstrakte Klasse schneller als eine Schnittstelle?
Eine abstrakte Klasse ist schneller als eine Schnittstelle, da die Schnittstelle eine Suche vor dem Aufruf einer überschriebenen Methode in Java erfordert, wohingegen eine abstrakte Klasse direkt verwendet werden kann.
Lesen Sie auch
- Unterschied zwischen abstrakter Klasse und Schnittstelle in Java
- Unterschied zwischen abstrakter Klasse und abstrakten Methoden
- Konstruktoren in der Java Abstract Class