In Java ist das Klasse ist ein Bauplan, aus dem wir ein individuelles Objekt erstellen können. Java bietet eine Stichwort benannte Klasse, mit der wir eine Klasse deklarieren können. Innerhalb der Klasse definieren wir Klasse Mitglieder und Funktionen. Es ist nicht möglich, etwas zu erstellen Java-Programme ohne Unterricht. Wir können eine Klasse auch als a bezeichnen benutzerdefinierte Arten von Klassen
In Java gibt es sieben Arten von Klassen:
Statische Klasse
Wir können einen Kurs machen statisch genau dann, wenn es sich um eine verschachtelte Klasse handelt. Wir können auch sagen, dass statische Klassen als verschachtelte Klassen bekannt sind. Das bedeutet, dass eine Klasse, die innerhalb einer anderen Klasse als statisch deklariert ist, als statische Klasse bezeichnet wird. Eine verschachtelte statische Klasse erfordert keinen Verweis auf die äußere Klasse. Der Zweck einer statischen Klasse besteht darin, den Umriss ihrer geerbten Klasse bereitzustellen.
Die Eigenschaften der statischen Klasse sind:
Softwaretests und -typen
- Die Klasse hat nur statische Mitglieder.
- Es kann nicht auf das (nicht statische) Mitglied der äußeren Klasse zugegriffen werden.
- Wir können kein Objekt der statischen Klasse erstellen.
Lassen Sie uns das Konzept der statischen Klasse anhand eines Programms verstehen.
StaticClassExample.java
public class StaticClassExample { private static String str = 'Javatpoint'; //nested class which is a Static class public static class StaticDemo { //non-static method of Static class public void show() { System.out.println(str); } } public static void main(String args[]) { StaticClassExample.StaticDemo obj = new StaticClassExample.StaticDemo(); obj.show(); } } Ausgabe:
Javatpoint
In der äußeren Klasse des obigen Programms haben wir eine Variable deklariert str als statisch, weil wir aus einem statischen Kontext auf diese Variable zugreifen. Wenn wir diese Variable als nicht statisch deklarieren, zeigt der Compiler einen Fehler an, weil Eine verschachtelte statische Klasse kann nicht auf nicht statische Mitglieder der äußeren Klasse zugreifen.
Das zweite, was im obigen Programm zu beachten ist, ist, dass wir zum Erstellen des Objekts der verschachtelten Klasse keine Instanz der äußeren Klasse erstellen müssen. Wenn die verschachtelte Klasse keine statische Klasse ist, müssen wir eine Instanz der äußeren Klasse erstellen.
Abschlussklasse
Das Wort final bedeutet, dass es nicht geändert werden kann. Der Finale Klasse in Java kann mit deklariert werden letztes Schlüsselwort . Sobald wir eine Klasse als final deklarieren, bleiben die Werte im gesamten Programm gleich. Der Zweck der Abschlussklasse besteht darin, die Klasse zu schaffen unveränderlich wie die String-Klasse. Dies ist nur eine Möglichkeit, die Klasse unveränderlich zu machen. Denken Sie daran, dass die Die Abschlussklasse kann nicht verlängert werden . Es auch verhindert, dass die Klasse in Unterklassen unterteilt wird .
Lassen Sie uns das Konzept der Abschlussklasse anhand eines Programms verstehen.
FinalClassExample.java
while-Schleife Java
//base class declared as final final class A { void printmsg() { System.out.print('Base class method is executed.'); } } //derived class //extending a final class which is not possible //it shows the error cannot inherit final class at compile time class B extends A { void printmsg() { System.out.print('Derived class method is executed.'); } } //main class public class FinalClassExample { public static void main(String[] arg) { B obj = new B(); obj.printmsg(); } } Ausgabe:
/FinalClassExample.java:11: error: cannot inherit from final A class B extends A
Abstrakte Klasse
Ein abstrakte Klasse ist ein, der mit dem Schlüsselwort deklariert wird abstrakt . Die Klasse kann abstrakte Methoden enthalten oder auch nicht. Wir können keine Instanz einer abstrakten Klasse erstellen, aber es kann eine Unterklasse sein. Diese Klassen sind unvollständig. Um die abstrakte Klasse zu vervollständigen, sollten wir die abstrakten Klassen zu einer konkreten Klasse erweitern. Wenn wir eine Unterklasse als abstrakt deklarieren, ist es notwendig, die Implementierung abstrakter Methoden bereitzustellen. Daher muss die Unterklasse auch als abstrakt deklariert werden. Mit der abstrakten Klasse können wir das Ausblenden von Daten erreichen. Ein Beispiel für eine abstrakte Klasse ist AbstarctMap Klasse, die Teil des Collections-Frameworks ist.
Lassen Sie uns das Konzept der abstrakten Klasse anhand eines Programms verstehen.
AbstractClassExample.java
//abstract class abstract class MathematicalOperations { int a=30, b=40; //abstract method public abstract void add(); } public class Operation extends MathematicalOperations { //definition of abstract method public void add() { System.out.println('Sum of a and b is: 'a+b); } public static void main(String args[]) { MathematicalOperations obj = new Operation(); obj.add(); } } Ausgabe:
Sum of a and b is: 70
Betonklasse
Dies sind die regulären Java-Klassen. Eine abgeleitete Klasse, die die grundlegenden Implementierungen für alle Methoden bereitstellt, die noch nicht in der Basisklasse implementiert sind, wird als a bezeichnet Beton Klasse. Mit anderen Worten handelt es sich um reguläre Java-Klassen, in denen alle Methoden einer abstrakten Klasse implementiert sind. Wir können direkt ein Objekt der konkreten Klasse erstellen. Denken Sie daran, dass konkrete und abstrakte Klassen nicht dasselbe sind. Eine konkrete Klasse kann ihre übergeordnete Klasse erweitern. Es wird für spezifische Anforderungen eingesetzt.
Lassen Sie uns das Konzept der konkreten Klasse anhand eines Programms verstehen.
ConcreteClassExample.java
//Concrete Class public class ConcreteClassExample { //method of the concreted class static int product(int a, int b) { return a * b; } public static void main(String args[]) { //method calling int p = product(6, 8); System.out.println('Product of a and b is: ' + p); } } Ausgabe:
Product of a and b is: 48
Singleton-Klasse
Eine Klasse, die jeweils nur ein Objekt enthält, wird als a bezeichnet Singleton-Klasse . Wenn wir jedoch versuchen, eine Instanz ein zweites Mal zu erstellen, verweist diese neu erstellte Instanz auf die erste Instanz. Wenn wir innerhalb der Klasse über eine beliebige Instanz eine Änderung vornehmen, wirkt sich die Änderung auch auf die Variable der einzelnen Instanz aus. Es wird normalerweise zur Zugriffskontrolle bei der Datenbankverbindung und der Socket-Programmierung verwendet. Wenn wir eine Singleton-Klasse erstellen möchten, gehen Sie wie folgt vor:
- Erstellen Sie eine private Konstrukteur .
- Erstellen Sie eine statische Methode (unter Verwendung der verzögerten Initialisierung), die das Objekt der Singleton-Klasse zurückgibt.
SingletonClassExample.java
public class Singleton { private String objectState; private static Singleton instance = null; private Singleton() throws Exception { this.objectState = 'Javatpoint'; } public static Singleton getInstance() { if(instance==null) { try { instance=new Singleton(); } catch(Exception e) { e.printStackTrace(); } } return instance; } public String getObjectState() { return objectState; } public void setObjectState(String objectState) { this.objectState = objectState; } } Ausgabe:
Javatpoint
POJO-Klasse
In Java steht POJO für Einfaches altes Java-Objekt. Eine Java-Klasse, die nur private Variablen, Setter und Getter enthält, wird als bezeichnet POJO Klasse. Es wird verwendet, um Java-Objekte zu definieren, die die Wiederverwendbarkeit und Lesbarkeit eines Java-Programms erhöhen. Die Klasse bietet Kapselung. Es wird in Java häufig verwendet, da diese Klassen leicht zu verstehen sind. Die POJO-Klasse hat die folgenden Eigenschaften:
- Die vordefinierten Klassen wie Arrays, HttpServlet usw. werden nicht erweitert.
- Es darf keine vorab festgelegten Anmerkungen enthalten.
- Es kann nicht vordefiniert implementiert werden Schnittstellen .
- Es ist nicht erforderlich, einen Konstruktor hinzuzufügen.
- Alle Instanzvariablen müssen privat sein.
- Der Getter/Setter Methoden muss öffentlich sein.
Lassen Sie uns das Konzept der POJO-Klasse anhand eines Java-Programms verstehen.
PojoClassExample.java
class PojoDemo { //private variable private double price=89764.34; //getter method public double getPrice() { return price; } //setter method public void setPrice(int price) { this.price = price; } } //main class public class PojoClassExample { public static void main(String args[]) { PojoDemo obj = new PojoDemo(); System.out.println('The price of an article is '+ obj.getPrice()+' Rs.'); } } Ausgabe:
Schriftart-Gimp
The price of an article is 89764.34 Rs.
Innere Klasse
Java ermöglicht es uns, eine Klasse innerhalb einer Klasse zu definieren. Solche Klassen werden als bezeichnet verschachtelte Klassen . Es dient dazu, die Klassen logisch zu gruppieren und zu erreichen Verkapselung . Auf die äußeren Klassenmitglieder (einschließlich private) kann von zugegriffen werden innere Klasse . Die allgemeine Syntax zum Deklarieren der verschachtelten Klasse lautet wie folgt:
class OuterClass { //code class NestedClass { //code } } Es gibt zwei Arten von verschachtelten Klassen:
1. Statische verschachtelte Klasse: Eine Klasse also statisch Und verschachtelt wird als statisch verschachtelte Klasse bezeichnet. Es interagiert mit dem Instanzmitglied seiner äußeren Klasse. Mit der folgenden Syntax können wir ein Objekt der statischen verschachtelten Klasse erstellen:
OuterClass.StaticNestedClass nestedObject = new OuterClass.StaticNestedClass();
2. Nicht statische verschachtelte Klasse: Es werden nicht statische verschachtelte Klassen aufgerufen innere Klassen .
Die allgemeine Syntax zum Deklarieren der statischen verschachtelten Klasse und der inneren Klasse lautet wie folgt:
class OuterClass { ... static class StaticNestedClass { ... } class InnerClass { ... } } Lassen Sie uns das Konzept der inneren Klasse anhand eines Java-Programms verstehen.
InnerClassExample.java
public class InnerClassExample { public static void main(String[] args) { System.out.println('This is outer class.'); } class InnerClass { public void printinner() { System.out.println('This is inner class.'); } } } Arten innerer Klassen
Java stellt die beiden Arten innerer Klassen bereit:
Dereferenzierungszeiger
- Lokale Klassen oder Methode Lokale innere Klasse
- Anonyme Klassen oder Anonyme innere Klasse
Lokale innere Klasse
Es handelt sich um eine Art innere Klasse, die innerhalb eines Blocks definiert wird. Hier bezeichnet Block einen Methodenkörper (eine Gruppe von Anweisungen, die in zwei geschweifte Klammern eingeschlossen sind). Aufgrund der Definition innerhalb eines Blocks wird sie auch als lokale innere Klasse der Methode bezeichnet. Dies sind die nicht statischen Klassen, da sie auf die Instanzmitglieder des Blocks zugreifen können. Wir können die lokalen inneren Klassen im Hauptteil einer Methode definieren. Diese Klassen müssen in dem Block instanziiert werden, in dem sie definiert sind.
Wenn wir ein Java-Programm kompilieren (ein Programm, das eine innere Klasse enthält), generiert der Compiler nämlich die beiden Klassendateien Äußere.Klasse Und OuterInner.class. Eine für die äußere Klasse und die andere für die innere Klasse, die einen Verweis auf die äußere Klasse enthält.
Lassen Sie uns das Konzept einer lokalen inneren Klasse anhand eines Java-Programms verstehen.
OuterClass.java
public class OuterClass { private void getValue() { //if you are using Java 7 make the variable final //if you are using Java 8 the code runs successfully int sum = 20; //declaring method local inner class class InnerClass { public int divisor; public int remainder; public InnerClass() { divisor = 4; remainder = sum%divisor; } private int getDivisor() { return divisor; } private int getRemainder() { return sum%divisor; } private int getQuotient() { System.out.println('We are inside the inner class'); return sum / divisor; } } //creating an instance of inner class InnerClass ic = new InnerClass(); System.out.println('Divisor = '+ ic.getDivisor()); System.out.println('Remainder = ' + ic.getRemainder()); System.out.println('Quotient = ' + ic.getQuotient()); } public static void main(String[] args) { //creating an instance of outer class OuterClass oc = new OuterClass(); oc.getValue(); } } Ausgabe:
Divisor = 4 Remainder = 0 We are inside the inner class Quotient = 5
Anonyme innere Klasse
Es handelt sich um eine Art innerer Klasse, die mit lokalen Klassen identisch ist. Der einzige Unterschied besteht jedoch darin, dass die Klasse keinen Klassennamen hat und aus der Klasse ein einzelnes Objekt erstellt wird. Dadurch wird der Code prägnanter. Es wird verwendet, wenn wir die lokale Klasse einmal verwenden möchten. Wir können anonyme Klassen auf die folgenden zwei Arten erstellen:
- Durch die Nutzung einer Schnittstelle
- Indem man die Klasse für konkret und abstrakt erklärt
Syntax:
// the class may an interface, abstract or concrete class DemoClass obj = new DemoClass() { //methods //data members public void demomethod() { //statements } }; Wenn wir uns die obige Syntax ansehen, sehen wir, dass sie mit dem Aufruf des Konstruktors identisch ist, außer dass die Klasse eine im Block enthaltene Definition hat.
AnonymousClassExample.java
interface Score { int run = 321; void getScore(); } public class AnonymousClassExample { public static void main(String[] args) { // Myclass is hidden inner class of Score interface // whose name is not written but an object to it // is created. Score s = new Score() { @Override public void getScore() { //prints score System.out.print('Score is '+run); } }; s.getScore(); } } Ausgabe:
Was ist Autowired in Java?
Score is 321
Java bietet auch eine andere Art von Java-Klasse, die sogenannte Wrapper-Klasse. Lassen Sie uns das im Detail besprechen.
Wrapper-Klasse
In Java der Begriff Wrapper-Klasse stellt eine Sammlung von Java-Klassen dar, die den primitiven Typ von Java objektivieren. Das bedeutet, dass es für jeden primitiven Typ eine entsprechende Wrapper-Klasse gibt. Die Wrapper-Klassen werden verwendet, um die Konvertierung von einem primitiven Typ in ein Objekt und umgekehrt durchzuführen. Die folgende Abbildung zeigt die Wrapper-Klassenhierarchie.
Die folgende Tabelle stellt den primitiven Typ und die entsprechende Wrapper-Klasse dar.
| Primitiver Typ | Wrapper-Klasse |
|---|---|
| Boolescher Wert | Boolescher Wert |
| int | Ganze Zahl |
| verkohlen | Charakter |
| doppelt | Doppelt |
| schweben | Schweben |
| lang | Lang |
| Byte | Byte |
| kurz | Kurz |
Lassen Sie uns die Wrapper-Klasse anhand eines Java-Programms verstehen.
WrapperClassExample.java
public class WrapperClassExample { public static void main(String args[]) { byte x = 0; //wrapping byte primitive type into Byte object Byte byteobj = new Byte(x); int y = 23; //wrapping int primitive type into Integer object Integer intobj = new Integer(y); char c='m'; //wrapping char primitive type into Character object Character charobj=c; //printing values from objects System.out.println('Byte object byteobj: ' + byteobj); System.out.println('Integer object intobj: ' + intobj); System.out.println('Character object charobj: ' + charobj); } } Ausgabe:
Byte object byteobj: 0 Integer object intobj: 23 Character object charobj: m