IKKE-PRIMITIVE DATATYPER I JAVA

Datatyper definerer typen af data, der er gemt i variablen. Typen angiver typen af data (forskellige størrelser og værdier).

Java programmeringssprog har to typer datatyper

Ikke-primitive datatyper
I modsætning til primitive datatyper er disse ikke foruddefinerede. Disse er brugerdefinerede datatyper skabt af programmører. Disse datatyper bruges til at gemme flere værdier.
aryan khan

Overvej for eksempel en array, der gemmer en gruppe værdier. Klasse er også en primitiv type, der gemmer forskellige metoder og variabler. Derfor kaldes disse også som avancerede datatyper i Java.

Når en ikke-primitiv datatype er defineret, refererer den til en hukommelsesplacering, hvor dataene er lagret i heap-hukommelse, dvs. den henviser til den hukommelsesplacering, hvor et objekt er placeret. Derfor kaldes en ikke-primitiv datatypevariabel også refereret datatype eller blot objektreferencevariabel .

En objektreferencevariabel lever på stakhukommelsen, og objektet, som den peger på, lever altid i heaphukommelsen. Stakken holder en markør til objektet på heapen.

I Java-programmering kaldes alle ikke-primitive datatyper blot objekter, der er skabt ved at instansiere en klasse.

Centrale punkter:
1. Standardværdien for enhver referencevariabel er null.
2. Når vi sender en ikke-primitiv datatype til en metode, videregiver vi adressen på det objekt, hvor dataene er gemt.
Typer af ikke-primitive datatyper

Der er fem typer ikke-primitive datatyper i Java. De er som følger:
1. klasse
2. Objekt
3. Snor
4. Array
5. Interface
1. Klasse og objekter:

EN klasse i Java er en brugerdefineret datatype, dvs. den er oprettet af brugeren. Det fungerer som en skabelon til dataene, som består af medlemsvariabler og metoder.

An objekt er klassens variabel, som kan få adgang til klassens elementer, dvs. metoder og variabler.

Eksempel:
forskel mellem $ og $$

I det følgende eksempel opretter vi en klasse, der indeholder variablerne og metoderne ( add() og sub() ). Her får vi adgang til metoderne ved hjælp af klassens objekt 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(); } } 
```
Produktion:
```
 Addition of numbers is: 30 Subtraction of numbers is: 10 
```
2. Interface:

An interface ligner en klasse, men den eneste forskel er, at dens metoder som standard er abstrakte, dvs. de har ikke krop. En grænseflade har kun de endelige variabler og metodeerklæringer. Det kaldes også en fuldt abstrakt klasse.
.næste java

Bemærk: Hvis klassen implementerer en grænseflade, skal den implementere alle den pågældende grænseflades metoder. Hvis ikke, skal vi erklære klassen som abstrakt.

Eksempel:

I det følgende eksempel opretter vi grænsefladen CalcInterface med to abstrakte metoder ( multiplicer() og divider() ). Her implementerer klassen InterfaceExample grænsefladen og definerer yderligere den pågældende grænseflades metoder. Derefter bruges klassens objekt til at få adgang til disse metoder.

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. Streng:

En streng repræsenterer en sekvens af tegn, f.eks. 'Javatpoint', 'Hello world' osv. String er Java-klassen.

En af måderne til at oprette en streng og gemme en værdi i den er vist nedenfor:
```
 String str = &apos;You&apos;re the best&apos;; 
```
Her, String type variabel str har værdien 'Du er den bedste'. Klik her for at forstå mere om String i Java .

Eksempel:
indeholder java-metoden

I det følgende eksempel opretter vi en streng med en værdi. Her bruger vi en af String-klassens metoder, understreng() som udskriver den angivne indekserede del af strengen.

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

An array er en datatype, som kan lagre flere homogene variable, dvs. variable af samme type i en sekvens. De lagres på en indekseret måde begyndende med indeks 0. Variablerne kan være enten primitive eller ikke-primitive datatyper.
computernetværk

Følgende eksempel viser, hvordan man deklarerer matrix af primitiv datatype int :
```
 int [ ] marks; 
```
Følgende eksempel viser, hvordan man erklærer matrix af ikke-primitiv datatype:
```
 Student [ ] students; 
```
hvor, Studerende er klassens navn og [ ] opretter en række objekter studerende .

Eksempel:

I det følgende eksempel opretter vi to grundlæggende array, hvor det ene initialiseres og det andet erklæres (input læses fra brugeren). Yderligere udskriver vi disse array ved hjælp af for-løkken.

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;>
```
Forskel mellem primitive og ikke-primitive datatyper i Java
1. I Java er de primitive datatyper systemdefinerede, men vi skal oprette og definere de ikke-primitive datatyper.
2. I primitiv datatype kan variabler kun lagre én værdi ad gangen. Men i ikke-primitive datatyper kan enten flere værdier af samme type eller forskellig type eller begge lagres.
3. Alle data for primitive typevariabler gemmes på stakken, hvorimod stakken for referencetyper holder en pointer til objektet på heapen.
4. En primitiv type starter med et lille bogstav, mens ikke-primitive typer starter med et stort bogstav.
5. Størrelsen af en primitiv type afhænger af datatypen, mens ikke-primitive typer alle har samme størrelse.

TechCodeview

Ikke-primitive datatyper i Java

Centrale punkter:

Typer af ikke-primitive datatyper

1. Klasse og objekter:

2. Interface:

Bemærk: Hvis klassen implementerer en grænseflade, skal den implementere alle den pågældende grænseflades metoder. Hvis ikke, skal vi erklære klassen som abstrakt.

3. Streng:

4. Array:

Forskel mellem primitive og ikke-primitive datatyper i Java