NICHT-PRIMITIVE DATENTYPEN IN JAVA

Datentypen definieren die Art der Daten, die in der Variablen gespeichert werden. Der Typ gibt die Art der Daten an (verschiedene Größen und Werte).

Die Programmiersprache Java verfügt über zwei Arten von Datentypen

Nicht-primitive Datentypen
Im Gegensatz zu primitiven Datentypen sind diese nicht vordefiniert. Dabei handelt es sich um benutzerdefinierte Datentypen, die von Programmierern erstellt wurden. Diese Datentypen werden zum Speichern mehrerer Werte verwendet.
Konvertieren Sie NFA in DFA

Betrachten Sie zum Beispiel eine Array, das eine Gruppe von Werten speichert. Klasse ist auch ein primitiver Typ, der verschiedene Methoden und Variablen speichert. Daher werden diese auch als bezeichnet erweiterte Datentypen in Java.

Immer wenn ein nicht-primitiver Datentyp definiert wird, bezieht er sich auf einen Speicherort, an dem die Daten im Heap-Speicher gespeichert werden, d. h. er bezieht sich auf den Speicherort, an dem ein Objekt platziert wird. Daher wird auch eine nicht-primitive Datentypvariable aufgerufen referenzierter Datentyp oder einfach Objektreferenzvariable .

Eine Objektreferenzvariable befindet sich im Stapelspeicher und das Objekt, auf das sie verweist, befindet sich immer im Heapspeicher. Der Stapel enthält einen Zeiger auf das Objekt auf dem Heap.

In der Java-Programmierung werden alle nicht-primitiven Datentypen einfach Objekte genannt, die durch Instanziieren einer Klasse erstellt werden.

Kernpunkte:
1. Der Standardwert jeder Referenzvariablen ist null.
2. Immer wenn wir einen nicht-primitiven Datentyp an eine Methode übergeben, übergeben wir die Adresse des Objekts, in dem die Daten gespeichert sind.
Arten von nicht-primitiven Datentypen

In Java gibt es fünf Arten nicht-primitiver Datentypen. Sie sind wie folgt:
1. Klasse
2. Objekt
3. Zeichenfolge
4. Array
5. Schnittstelle
1. Klasse und Objekte:

A Klasse In Java handelt es sich um einen benutzerdefinierten Datentyp, d. h. er wird vom Benutzer erstellt. Es fungiert als Vorlage für die Daten, die aus Mitgliedsvariablen und Methoden bestehen.

Ein Objekt ist die Variable der Klasse, die auf die Elemente der Klasse, also Methoden und Variablen, zugreifen kann.

Beispiel:
Streicher in c

Im folgenden Beispiel erstellen wir eine Klasse, die die Variablen und Methoden enthält ( add() und sub() ). Hier greifen wir über das Objekt der Klasse auf die Methoden zu obj .

ClassExample.java
```
 public class ClassExample { // defining the variables of class int a = 20; int b = 10; int c; // defining the methods of class public void add () { int c = a + b; System.out.println(&apos;Addition of numbers is: &apos; + c); } public void sub () { int c = a - b; System.out.println(&apos;Subtraction of numbers is: &apos; + c); } // main method public static void main (String[] args) { // creating the object of class ClassExample obj = new ClassExample(); // calling the methods obj.add(); obj.sub(); } } 
```
Ausgabe:
```
 Addition of numbers is: 30 Subtraction of numbers is: 10 
```
2. Schnittstelle:

Ein Schnittstelle ähnelt einer Klasse, der einzige Unterschied besteht jedoch darin, dass ihre Methoden standardmäßig abstrakt sind, d. h. sie haben keinen Körper. Eine Schnittstelle verfügt nur über die endgültigen Variablen und Methodendeklarationen. Sie wird auch als vollständig abstrakte Klasse bezeichnet.
wie man einen String in ein Zeichen umwandelt

Hinweis: Wenn die Klasse eine Schnittstelle implementiert, muss sie alle Methoden dieser Schnittstelle implementieren. Wenn nicht, müssen wir die Klasse als abstrakt deklarieren.

Beispiel:

Im folgenden Beispiel erstellen wir die Schnittstelle CalcInterface mit zwei abstrakten Methoden ( multiplizieren() und dividieren() ). Hier implementiert die Klasse InterfaceExample die Schnittstelle und definiert die Methoden dieser Schnittstelle weiter. Anschließend wird das Objekt der Klasse verwendet, um auf diese Methoden zuzugreifen.

InterfaceExample.java
```
 interface CalcInterface { void multiply(); void divide(); } public class InterfaceExample implements CalcInterface { // defining the variables of class int a = 10; int b = 20; int c; // implementing the interface methods public void multiply() { int c = a * b; System.out.println(&apos;Multiplication of numbers is: &apos; + c); } public void divide() { int c = a / b; System.out.println(&apos;Division of numbers is: &apos; + c); } // main method public static void main (String[] args) throws IOException { InterfaceExample obj = new InterfaceExample(); // calling the methods obj.multiply(); obj.divide(); } } 
```
3. Zeichenfolge:

Ein String stellt eine Folge von Zeichen dar, zum Beispiel „Javatpoint“, „Hello World“ usw. String ist die Klasse von Java.

Eine Möglichkeit, eine Zeichenfolge zu erstellen und darin einen Wert zu speichern, wird unten gezeigt:
```
 String str = &apos;You&apos;re the best&apos;; 
```
Hier eine Variable vom Typ String str hat den Wert „Du bist der Beste“. Klicken Sie hier, um mehr darüber zu erfahren Zeichenfolge in Java .

Beispiel:
javafx

Im folgenden Beispiel erstellen wir eine Zeichenfolge mit einem Wert. Hier verwenden wir eine der Methoden der String-Klasse: Teilzeichenfolge() Dadurch wird der angegebene indizierte Teil der Zeichenfolge gedruckt.

StringExample.java
```
 public class StringExample { public static void main(String[] args) { // creating a string and initializing it String str = &apos;Hello! This is example of String type&apos;; // applying substring() on above string String subStr = str.substring(0,14); // printing the string System.out.println(subStr); } } 
```
Ausgabe:
```
 Hello! This is 
```
4. Array:

Ein Array ist ein Datentyp, der mehrere homogene Variablen speichern kann, d. h. Variablen desselben Typs in einer Sequenz. Sie werden indiziert ab Index 0 gespeichert. Die Variablen können entweder primitive oder nicht-primitive Datentypen sein.

Das folgende Beispiel zeigt, wie ein Array mit einem primitiven Datentyp deklariert wird int :
```
 int [ ] marks; 
```
Das folgende Beispiel zeigt, wie ein Array mit einem nicht-primitiven Datentyp deklariert wird:
```
 Student [ ] students; 
```
Wo, Student ist der Klassenname und [ ] erstellt ein Array von Objekten Studenten .
Beispiel für einen Teilstring in Java

Beispiel:

Im folgenden Beispiel erstellen wir zwei grundlegende Arrays, von denen eines initialisiert und das andere deklariert wird (Eingabe wird vom Benutzer gelesen). Außerdem drucken wir dieses Array mithilfe der for-Schleife.

ArrayExample.java
```
 // importing required packages import java.io. * ; import java.util. * ; public class ArrayExample { public static void main(String[] args) throws IOException { int i; Scanner sc = new Scanner(System. in ); // declaring and initializing an array int arr[] = {1, 2, 3, 6, 9}; // defining another array arr1 int arr1[] = new int[5]; // reading values from the user System.out.println(&apos;Enter the numbers (size = 5) :&apos;); for (i = 0; i <5; i++) { arr1[i]="sc.nextInt();" } system.out.println('previous array with initialized size is: '); for (i="0;" i < 5; system.out.print(arr[i] + ' system.out.println('
the new we have entered is:'); system.out.print(arr1[i] pre> <p> <strong>Output:</strong> </p> <pre> Enter the numbers (size = 5) : 56 43 22 1 7 Previous array with initialized size is: 1 2 3 6 9 The new array we have entered is: 56 43 22 1 7 </pre> <h2>Difference between Primitive and Non-primitive Data types in Java</h2> <ol class="points"> <li>In Java, the primitive data types are system defined however we have to create and define the non-primitive data types.</li> <li>In primitive data type, variables can store only one value at a time. However in non-primitive data types, either multiple values of the same type or different type or both can be stored.</li> <li>All the data for primitive type variables are stored on the stack whereas, for reference types, the stack holds a pointer to the object on the heap.</li> <li>A primitive type starts with a lowercase letter, while non-primitive types start with an uppercase letter.</li> <li>The size of a primitive type depends on the data type, while non-primitive types have all the same size.</li> </ol> <hr></5;>
```
Unterschied zwischen primitiven und nicht-primitiven Datentypen in Java
1. In Java sind die primitiven Datentypen systemdefiniert, wir müssen jedoch die nicht-primitiven Datentypen erstellen und definieren.
2. Im primitiven Datentyp können Variablen jeweils nur einen Wert speichern. In nicht-primitiven Datentypen können jedoch entweder mehrere Werte desselben Typs oder unterschiedlichen Typs oder beides gespeichert werden.
3. Alle Daten für Variablen vom primitiven Typ werden auf dem Stapel gespeichert, während der Stapel für Referenztypen einen Zeiger auf das Objekt auf dem Heap enthält.
4. Ein primitiver Typ beginnt mit einem Kleinbuchstaben, während nicht-primitive Typen mit einem Großbuchstaben beginnen.
5. Die Größe eines primitiven Typs hängt vom Datentyp ab, während nicht-primitive Typen alle die gleiche Größe haben.

TechCodeview

Nicht-primitive Datentypen in Java

Kernpunkte:

Arten von nicht-primitiven Datentypen

1. Klasse und Objekte:

2. Schnittstelle:

Hinweis: Wenn die Klasse eine Schnittstelle implementiert, muss sie alle Methoden dieser Schnittstelle implementieren. Wenn nicht, müssen wir die Klasse als abstrakt deklarieren.

3. Zeichenfolge:

4. Array:

Unterschied zwischen primitiven und nicht-primitiven Datentypen in Java