EI-PRIMITIIVISET TIETOTYYPIT JAVASSA

Tietotyypit määrittelevät muuttujaan tallennettavien tietojen tyypin. Tyyppi määrittää datan tyypin (eri koot ja arvot).

Java-ohjelmointikielellä on kahdenlaisia tietotyyppejä

Ei-primitiiviset tietotyypit
Toisin kuin primitiiviset tietotyypit, näitä ei ole ennalta määritetty. Nämä ovat ohjelmoijien luomia käyttäjän määrittämiä tietotyyppejä. Näitä tietotyyppejä käytetään useiden arvojen tallentamiseen.
testaus ja testaustyypit

Harkitse esimerkiksi an matriisi, joka tallentaa arvoryhmän. Luokka on myös primitiivinen tyyppi, joka tallentaa erilaisia menetelmiä ja muuttujia. Siksi näitä kutsutaan myös nimellä kehittyneet tietotyypit Javassa.

Aina kun ei-primitiivinen tietotyyppi määritellään, se viittaa muistipaikkaan, johon data on tallennettu kasamuistiin, eli se viittaa muistipaikkaan, johon objekti on sijoitettu. Siksi kutsutaan myös ei-primitiivistä tietotyyppimuuttujaa viitattu tietotyyppi tai yksinkertaisesti objektiviittausmuuttuja .

Objektiviittausmuuttuja asuu pinomuistissa ja objekti, johon se osoittaa, asuu aina kasamuistissa. Pinossa on osoitin kasan objektiin.

Java-ohjelmoinnissa kaikkia ei-primitiivisiä tietotyyppejä kutsutaan yksinkertaisesti objekteiksi, jotka luodaan instantoimalla luokka.

Avainkohdat:
1. Minkä tahansa viitemuuttujan oletusarvo on tyhjä.
2. Aina kun välitämme ei-primitiivistä tietotyyppiä menetelmälle, välitämme sen objektin osoitteen, johon tiedot on tallennettu.
Ei-primitiivisten tietotyyppien tyypit

Javassa on viisi tyyppiä ei-primitiivisiä tietotyyppejä. Ne ovat seuraavat:
1. Luokka
2. Esine
3. merkkijono
4. Array
5. Käyttöliittymä
1. Luokka ja objektit:

A luokkaa Javassa on käyttäjän määrittelemä tietotyyppi, eli se on käyttäjän luoma. Se toimii mallina datalle, joka koostuu jäsenmuuttujista ja menetelmistä.

An esine on luokan muuttuja, joka pääsee käsiksi luokan elementteihin eli menetelmiin ja muuttujiin.

Esimerkki:
python-ohjelmointiesimerkkejä

Seuraavassa esimerkissä luomme luokan, joka sisältää muuttujat ja menetelmät ( add() ja sub() ). Tässä pääsemme menetelmiin käyttämällä luokan objektia 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(); } } 
```
Lähtö:
```
 Addition of numbers is: 30 Subtraction of numbers is: 10 
```
2. Käyttöliittymä:

An käyttöliittymä on samanlainen kuin luokka, mutta ainoa ero on, että sen menetelmät ovat oletuksena abstrakteja, eli niillä ei ole runkoa. Liitännässä on vain lopulliset muuttujat ja menetelmäilmoitukset. Sitä kutsutaan myös täysin abstraktiksi luokaksi.
tcp ja ip malli

Huomautus: Jos luokka toteuttaa rajapinnan, sen on toteutettava kaikki kyseisen rajapinnan menetelmät. Jos ei, meidän on julistettava luokka abstraktiksi.

Esimerkki:

Seuraavassa esimerkissä luomme käyttöliittymän CalcInterface kahdella abstraktilla menetelmällä ( kerro() ja jaa() ). Tässä luokka InterfaceExample toteuttaa rajapinnan ja määrittelee edelleen kyseisen rajapinnan menetelmät. Sitten luokan objektia käytetään pääsemään näihin menetelmiin.

KäyttöliittymäEsimerkki.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. Merkkijono:

Merkkijono edustaa merkkijonoa, esimerkiksi 'Javatpoint', 'Hello world' jne. Merkkijono on Java-luokka.

Alla on yksi tavoista luoda merkkijono ja tallentaa siihen arvo:
```
 String str = &apos;You&apos;re the best&apos;; 
```
Tässä merkkijonotyypin muuttuja str on arvo 'Olet paras'. Napsauta tästä saadaksesi lisätietoja Javalla merkkijono .

Esimerkki:
koneoppimismalleja

Seuraavassa esimerkissä luomme merkkijonon, jolla on arvo. Tässä käytämme yhtä String-luokan menetelmistä, osamerkkijono() joka tulostaa määritetyn indeksoidun osan merkkijonosta.

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); } } 
```
Lähtö:
```
 Hello! This is 
```
4. Taulukko:

An joukko on tietotyyppi, joka voi tallentaa useita homogeenisia muuttujia eli samantyyppisiä muuttujia sekvenssiin. Ne tallennetaan indeksoidulla tavalla alkaen indeksistä 0. Muuttujat voivat olla joko primitiivisiä tai ei-primitiivisiä tietotyyppejä.
merkkijono päivämäärään muuntaa

Seuraava esimerkki näyttää, kuinka primitiivisen tietotyypin joukko määritellään int :
```
 int [ ] marks; 
```
Seuraava esimerkki näyttää, kuinka ei-primitiivisen tietotyypin matriisi määritetään:
```
 Student [ ] students; 
```
missä, Opiskelija on luokan nimi ja [ ] luo objektijoukon opiskelijat .

Esimerkki:

Seuraavassa esimerkissä luomme kaksi perustaulukkoa, joista toinen alustetaan ja toinen deklaroidaan (syöte luetaan käyttäjältä). Lisäksi tulostamme nämä taulukot for-silmukan avulla.

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;>
```
Ero primitiivisten ja ei-primitiivisten tietotyyppien välillä Javassa
1. Javassa primitiiviset tietotyypit ovat järjestelmämääritelmiä, mutta meidän on luotava ja määriteltävä ei-primitiiviset tietotyypit.
2. Primitiivisessä tietotyypissä muuttujat voivat tallentaa vain yhden arvon kerrallaan. Ei-primitiivisissä tietotyypeissä voidaan kuitenkin tallentaa useita samantyyppisiä tai erityyppisiä arvoja tai molempia.
3. Kaikki primitiivityyppisten muuttujien tiedot tallennetaan pinoon, kun taas viitetyyppien kohdalla pinossa on osoitin keon objektiin.
4. Primitiiviset tyypit alkavat pienellä kirjaimella, kun taas ei-primitiiviset tyypit alkavat isolla kirjaimella.
5. Primitiivityypin koko riippuu tietotyypistä, kun taas ei-primitiivisillä tyypeillä on sama koko.

TechCodeview

Ei-primitiiviset tietotyypit Javassa

Avainkohdat:

Ei-primitiivisten tietotyyppien tyypit

1. Luokka ja objektit:

2. Käyttöliittymä:

Huomautus: Jos luokka toteuttaa rajapinnan, sen on toteutettava kaikki kyseisen rajapinnan menetelmät. Jos ei, meidän on julistettava luokka abstraktiksi.

3. Merkkijono:

4. Taulukko:

Ero primitiivisten ja ei-primitiivisten tietotyyppien välillä Javassa