NEPRIMITĪVI DATU TIPI JAVA

Datu tipi nosaka datu veidu, kas tiek glabāti mainīgajā. Veids norāda datu veidu (dažādi izmēri un vērtības).

Java programmēšanas valodai ir divu veidu datu veidi

Neprimitīvie datu veidi
Atšķirībā no primitīvajiem datu veidiem tie nav iepriekš definēti. Tie ir programmētāju izveidoti lietotāja definēti datu tipi. Šie datu tipi tiek izmantoti vairāku vērtību glabāšanai.
stīgu marķieri java

Piemēram, apsveriet an masīvs, kas glabā vērtību grupu. Klase ir arī primitīvs veids, kas glabā dažādas metodes un mainīgos. Tāpēc tos sauc arī par uzlaboti datu veidi Java valodā.

Ikreiz, kad tiek definēts neprimitīvs datu tips, tas attiecas uz atmiņas vietu, kur dati tiek glabāti kaudzes atmiņā, t.i., tas attiecas uz atmiņas vietu, kurā ir novietots objekts. Tāpēc tiek izsaukts arī neprimitīvs datu tipa mainīgais atsauces datu tips vai vienkārši objekta atsauces mainīgais .

Objekta atsauces mainīgais dzīvo steka atmiņā, un objekts, uz kuru tas norāda, vienmēr dzīvo kaudzes atmiņā. Kaudzīte satur rādītāju uz kaudzes objektu.

Java programmēšanā visus neprimitīvos datu tipus vienkārši sauc par objektiem, kas tiek izveidoti, instantiējot klasi.

Galvenie punkti:
1. Jebkura atsauces mainīgā noklusējuma vērtība ir nulle.
2. Ikreiz, kad metodei nododam neprimitīvu datu tipu, mēs nododam tā objekta adresi, kurā dati tiek glabāti.
Neprimitīvo datu tipu veidi

Java ir piecu veidu neprimitīvie datu tipi. Tie ir šādi:
1. Klase
2. Objekts
3. Stīga
4. Masīvs
5. Interfeiss
1. Klase un objekti:

A klasē Java ir lietotāja definēts datu tips, t.i., to izveido lietotājs. Tas darbojas kā datu veidne, kas sastāv no dalībnieku mainīgajiem lielumiem un metodēm.

An objektu ir klases mainīgais, kas var piekļūt klases elementiem, t.i., metodēm un mainīgajiem.

Piemērs:
pārslēgt java

Nākamajā piemērā mēs izveidojam klasi, kurā ir mainīgie un metodes ( add() un sub() ). Šeit mēs piekļūstam metodēm, izmantojot klases objektu 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(); } } 
```
Izvade:
```
 Addition of numbers is: 30 Subtraction of numbers is: 10 
```
2. Interfeiss:

An saskarne ir līdzīga klasei, taču vienīgā atšķirība ir tā, ka tās metodes pēc noklusējuma ir abstraktas, t.i., tām nav pamatteksta. Interfeisam ir tikai galīgie mainīgie un metožu deklarācijas. To sauc arī par pilnībā abstraktu klasi.
css robeža

Piezīme. Ja klase īsteno saskarni, tai ir jāievieš visas šīs saskarnes metodes. Ja nē, mums ir jāpaziņo klase kā abstrakta.

Piemērs:

Nākamajā piemērā mēs veidojam saskarni CalcInterface ar divām abstraktām metodēm ( reizināt () un dalīt () ). Šeit klase InterfaceExample ievieš saskarni un tālāk definē šīs saskarnes metodes. Pēc tam, lai piekļūtu šīm metodēm, tiek izmantots klases objekts.

InterfeissPiemērs.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. Virkne:

Virkne apzīmē rakstzīmju secību, piemēram, 'Javatpoint', 'Hello world' utt. Virkne ir Java klase.

Tālāk ir parādīts viens no veidiem, kā izveidot virkni un saglabāt tajā vērtību:
```
 String str = &apos;You&apos;re the best&apos;; 
```
Šeit, virknes tipa mainīgais str ir vērtība “Tu esi labākais”. Noklikšķiniet šeit, lai uzzinātu vairāk par Virkne Java valodā .

Piemērs:
simetriska atšķirība

Nākamajā piemērā mēs izveidojam virkni ar vērtību. Šeit mēs izmantojam vienu no stīgu klases metodēm, apakšvirkne() kas izdrukā norādīto indeksēto virknes daļu.

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); } } 
```
Izvade:
```
 Hello! This is 
```
4. Masīvs:

An masīvs ir datu tips, kurā var saglabāt vairākus viendabīgus mainīgos, t.i., viena veida mainīgos secībā. Tie tiek saglabāti indeksētā veidā, sākot ar indeksu 0. Mainīgie var būt primitīvi vai neprimitīvi datu tipi.

Šis piemērs parāda, kā deklarēt primitīva datu tipa masīvu starpt :
```
 int [ ] marks; 
```
Šis piemērs parāda, kā deklarēt neprimitīva datu tipa masīvu:
```
 Student [ ] students; 
```
kur, Students ir klases nosaukums un [ ] izveido objektu masīvu studenti .
haralds baldrs

Piemērs:

Nākamajā piemērā mēs izveidojam divus pamata masīvus, no kuriem viens tiek inicializēts un otrs tiek deklarēts (ievade tiek nolasīta no lietotāja). Turklāt mēs drukājam šos masīvus, izmantojot for cilpu.

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;>
```
Atšķirība starp primitīvajiem un neprimitīvajiem datu tipiem Java
1. Java primitīvie datu tipi ir definēti sistēmā, taču mums ir jāizveido un jādefinē neprimitīvie datu tipi.
2. Primitīvajā datu tipā mainīgie var vienlaikus saglabāt tikai vienu vērtību. Tomēr neprimitīvos datu tipos var saglabāt vairākas viena vai dažāda veida vērtības, vai arī abas.
3. Visi dati par primitīvā tipa mainīgajiem tiek glabāti kaudzē, turpretim atsauces tipiem kaudze satur rādītāju uz objektu kaudzē.
4. Primitīvais tips sākas ar mazo burtu, savukārt primitīvie veidi sākas ar lielo burtu.
5. Primitīvā tipa lielums ir atkarīgs no datu veida, savukārt primitīvajiem tipiem ir vienādi izmēri.

TechCodeview

Neprimitīvi datu tipi Java

Galvenie punkti:

Neprimitīvo datu tipu veidi

1. Klase un objekti:

2. Interfeiss:

Piezīme. Ja klase īsteno saskarni, tai ir jāievieš visas šīs saskarnes metodes. Ja nē, mums ir jāpaziņo klase kā abstrakta.

3. Virkne:

4. Masīvs:

Atšķirība starp primitīvajiem un neprimitīvajiem datu tipiem Java