NEM PRIMITÍV ADATTÍPUSOK JAVA NYELVEN

Az adattípusok határozzák meg a változóban tárolt adatok típusát. A típus határozza meg az adatok fajtáját (különböző méretek és értékek).

A Java programozási nyelvnek kétféle adattípusa van

Nem primitív adattípusok
A primitív adattípusokkal ellentétben ezek nincsenek előre definiálva. Ezek a programozók által létrehozott, felhasználó által definiált adattípusok. Ezeket az adattípusokat több érték tárolására használják.
javafx

Például vegyünk egy értékcsoportot tároló tömb. Az osztály is egy primitív típus, amely különböző metódusokat és változókat tárol. Ezért ezeket úgy is hívják fejlett adattípusok Java nyelven.

Amikor egy nem primitív adattípust definiálunk, az egy memóriahelyre utal, ahol az adatokat a kupacmemóriában tárolják, azaz arra a memóriahelyre utal, ahol egy objektum el van helyezve. Ezért egy nem primitív adattípusú változót is hívnak hivatkozott adattípus vagy egyszerűen objektum referencia változó .

Egy objektum-hivatkozási változó a veremmemóriában él, az objektum pedig, amelyre mutat, mindig a kupacmemóriában él. A verem egy mutatót tartalmaz a kupacban lévő objektumra.

A Java programozásban minden nem primitív adattípust egyszerűen objektumnak neveznek, amelyeket egy osztály példányosításával hoznak létre.

Főbb pontok:
1. Bármely referenciaváltozó alapértelmezett értéke null.
2. Amikor egy nem primitív adattípust adunk át egy metódusnak, akkor annak az objektumnak a címét adjuk át, ahol az adatokat tároljuk.
A nem primitív adattípusok típusai

A Java-ban ötféle nem primitív adattípus létezik. Ezek a következők:
1. Osztály
2. Tárgy
3. Húr
4. Sor
5. Felület
1. Osztály és objektumok:

A osztály a Java-ban egy felhasználó által meghatározott adattípus, azaz a felhasználó hozza létre. Az adatok sablonjaként működik, amely tagváltozókból és metódusokból áll.

An tárgy az osztály változója, amely hozzáférhet az osztály elemeihez, azaz a metódusokhoz és a változókhoz.

Példa:
szándékos szándék

A következő példában létrehozunk egy osztályt, amely tartalmazza a változókat és metódusokat ( add() és sub() ). Itt az osztály objektumával érjük el a metódusokat obj .

OsztályPélda.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(); } } 
```
Kimenet:
```
 Addition of numbers is: 30 Subtraction of numbers is: 10 
```
2. Interfész:

An felület hasonlít egy osztályhoz, de az egyetlen különbség az, hogy a metódusai alapértelmezés szerint absztraktak, azaz nincs törzsük. Egy interfész csak a végső változókat és metódusdeklarációkat tartalmazza. Teljesen absztrakt osztálynak is nevezik.
hogyan lehet karakterláncot karakterré alakítani

Megjegyzés: Ha az osztály egy interfészt valósít meg, akkor ennek az interfésznek az összes metódusát meg kell valósítania. Ha nem, akkor az osztályt absztraktnak kell nyilvánítanunk.

Példa:

A következő példában a CalcInterface felületet hozzuk létre két absztrakt módszerrel ( szorzás() és osztás() ). Itt az InterfaceExample osztály valósítja meg az interfészt, és tovább határozza meg az interfész metódusait. Ezután az osztály objektumát használják a metódusok eléréséhez.

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. Karakterlánc:

A karakterlánc karaktersorozatot jelöl, például 'Javatpoint', 'Hello world' stb. A string a Java osztálya.

Az alábbiakban látható az egyik módja a karakterlánc létrehozásának és abban az érték tárolásának:
```
 String str = &apos;You&apos;re the best&apos;; 
```
Itt a String típusú változó str értéke „Te vagy a legjobb”. Kattintson ide, ha többet szeretne tudni erről String Java nyelven .

Példa:
js készlet

A következő példában egy karakterláncot hozunk létre egy értékkel. Itt a String osztály metódusainak egyikét használjuk, részkarakterlánc() amely kiírja a karakterlánc megadott indexelt részét.

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); } } 
```
Kimenet:
```
 Hello! This is 
```
4. Tömb:

An sor egy olyan adattípus, amely több homogén változót, azaz azonos típusú változókat tud tárolni egy sorozatban. Tárolásuk indexelt módon történik, 0 indextől kezdve. A változók lehetnek primitív vagy nem primitív adattípusok.
az absztrakt osztálynak lehet konstruktora

A következő példa bemutatja, hogyan deklarálható primitív adattípusú tömb int :
```
 int [ ] marks; 
```
A következő példa bemutatja, hogyan deklarálható a nem primitív adattípusú tömb:
```
 Student [ ] students; 
```
ahol, Diák az osztály neve, és a [ ] objektumtömböt hoz létre hallgatók .

Példa:

A következő példában két alapvető tömböt hozunk létre, amelyben az egyik inicializálva van, a másik pedig deklarálva van (a bemenetet a felhasználó olvassa be). Továbbá ezeket a tömböket a for ciklus segítségével nyomtatjuk ki.

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;>
```
Különbség a primitív és a nem primitív adattípusok között a Java nyelven
1. A Java-ban a primitív adattípusok rendszer által meghatározottak, azonban létre kell hoznunk és definiálnunk kell a nem primitív adattípusokat.
2. A primitív adattípusban a változók egyszerre csak egy értéket tárolhatnak. A nem primitív adattípusokban azonban vagy több azonos típusú vagy különböző típusú érték, vagy mindkettő tárolható.
3. A primitív típusú változók összes adata a veremben tárolódik, míg a referenciatípusok esetében a verem egy mutatót tartalmaz a kupacban lévő objektumra.
4. A primitív típusok kisbetűvel, míg a nem primitív típusok nagybetűvel kezdődnek.
5. A primitív típusok mérete az adattípustól függ, míg a nem primitív típusok mérete azonos.

TechCodeview

Nem primitív adattípusok Java nyelven

Főbb pontok:

A nem primitív adattípusok típusai

1. Osztály és objektumok:

2. Interfész:

Megjegyzés: Ha az osztály egy interfészt valósít meg, akkor ennek az interfésznek az összes metódusát meg kell valósítania. Ha nem, akkor az osztályt absztraktnak kell nyilvánítanunk.

3. Karakterlánc:

4. Tömb:

Különbség a primitív és a nem primitív adattípusok között a Java nyelven