NIET-PRIMITIEVE GEGEVENSTYPEN IN JAVA

Gegevenstypen definiëren het type gegevens dat in de variabele wordt opgeslagen. Het type specificeert het soort gegevens (verschillende groottes en waarden).

Java-programmeertaal kent twee soorten gegevenstypen

Niet-primitieve gegevenstypen
In tegenstelling tot primitieve gegevenstypen zijn deze niet vooraf gedefinieerd. Dit zijn door de gebruiker gedefinieerde gegevenstypen die door programmeurs zijn gemaakt. Deze gegevenstypen worden gebruikt om meerdere waarden op te slaan.
rdbms

Denk bijvoorbeeld aan een array waarin een groep waarden wordt opgeslagen. Klasse is ook een primitief type dat verschillende methoden en variabelen opslaat. Daarom worden deze ook wel als genoemd geavanceerde gegevenstypen op Java.

Wanneer een niet-primitief gegevenstype wordt gedefinieerd, verwijst dit naar een geheugenlocatie waar de gegevens zijn opgeslagen in heap-geheugen, dat wil zeggen dat het verwijst naar de geheugenlocatie waar een object is geplaatst. Daarom wordt ook een niet-primitieve gegevenstypevariabele genoemd gegevenstype waarnaar wordt verwezen of objectreferentievariabele eenvoudigweg object .

Een objectreferentievariabele leeft in het stapelgeheugen en het object waarnaar deze verwijst, bevindt zich altijd in het heapgeheugen. De stapel bevat een verwijzing naar het object op de hoop.

Bij het programmeren in Java worden alle niet-primitieve gegevenstypen eenvoudigweg objecten genoemd die worden gemaakt door het instantiëren van een klasse.

Belangrijkste punten:
1. De standaardwaarde van elke referentievariabele is nul.
2. Telkens wanneer we een niet-primitief gegevenstype aan een methode doorgeven, geven we het adres door van dat object waar de gegevens zijn opgeslagen.
Typen niet-primitieve gegevenstypen

Er zijn vijf soorten niet-primitieve gegevenstypen in Java. Ze zijn als volgt:
1. Klas
2. Voorwerp
3. Snaar
4. Array
5. Koppel
1. Klasse en objecten:

A klas in Java is het een door de gebruiker gedefinieerd gegevenstype, dat wil zeggen dat het door de gebruiker wordt gemaakt. Het fungeert als een sjabloon voor de gegevens die bestaat uit lidvariabelen en methoden.

Een voorwerp is de variabele van de klasse, die toegang heeft tot de elementen van de klasse, dat wil zeggen methoden en variabelen.

Voorbeeld:
python os lijstdir

In het volgende voorbeeld maken we een klasse die de variabelen en methoden bevat ( toevoegen() en sub() ). Hier hebben we toegang tot de methoden die het object van de klasse gebruiken obj .

KlasseVoorbeeld.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(); } } 
```
Uitgang:
```
 Addition of numbers is: 30 Subtraction of numbers is: 10 
```
2. Interface:

Een koppel is vergelijkbaar met een klasse, maar het enige verschil is dat de methoden ervan standaard abstract zijn, dat wil zeggen dat ze geen body hebben. Een interface heeft alleen de laatste variabelen en methodedeclaraties. Het wordt ook wel een volledig abstracte klasse genoemd.
Java-geldige ID's

Opmerking: Als de klasse een interface implementeert, moet hij alle methoden van die interface implementeren. Als dat niet het geval is, moeten we de klasse als abstract verklaren.

Voorbeeld:

In het volgende voorbeeld maken we de interface CalcInterface met twee abstracte methoden ( vermenigvuldig() en deel() ). Hier implementeert de klasse InterfaceExample de interface en definieert verder de methoden van die interface. Vervolgens wordt het object van de klasse gebruikt om toegang te krijgen tot die methoden.

InterfaceVoorbeeld.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. Tekenreeks:

Een string vertegenwoordigt een reeks tekens, bijvoorbeeld 'Javatpoint', 'Hallo wereld', enz. String is de klasse van Java.

Eén van de manieren waarop u een string kunt maken en er een waarde in kunt opslaan, wordt hieronder weergegeven:
```
 String str = &apos;You&apos;re the best&apos;; 
```
Hier de variabele van het stringtype str heeft de waarde 'Jij bent de beste'. Klik hier voor meer informatie over Tekenreeks in Java .

Voorbeeld:
wiskundige methoden in Java

In het volgende voorbeeld maken we een tekenreeks met een waarde. Hier gebruiken we een van de String-klassemethoden, subtekenreeks() waarmee het opgegeven geïndexeerde deel van de string wordt afgedrukt.

StringVoorbeeld.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); } } 
```
Uitgang:
```
 Hello! This is 
```
4. Array:

Een reeks is een gegevenstype dat meerdere homogene variabelen kan opslaan, dat wil zeggen variabelen van hetzelfde type in een reeks. Ze worden geïndexeerd opgeslagen, beginnend met index 0. De variabelen kunnen primitieve of niet-primitieve gegevenstypen zijn.
c booleaans

Het volgende voorbeeld laat zien hoe u een array met primitieve gegevenstypes declareert int :
```
 int [ ] marks; 
```
Het volgende voorbeeld laat zien hoe u een array met niet-primitieve gegevenstypes declareert:
```
 Student [ ] students; 
```
waar, Student is de klassenaam en [ ] creëert een array met objecten studenten .

Voorbeeld:

In het volgende voorbeeld maken we twee basisarrays, waarin de ene wordt geïnitialiseerd en de andere wordt gedeclareerd (invoer wordt gelezen van de gebruiker). Verder drukken we die array af met behulp van de for-lus.

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;>
```
Verschil tussen primitieve en niet-primitieve gegevenstypen in Java
1. In Java zijn de primitieve gegevenstypen door het systeem gedefinieerd, maar we moeten de niet-primitieve gegevenstypen creëren en definiëren.
2. Bij het primitieve gegevenstype kunnen variabelen slechts één waarde tegelijk opslaan. In niet-primitieve gegevenstypen kunnen echter meerdere waarden van hetzelfde type of een ander type of beide worden opgeslagen.
3. Alle gegevens voor variabelen van het primitieve type worden op de stapel opgeslagen, terwijl voor referentietypen de stapel een verwijzing naar het object op de heap bevat.
4. Een primitief type begint met een kleine letter, terwijl niet-primitieve typen beginnen met een hoofdletter.
5. De grootte van een primitief type hangt af van het gegevenstype, terwijl niet-primitieve typen allemaal dezelfde grootte hebben.

TechCodeview

Niet-primitieve gegevenstypen in Java

Belangrijkste punten:

Typen niet-primitieve gegevenstypen

1. Klasse en objecten:

2. Interface:

Opmerking: Als de klasse een interface implementeert, moet hij alle methoden van die interface implementeren. Als dat niet het geval is, moeten we de klasse als abstract verklaren.

3. Tekenreeks:

4. Array:

Verschil tussen primitieve en niet-primitieve gegevenstypen in Java