types classes java
In diesem Tutorial werden verschiedene Arten von Klassen in Java wie Abstract, Concrete, Final, Inner, POJO, Static und andere spezielle Klassen anhand von Beispielen erläutert:
In unserem vorherigen Tutorial haben wir Klassen und Objekte in Java besprochen. Eine Klasse in Java ist eine Vorlage oder ein Entwurf. Es kann auch als Sammlung ähnlicher Objekte definiert werden. Wir definieren Objekte der Typklasse und kommunizieren dann über diese Objekte.
Jedes Objekt ist eine Instanz einer Klasse, die einen Status und ein Verhalten hat.
=> Besuchen Sie hier für die exklusive Java Training Tutorial-Reihe.
Was du lernen wirst:
Klassentypen in Java - Einführung
Wir alle wissen, dass die Klasse die folgenden Komponenten hat:
- Modifikatoren: Geben Sie den Zugriff für die Klasse an.
- Klassenname: Name der Klasse.
- Schlüsselwörter: Schlüsselwörter, die angeben, ob eine Klasse eine Klasse oder Schnittstelle erweitert oder implementiert.
- Die Klasse Body in geschweiften Klammern {}
Abhängig von den verschiedenen verwendeten Modifikatoren, dem angegebenen Klassenkörper und den verwendeten Schlüsselwörtern gibt es in Java verschiedene Arten von Klassen.
So teilen Sie eine Zeichenfolge in Python nach Zeichen
- Konkrete Klasse: Eine normale Klasse mit konkreter Implementierung von Methoden.
- POJO-Klasse: Dies ist ein 'einfaches altes Java-Objekt', das nur private Mitgliedsvariablen und Getter-Setter-Methoden für den Zugriff auf diese Variablen enthält.
- Abstrakte Klasse: Diese Klasse verfügt über eine oder mehrere abstrakte Methoden.
- Abschlussklasse: Eine letzte Klasse kann nicht vererbt werden.
- Statische Klasse: Eine Klasse, die nur statische Elemente enthält.
- Innere Klasse: Eine innere Klasse ist eine Klasse, die Mitglied einer anderen Klasse ist.
In diesem Tutorial werden wir jeden dieser Klassentypen anhand von Beispielen diskutieren.
Wir werden auch einige andere Arten von Klassen diskutieren, die in Java als spezielle Klassen gelten.
- Anonyme Klasse: Eine Klasse ohne Namen.
- Unveränderliche Klasse: Eine Klasse, deren Objekt nicht geändert werden kann.
- Singleton-Klasse: Eine Klasse, deren einzelne Instanz erstellt werden kann.
- Objektklasse: Die Basisklasse aller Java-Funktionen.
- Wrapper-Klasse: Jeder primitive Datentyp in Java hat eine Wrapper-Klasse.
Lassen Sie uns zunächst kurz erläutern, wie eine Klasse in Java zusammen mit der Hauptklasse in Java importiert wird, die die Hauptmethode oder den Startpunkt in Java enthält.
In Java importieren
Wenn wir in Java Features oder Funktionen in unser Programm aufnehmen möchten, können wir die Anweisung 'import' verwenden. Mit der import-Anweisung können wir ein gesamtes Paket importieren und dessen Funktionalität in unserem Programm verwenden, oder wir können auch eine einzelne Klasse einschließen.
Unten ist die Syntax für die Importanweisung angegeben.
import packageName/classname; Wenn wir das Paket java.lang und alle seine Klassen importieren möchten, können wir die folgende Anweisung schreiben:
import java.lang.*; Angenommen, wir möchten die Funktionalität der Arrays-Klasse in unser Programm aufnehmen, dann können wir die folgende Anweisung schreiben:
import java.util.Arrays; Die import-Anweisung entspricht der C / C ++ include-Anweisung. Die import-Anweisung wird als erste Anweisung am Anfang des Java-Programms platziert. Wir können mehr als eine Anweisung im Java-Programm haben.
Hauptklasse In Java
Wir wissen bereits, dass in Java die main () -Methode der Ausgangspunkt jeder Programmausführung ist und in jede Klasse dieser bestimmten Anwendung eingefügt werden kann. Wenn wir jedoch eine komplexe Anwendung mit zu vielen Dateien und Klassen haben, ist es ratsam, eine Hauptklasse zu haben und die main () -Methode in diese Hauptklasse einzufügen.
class Main{ public static void main(String() args){ System.out.println(“Hello, World!”); } } Beachten Sie, dass die JVM kein Objekt der Klasse Main erstellt. Die Logik dahinter ist, dass main () eine statische Methode ist und ohne Klassenobjekt aufgerufen werden kann.
Arten von Klassen in Java
Kommen wir nun zu den Klassentypen in Java. Wir werden jede dieser Klassen einzeln erklären, gefolgt von den Programmierbeispielen.
# 1) Betonklasse
Eine konkrete Klasse ist eine normale Klasse in einem Java-Programm. Diese Klasse hat keine abstrakten Methoden. Alle Methoden in der konkreten Klasse sind vollständig implementiert.
Eine konkrete Klasse kann von einer anderen Klasse, sogar einer abstrakten Klasse, erben oder eine Schnittstelle implementieren. Wir können die konkrete Klasse instanziieren und ihre Objekte erstellen.
Ein einfaches Beispiel für eine konkrete Klasse ist unten dargestellt.
public class Main { // Concrete Class example static int total(int val1, int val2) { return val1 + val2; } public static void main(String args()) { int sum = total(100, 108); System.out.println('Total of two integers: ' + sum); } } Ausgabe
Das obige Programm zeigt eine konkrete Klasse. Wir sehen, dass diese Klasse eine vollständige Implementierung hat. Es ist nichts unvollständig oder nicht implementiert.
# 2) POJO-Klasse
Ein POJO (Plain Old Java Object) ist eine Klasse, die nur private Mitgliedsvariablen enthält. Abgesehen von den privaten Mitgliedsvariablen enthält es nur Getter- und Setter-Methoden, die von diesen Mitgliedsvariablen verwendet werden.
Eine POJO-Klasse hat kein Verhalten. Es kann jedoch einige Methoden wie Gleichheit oder Schnittstellen überschreiben.
Eigenschaften der POJO-Klasse:
- Die POJO-Klasse muss über eine öffentliche Getter- und Setter-Methode verfügen.
- Alle Mitglieder oder Instanzvariablen sollten privat sein.
- Die POJO-Klasse erweitert oder implementiert keine vordefinierten Klassen oder Schnittstellen.
- Sie enthalten keine vordefinierten Anmerkungen.
- Hat keinen Konstruktor ohne Argumente (Konstruktor ohne Argumente).
Im Folgenden finden Sie ein Java-Programm, das die POJO-Klasse demonstriert.
//declare a POJO class class POJO_Class { private int daysOfWeek=7; //private variable public int getdaysOfWeek() { //getter return daysOfWeek; } public void setdaysOfWeek(int dow) { //setter this.daysOfWeek = dow; } } public class Main { public static void main(String args()){ POJO_Class pojoDemo = new POJO_Class(); //instance of POJO class System.out.println('Days of the week:' + pojoDemo.getdaysOfWeek()); } } Ausgabe
Die obige Demonstration der POJO-Klasse zeigt, dass sie eine private Variable und die Getter-Setter-Methoden für diese Variable hat. Um auf diese Mitgliedsvariable zuzugreifen, verwenden wir die Getter-Methode. Die Setter-Methode wird verwendet, um den Wert zu aktualisieren.
# 3) Abstrakte Klasse
Eine abstrakte Klasse ist eine Klasse, die unvollständig ist oder deren Implementierung nicht abgeschlossen ist. Eine abstrakte Klasse kann nicht instanziiert werden. Es muss um die anderen Klassen erweitert werden und seine Methoden implementieren, um eine konkrete Klasse zu bilden.
Eine abstrakte Klasse wird mit dem Schlüsselwort 'abstract' deklariert. Eine abstrakte Klasse kann statische und endgültige Methoden sowie Konstruktoren haben.
Lassen Sie uns eine abstrakte Klasse in Java demonstrieren.
interface multiply //interface multiply { int product(int num1, int num2); } // abstract class abstract class Product implements multiply { // this is an abstract method to calculate product of two numbers public abstract int product(int num1, int num2); } // Concrete class :this will implement the abstract method above class Main extends Product { public int product(int num1, int num2) { return num1*num2; } // main method public static void main(String args()) { Main obj = new Main(); int prod = obj.product(100, 20); // print product System.out.println('Product of two numbers: ' + prod); } }Ausgabe
Im obigen Programm haben wir eine Schnittstelle multiplizieren. Wir erstellen eine abstrakte Klasse Product, die eine Multiplikationsschnittstelle implementiert. Innerhalb des Produkts haben wir ein Methodenprodukt, das nicht implementiert ist. Dann haben wir eine Hauptklasse, die die Produktklasse erbt und die Produktmethode implementiert. Später rufen wir diese Methode für das Hauptklassenobjekt auf.
# 4) Statische Klasse
Eine statische Aufladung in Java bedeutet im Allgemeinen das Objekt, das zu einer Klasse und nicht zu den einzelnen Instanzen gehört. Auf ein statisches Element oder eine statische Methode in Java muss also nicht mit einem Objekt zugegriffen werden, sondern direkt mit einem Klassennamen.
Eine statische Klasse in Java kann nur statische Elemente enthalten. Wir können auch keine statische Klasse instanziieren.
Das folgende Java-Programm demonstriert eine statische Klasse.
class Static_Class { static int total; // static variable static void sum(int val1, int val2) { // static method System.out.print('Static method to calculate sum:' + ' '); total = val1 + val2; System.out.println(val1 + '+' + val2); // print the numbers } static class Nested_Class { // static class static { // static block System.out.println('static block inside a static nested class'); } public void displaySum() { sum(25, 75); // call static method // print the value in static variable total, it holds the sum of two numbers System.out.println('Sum of two numbers:' + total); } } } public class Main { public static void main(String args()) { // declare static class object Static_Class.Nested_Class object = new Static_Class.Nested_Class(); object.displaySum(); // call displaySum method inside a static class } } Ausgabe
Die obige Klasse demonstriert die statische Klasse. Hier haben wir eine statische Klasse, die Mitglied einer anderen konkreten Klasse ist. Innerhalb der statischen Klasse berechnen wir die Summe zweier Zahlen und speichern das Ergebnis in einer statischen Variablen, die Mitglied der äußeren Klasse ist.
# 5) Abschlussklasse
Eine letzte Klasse ist eine Klasse, die nicht vererbt oder in Unterklassen eingeteilt werden kann. Sobald eine Klasse in Java als endgültig deklariert wurde, ist sie eine Art Konstante und wird unveränderlich.
Um eine Klasse unveränderlich zu machen, müssen wir sie als endgültig deklarieren.
//final class final class Base_Class { void Display() { System.out.println('Base_Class::Display()'); } } //class Derived_Class extends Base_Class { //Compile-time error - can't inherit final class class Derived_Class{ void Display() { System.out.println('Derived_Class::Display()'); } } public class Main { public static void main(String() arg) { Base_Class base_obj = new Base_Class(); //create a final class object base_obj.Display(); Derived_Class deri_obj = new Derived_Class(); deri_obj.Display(); } } Ausgabe
Das obige Programm deklariert zuerst eine Base_Class, die als 'final' markiert ist. Wenn wir versuchen, es in Derived_Class zu erweitern, erhalten wir daher einen Compilerfehler. (Die kommentierte Zeile). Wir können jedoch das Objekt erstellen und die Display-Methode aufrufen.
# 6) Verschachtelte Klasse / Innere Klasse
Verschachtelte Klasse, in Java auch als innere Klasse bezeichnet, wird verwendet, um die Kapselung zu verbessern. Eine verschachtelte Klasse / innere Klasse ist eine Klasse, die in einer anderen Klasse eingeschlossen ist.
So wie eine Klasse Variablen und Methoden als Mitglieder hat, kann sie auch eine innere Klasse als Mitglied haben.
Eine verschachtelte Klasse hat die folgende Struktur:
class OuterClass{ class NestedClass{ //nested class code… } //outerclass code… } Innere Klassen haben die folgenden Untertypen:
- Verschachtelte innere Klasse
- Methode Lokale innere Klasse
- Anonyme innere Klasse
- Statisch verschachtelte Klasse
# 1) Verschachtelte innere Klasse
Eine verschachtelte innere Klasse hat Zugriff auf private Mitgliedsvariablen einer äußeren Klasse. Wir können Zugriffsmodifikatoren auch auf die verschachtelte innere Klasse anwenden.
# 2) Methode Lokale innere Klasse
Dies ist die innere Klasse, die innerhalb einer Methode der äußeren Klasse deklariert wird.
# 3) Anonyme innere Klasse
Anonyme innere Klasse ist eine innere Klasse, die innerhalb einer äußeren Klasse deklariert ist und keinen Namen hat.
# 4) Statisch verschachtelte Klasse
Implementieren Sie die Prioritätswarteschlange c ++
So wie eine Klasse eine statische Mitgliedsvariable hat, kann sie auch eine statische Klasse als Mitglied haben.
Ein Beispiel für eine verschachtelte / innere Klasse ist unten angegeben:
public class Main { //nested/inner class enclosed inside Main class. class InnerClass { public void inner_print() { System.out.println('Inner class'); } } public static void main(String() args) { System.out.println('Main in Outer class'); } } Ausgabe
Andere spezielle Klassen in Java
Unveränderliche Klasse in Java
Eine unveränderliche Klasse generiert unveränderliche Objekte. Ein unveränderliches Objekt ist ein Objekt, dessen Inhalt nach dem Erstellen des Objekts nicht mehr geändert werden kann. Eine unveränderliche Klasse ist also diejenige, deren Objekt nach dem Erstellen nicht mehr geändert werden kann.
Alle Wrapper-Klassen in Java für primitive Typen (Integer, Boolean, Byte usw.) sind unveränderlich. Die String-Klasse ist ebenfalls unveränderlich.
Wir können auch benutzerdefinierte unveränderliche Klassen in Java haben.
Damit eine Klasse unveränderlich ist, muss sie zusammen mit allen Datenelementen als endgültig deklariert werden. Außerdem sollte die Klasse einen parametrisierten Konstruktor haben. Alle Mitgliedsvariablen sollten eine Getter-Methode haben, aber keine Setter-Methode.
Alle oben genannten Anforderungen müssen erfüllt sein, damit eine Klasse unveränderlich ist.
Implementieren wir ein Java-Programm, um die unveränderliche Klasse zu demonstrieren.
final class City { final String city_name; final int cityId; //parameterised constructor public City(String name, int id) { this.city_name = name; this.cityId = id; } //getters for member variables public String getcityName() { return city_name; } public int getcityId() { return cityId; } } // Driver class class Main { public static void main(String args()) { City city = new City('New York', 1001); System.out.print('City Id:' + city.getcityId() + ' '); System.out.println('City Name:' + city.getcityName()); //city.cityId = 1002; //cannot assign a value to final variable regNo } } Ausgabe
Im obigen Programm haben wir eine Stadtklasse deklariert. Dies ist eine letzte Klasse, und in dieser Klasse haben wir zwei Mitgliedsvariablen und einen parametrisierten Konstruktor deklariert. Wir haben auch Getter-Methoden für diese beiden Mitgliedsvariablen deklariert. Die City-Klasse erfüllt also alle Anforderungen einer unveränderlichen Klasse.
Beachten Sie die kommentierte Codezeile in der Hauptmethode. Wenn wir diese Zeile auskommentieren, wird ein Compilerfehler angezeigt (im Kommentar hier angegeben), wenn wir versuchen, den Wert für eine Mitgliedsvariable festzulegen.
Singleton-Klasse in Java
Eine Singleton-Klasse erlaubt jeweils eine einzelne Instanz. In Java ist ein Singleton ein Entwurfsmuster. Dieses Entwurfsmuster stellt sicher, dass zu jedem Zeitpunkt nur eine Instanz einer Klasse vorhanden ist. Jede als Singleton definierte Klasse hat also einen einzelnen Zugriffspunkt und ist global.
Beachten Sie, dass das Beenden des Anwendungslebenszyklus eine Singleton-Klasse nicht wie die normalen Klassen zerstört. Wenn eine Klasse als Singleton deklariert wird, erstellen wir nicht jedes Mal eine neue Instanz, wenn eine neue Anforderung für das Objekt gestellt wird.
Die gleiche Instanz wird immer wieder verwendet. Auf diese Weise können wir den Speicherplatz vor allem bei Multithread- und Datenbankanwendungen sparen.
Wir können eine Singleton-Klasse für Aktivitäten wie Caching, Protokollierung usw. verwenden.
Das folgende Programm demonstriert eine Singleton-Klasse.
class Singleton { // static variable of type Singleton private static Singleton single_instance = null; // String variable public String str; // private constructor : restricted to this class private Singleton() { str = 'Singleton class::private constructor'; } // create instance of Singleton class using getInstance static method public static Singleton getInstance() { if (single_instance == null) single_instance = new Singleton(); return single_instance; } } class Main { public static void main(String args()) { // instantiate Singleton class with obj1 Singleton obj1 = Singleton.getInstance(); // instantiate Singleton class with obj2 Singleton obj2 = Singleton.getInstance(); System.out.println('obj1(str):' + obj1.str); System.out.println('obj2(str):' + obj2.str); // change variable of instance obj1 obj1.str = (obj1.str).toUpperCase(); System.out.println('
After changing obj1(str):'); System.out.println('obj1(str):' + obj1.str); System.out.println('obj2(str):' + obj2.str); } } Ausgabe
Im obigen Programm haben wir eine Singleton-Klasse mit einem privaten Konstruktor definiert. Wir haben eine Mitgliedsvariable vom Typ String definiert. In der Hauptmethode deklarieren wir zwei Instanzen der Singleton-Klasse. Dann ändern wir die String-Variable mit einer der Instanzen.
Wenn wir den String-Wert für beide Instanzen drucken, stellen wir fest, dass sich der Wert der String-Variablen für beide Instanzen geändert hat. Obwohl wir den Wert aufgrund der Singleton-Klasse nur für eine Instanz geändert haben, werden Änderungen in allen Instanzen wiedergegeben.
Wir geben immer dieselbe Instanz zurück, obwohl wir scheinbar unterschiedliche Instanzen erstellen.
Objektklasse In Java
Die Object-Klasse ist die übergeordnete Klasse oder die erste Klasse in Java. Es befindet sich auf der obersten Ebene der Java-Hierarchie.
Da alle Klassen die Object-Klasse als Oberklasse haben, implementieren alle Java-Objekte einschließlich Arrays die Object-Klassenmethoden. Die Objektklasse ist im Paket 'java.lang' enthalten.
Deklaration für java.lang.Object lautet:
Objekt der öffentlichen Klasse
In der folgenden Tabelle werden die Konstruktoren und Methoden der Object-Klasse beschrieben.
| Konstruktor / Methode | Beschreibung |
|---|---|
| Klasse getClass () | Gibt die Laufzeitklasse des Objekts zurück. |
| Objektklassenkonstruktor | |
| Objekt() | Objektklassenkonstruktor |
| Objektklassenmethoden | |
| geschützter Objektklon () | Gibt einen Klon oder eine Kopie des Objekts zurück. |
| Boolescher Wert gleich (Objekt obj) | Überprüft, ob ein bestimmtes Objekt obj diesem Objekt entspricht. |
| geschützte Leere finalize () | Wird vom Garbage Collector aufgerufen, wenn alle Verweise auf das Objekt zerstört wurden. |
| int hashCode () | Gibt Hash-Code für das Objekt zurück. |
| void notify () | Verwenden Sie diese Option, um einen einzelnen wartenden Thread zu aktivieren. |
| void notifyAll () | Weckt alle wartenden Threads auf. |
| String toString () | Gibt einen String zurück, der dem Objekt entspricht. |
| void wait () | Lässt einen Thread warten, bis er durch die Benachrichtigungsmethode eines anderen Threads aufgeweckt wird. |
| Leere Wartezeit (lange Zeitüberschreitung) | Lässt den Thread warten, bis die durch 'Timeout' angegebene Zeit abgelaufen ist oder durch die Methoden 'notify' oder 'notifyAll' aufgeweckt wird. |
| Leere Wartezeit (lange Zeitüberschreitung, int nanos) | Bewirkt, dass der Thread wartet, bis die angegebene Zeit abgelaufen ist oder bis notify () oder notifyAll () von einem anderen Thread aufgerufen wird. |
Implementieren wir ein Beispiel-Java-Programm, das einige der Methoden der Objektklasse demonstriert.
public class Main { public static void main(String() args) { Main t = new Main(); System.out.println('Main class Object HashCode:' + t.hashCode()); t = null; // call garbage collector System.gc(); System.out.println('Main class:End'); } @Override protected void finalize() { System.out.println('Main Class::finalize method called.'); } } Ausgabe
Hier haben wir eine Hauptklasse. In der Hauptmethode () erstellen wir ein Objekt der Hauptklasse. Dieses Objekt ist ein Nachkomme der Object-Klasse und unterstützt alle Object-Klassenmethoden. Daher verwenden wir dieses Objekt und rufen einige Object-Klassenmethoden wie hashCode (), System.GC (), finalize () usw. auf.
Wrapper-Klasse in Java
Java bietet eine Funktion namens Wrapper-Klasse, die über einen Mechanismus verfügt, der den primitiven Datentyp in ein Objekt konvertiert und umgekehrt. Wrapper-Klassen sind Klassen, die primitive Typen wie int, char usw. als Objekte darstellen.
Somit hat jeder primitive Datentyp in Java seine entsprechende Wrapper-Klasse.
Die folgende Tabelle zeigt die primitiven Datentypen und ihre entsprechende Wrapper-Klasse.
| Primitiver Typ | Wrapper-Typ |
|---|---|
| schweben | Schweben |
| Boolescher Wert | Boolescher Wert |
| verkohlen | Charakter |
| Byte | Byte |
| kurz | Kurz |
| int | Ganze Zahl |
| lange | Lange |
| doppelt | Doppelt |
Um die Grundelemente in Objekte und Objekte in Grundelemente umzuwandeln, haben wir Techniken, die als 'Autoboxing' bzw. 'Boxen' bezeichnet werden. Ase Java ist eine objektorientierte Programmiersprache, wir beschäftigen uns immer mit Objekten und wir haben auch viele Funktionen wie Sammlungen, Serialisierung usw., die auch Objekte und primitive Typen benötigen.
Daher ist es unbedingt erforderlich, dass wir in Java immer Objekte und primitive Typen benötigen. Daher benötigen wir diese Techniken des Autoboxing und Unboxing.
Autoboxing
Autoboxing ist eine Technik zum automatischen Konvertieren eines primitiven Datentyps in ein Objekt der entsprechenden Wrapper-Klasse. Zum Beispiel , Konvertierung von int in Integer-Klasse, char in Character-Klasse usw. sind Instanzen von Autoboxing.
Hinweis: Wrapper-Klassen verwenden die valueOf () -Methode, um das Grundelement in Objekte zu konvertieren, die seit Java 5 nicht mehr verwendet werden.
Unboxing
Die umgekehrte Konvertierung von Wrapper-Klassenobjekten in ihre entsprechenden primitiven Datentypen wird als 'Unboxing' bezeichnet.
Hinweis: Seit Java 5 wird die Methode intValue (), die das Wrapper-Objekt in einen primitiven Typ konvertiert, abgeschrieben.
Im Folgenden finden Sie ein Beispiel für das Boxen / Entpacken.
Was sind Metadaten im Data Warehouse?
public class Main { public static void main(String args()){ //Convert int to Integer : boxing int num=20; Integer int_class= Integer.valueOf(num);//explicit conversion from int to Integer Integer inum=num;//autoboxing System.out.println('int => Integer: ' + num+' => '+inum); //Convert Integer to int: unboxing Integer val=new Integer (3); int ival=val.intValue();//explicit conversion from Integer to int int jval=val;//unboxing System.out.println('Integer => int:' + val+' => '+jval); } } Ausgabe
Das obige Programm zeigt Autoboxing und Unboxing für den Int-Wert. Zuerst konvertieren wir int in ein Integer-Objekt und dann wird ein Integer-Objekt in den int-Datentyp konvertiert.
Implementieren wir ein Programm, das die in Java vorhandenen Wrapper-Klassen demonstriert.
public class Main { public static void main(String args()) { byte bbyte=10; short sshort=20; int iint=300; long llong=400; float ffloat=3.14F; double ddouble=77.2D; char cchar='A'; boolean bboolean=true; //Convert primitives into objects => Autoboxing Byte byteobj=bbyte; Short shortobj=sshort; Integer intobj=iint; Long longobj=llong; Float floatobj=ffloat; Double doubleobj=ddouble; Character charobj=cchar; Boolean boolobj=bboolean; //Print converted objects System.out.println('Primitives converted to Objects:'); System.out.println('Byte object: '+byteobj); System.out.println('Short object: '+shortobj); System.out.println('Integer object: '+intobj); System.out.println('Long object: '+longobj); System.out.println('Float object: '+floatobj); System.out.println('Double object: '+doubleobj); System.out.println('Character object: '+charobj); System.out.println('Boolean object: '+boolobj); //Convert Objects to Primitives => Unboxing byte bytevalue=byteobj; short shortvalue=shortobj; int intvalue=intobj; long longvalue=longobj; float floatvalue=floatobj; double doublevalue=doubleobj; char charvalue=charobj; boolean boolvalue=boolobj; //Print primitives System.out.println('Converting Objects to Primitives'); System.out.println('byte value: '+bytevalue); System.out.println('short value: '+shortvalue); System.out.println('int value: '+intvalue); System.out.println('long value: '+longvalue); System.out.println('float value: '+floatvalue); System.out.println('double value: '+doublevalue); System.out.println('char value: '+charvalue); System.out.println('boolean value: '+boolvalue); } } Ausgabe
Die obige Programmausgabe zeigt die Konvertierung von primitiven Typen in Wrapper-Objekte (Autoboxing) und kehrt die Konvertierung von Wrapper-Objekten in primitive Typen um (Unboxing).
Häufig gestellte Fragen
F # 1) Was ist der Klassendatentyp in Java?
Antworten: Java bietet eine Klasse mit dem Namen 'Klasse', die Informationen zu allen Klassen, Objekten und Schnittstellen der laufenden Anwendung enthält. Die Klassenklasse repräsentiert auch primitive Datentypen und den Leertyp.
Die Class-Klasse ist Teil des Pakets java.lang.
F # 2) Was ist die normale Klasse in Java?
Antworten: Eine normale Klasse in Java ist eine nicht statische Klasse. Mit dem neuen Schlüsselwort können wir Objekte einer normalen Klasse erstellen. Jede normale Klasse kann auch eine andere Klasse als Mitglied haben. In diesem Fall wird die Mitgliedsklasse als verschachtelte oder innere Klasse und die einschließende Klasse als äußere Klasse bezeichnet.
F # 3) Ist String eine Wrapper-Klasse in Java?
Antworten: Nein, String ist in Java keine Wrapper-Klasse. Damit eine Klasse eine Wrapper-Klasse ist, benötigen wir ihren entsprechenden primitiven Typ. Beispielsweise, Für die Integer-Wrapper-Klasse haben wir den primitiven Typ int. Für die String-Klasse haben wir keinen entsprechenden primitiven Datentyp.
F # 4) Was ist der Vorteil der Wrapper-Klasse?
Antworten: Wrapper-Klassen werden zur Konvertierung primitiver Datentypen in Objekte verwendet. Mit anderen Worten, Wrapper-Klassen wickeln primitive Typen in Objekte ein. Wrapper-Klassen werden verwendet, wenn bestimmte Java-Funktionen wie Sammlungen nur Objekte und keine primitiven Datentypen erwarten.
F # 5) Warum wird die Singleton-Klasse in Java verwendet?
Antworten: Wann immer wir einen globalen Zugriffspunkt für ein bestimmtes Objekt wünschen, wählen wir ein Singleton-Muster, mit dem wir eine Singleton-Klasse entwerfen können, in der es nur eine Instanz gibt. Singleton-Klassen werden in Caches, Thread-Pooling, Datenbankanwendungen, Protokollierung usw. verwendet.
Fazit
In diesem Tutorial haben wir die verschiedenen in Java verwendeten Klassentypen behandelt. Wir haben die Klassentypen Konkret, Abstrakt, Endgültig, Statisch, Verschachtelt, POJO usw. gesehen. Abgesehen davon haben wir auch Singleton-Klassen und unveränderliche Klassen sowie deren Implementierungsbeispiele erörtert.
Wir haben auch Wrapper-Klassen und Objektklassen in Java behandelt. Wrapper-Klassen sind die Klassen, die die primitiven Datentypen von Java in Objekte umschließen. Die Objektklasse in Java ist die Oberklasse aller anderen Klassen. Es ist die oberste Klasse in der Java-Hierarchie.
Nachdem wir die Klassen und Objekte in Java und die Klassentypen besprochen haben, werden wir im nächsten Tutorial mit einer detaillierten Diskussion über Konstruktoren in Java fortfahren.
=> Lesen Sie hier den perfekten Java-Schulungsleitfaden.
Literatur-Empfehlungen
- Java Interface und Abstract Class Tutorial mit Beispielen
- Java-Grundlagen: Java-Syntax, Java-Klasse und Java-Kernkonzepte
- Was ist ein statisches Schlüsselwort in Java?
- Java Integer und Java BigInteger Klasse mit Beispielen
- Java Scanner Class Tutorial mit Beispielen
- Java Class Vs Object - Verwendung von Klasse und Objekt in Java
- Java Array Class Tutorial - java.util.Arrays-Klasse mit Beispielen
- Was ist Java Vector? Java Vector Class Tutorial mit Beispielen