ICKE-PRIMITIVA DATATYPER I JAVA

Datatyper definierar typen av data som lagras i variabeln. Typen anger typen av data (olika storlekar och värden).

Java programmeringsspråk har två typer av datatyper

Icke-primitiva datatyper
Till skillnad från primitiva datatyper är dessa inte fördefinierade. Dessa är användardefinierade datatyper skapade av programmerare. Dessa datatyper används för att lagra flera värden.
js set

Tänk till exempel en array som lagrar en grupp värden. Klass är också en primitiv typ som lagrar olika metoder och variabler. Därför kallas dessa också som avancerade datatyper i Java.

Närhelst en icke-primitiv datatyp definieras, hänvisar den till en minnesplats där data lagras i högminne, dvs. den hänvisar till minnesplatsen där ett objekt är placerat. Därför kallas även en icke-primitiv datatypvariabel refererad datatyp eller helt enkelt objektreferensvariabel .

En objektreferensvariabel finns i stackminnet och objektet som den pekar på finns alltid i heapminnet. Högen håller en pekare till objektet på högen.

I Java-programmering kallas alla icke-primitiva datatyper helt enkelt objekt som skapas genom att instansiera en klass.

Nyckelord:
1. Standardvärdet för en referensvariabel är null.
2. Närhelst vi skickar en icke-primitiv datatyp till en metod skickar vi adressen till det objekt där data lagras.
Typer av icke-primitiva datatyper

Det finns fem typer av icke-primitiva datatyper i Java. De är följande:
1. Klass
2. Objekt
3. Sträng
4. Array
5. Gränssnitt
1. Klass och objekt:

A klass i Java är en användardefinierad datatyp, dvs den skapas av användaren. Det fungerar som en mall för data som består av medlemsvariabler och metoder.

En objekt är klassens variabel, som kan komma åt elementen i klassen, dvs metoder och variabler.

Exempel:
c++ delande sträng

I följande exempel skapar vi en klass som innehåller variablerna och metoderna ( add() och sub() ). Här kommer vi åt metoderna med 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. Gränssnitt:

En gränssnitt liknar en klass men den enda skillnaden är att dess metoder är abstrakta som standard, dvs de har inte body. Ett gränssnitt har bara de slutliga variablerna och metoddeklarationerna. Det kallas också en helt abstrakt klass.
datum konvertera till sträng

Obs: Om klassen implementerar ett gränssnitt måste den implementera alla metoder för det gränssnittet. Om inte, måste vi deklarera klassen som abstrakt.

Exempel:

I följande exempel skapar vi gränssnittet CalcInterface med två abstrakta metoder ( multiplicera() och dividera() ). Här implementerar klassen InterfaceExample gränssnittet och definierar ytterligare metoderna för det gränssnittet. Sedan används klassens objekt för att komma åt dessa 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. Sträng:

En sträng representerar en sekvens av tecken, till exempel 'Javatpoint', 'Hello world', etc. String är Java-klassen.

Ett av sätten att skapa en sträng och lagra ett värde i den visas nedan:
```
 String str = &apos;You&apos;re the best&apos;; 
```
Här, strängtypsvariabel str har värdet 'Du är bäst'. Klicka här för att förstå mer om Sträng i Java .

Exempel:
fmoviez

I följande exempel skapar vi en sträng med ett värde. Här använder vi en av String-klassmetoderna, substring() som skriver ut den angivna indexerade delen av strängen.

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:

En array är en datatyp som kan lagra flera homogena variabler, dvs variabler av samma typ i en sekvens. De lagras på ett indexerat sätt som börjar med index 0. Variablerna kan vara antingen primitiva eller icke-primitiva datatyper.
java substring exempel

Följande exempel visar hur man deklarerar array av primitiv datatyp int :
```
 int [ ] marks; 
```
Följande exempel visar hur man deklarerar array av icke-primitiv datatyp:
```
 Student [ ] students; 
```
var, Studerande är klassens namn och [ ] skapar en array av objekt studenter .

Exempel:

I följande exempel skapar vi två grundläggande arrayer, där den ena initieras och den andra deklareras (indata läses från användaren). Vidare skriver vi ut dessa arrayer med hjälp av for-loopen.

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;>
```
Skillnad mellan primitiva och icke-primitiva datatyper i Java
1. I Java är de primitiva datatyperna systemdefinierade men vi måste skapa och definiera de icke-primitiva datatyperna.
2. I primitiv datatyp kan variabler endast lagra ett värde åt gången. Men i icke-primitiva datatyper kan antingen flera värden av samma typ eller olika typ eller båda lagras.
3. All data för primitiva typvariabler lagras i stacken medan, för referenstyper, stacken håller en pekare till objektet på högen.
4. En primitiv typ börjar med en liten bokstav, medan icke-primitiv typ börjar med en stor bokstav.
5. Storleken på en primitiv typ beror på datatypen, medan icke-primitiva typer har alla samma storlek.

TechCodeview

Icke-primitiva datatyper i Java

Nyckelord:

Typer av icke-primitiva datatyper

1. Klass och objekt:

2. Gränssnitt:

Obs: Om klassen implementerar ett gränssnitt måste den implementera alla metoder för det gränssnittet. Om inte, måste vi deklarera klassen som abstrakt.

3. Sträng:

4. Array:

Skillnad mellan primitiva och icke-primitiva datatyper i Java