Datové typy definují typ dat, která jsou uložena v proměnné. Typ určuje druh dat (různé velikosti a hodnoty).

Programovací jazyk Java má dva typy datových typů

1. Neprimitivní datové typy

   Na rozdíl od primitivních datových typů nejsou tyto předdefinované. Jedná se o uživatelsky definované datové typy vytvořené programátory. Tyto datové typy se používají k ukládání více hodnot.

   velikost pythonu

   Zvažte například pole, které ukládá skupinu hodnot. Třída je také primitivní typ, který ukládá různé metody a proměnné. Proto se také nazývají jako pokročilé datové typy v Javě.

   Kdykoli je definován neprimitivní datový typ, odkazuje na paměťové místo, kde jsou data uložena v paměti haldy, tj. odkazuje na paměťové místo, kde je umístěn objekt. Proto se také nazývá proměnná typu neprimitivních dat odkazovaný datový typ nebo jednoduše objektová referenční proměnná .

   Referenční proměnná objektu žije v paměti zásobníku a objekt, na který ukazuje, vždy žije v paměti haldy. Zásobník obsahuje ukazatel na objekt na hromadě.

   V programování Java se všechny neprimitivní datové typy jednoduše nazývají objekty, které jsou vytvořeny vytvořením instance třídy.

   Klíčové body:

   1. Výchozí hodnota jakékoli referenční proměnné je null.
   2. Kdykoli předáváme metodě neprimitivní datový typ, předáváme adresu tohoto objektu, kde jsou data uložena.

   Typy neprimitivních datových typů

   V Javě existuje pět typů neprimitivních datových typů. Jsou následující:

   1. Třída
   2. Objekt
   3. Tětiva
   4. Pole
   5. Rozhraní

   1. Třída a předměty:

   A třída v Javě je uživatelsky definovaný datový typ, tj. je vytvořen uživatelem. Funguje jako šablona pro data, která se skládají z členských proměnných a metod.

   An objekt je proměnná třídy, která má přístup k prvkům třídy, tj. metodám a proměnným.

   Příklad:

   velikost lžičky

   V následujícím příkladu vytváříme třídu obsahující proměnné a metody ( add() a sub() ). Zde přistupujeme k metodám pomocí objektu třídy 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('Addition of numbers is: ' + c); } public void sub () { int c = a - b; System.out.println('Subtraction of numbers is: ' + 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(); } } 

   Výstup:

    Addition of numbers is: 30 Subtraction of numbers is: 10 

   2. Rozhraní:

   An rozhraní je podobná třídě, ale jediný rozdíl je v tom, že její metody jsou ve výchozím nastavení abstraktní, tj. nemají tělo. Rozhraní má pouze konečné proměnné a deklarace metod. Nazývá se také plně abstraktní třída.

   np.unikátní

   Poznámka: Pokud třída implementuje rozhraní, musí implementovat všechny metody tohoto rozhraní. Pokud ne, musíme třídu deklarovat jako abstraktní.

   Příklad:

   V následujícím příkladu vytváříme rozhraní CalcInterface dvěma abstraktními metodami ( multiply() a division() ). Zde třída InterfaceExample implementuje rozhraní a dále definuje metody tohoto rozhraní. Potom je objekt třídy použit pro přístup k těmto metodám.

   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('Multiplication of numbers is: ' + c); } public void divide() { int c = a / b; System.out.println('Division of numbers is: ' + c); } // main method public static void main (String[] args) throws IOException { InterfaceExample obj = new InterfaceExample(); // calling the methods obj.multiply(); obj.divide(); } } 

   3. Řetězec:

   Řetězec představuje posloupnost znaků, například 'Javatpoint', 'Hello world' atd. String je třída Javy.

   Jeden ze způsobů, jak vytvořit řetězec a uložit do něj hodnotu, je uveden níže:

    String str = 'You're the best'; 

   Zde proměnná typu String str má hodnotu „Jsi nejlepší“. Kliknutím sem získáte další informace o Řetězec v Javě .

   Příklad:

   java fazole

   V následujícím příkladu vytváříme řetězec s hodnotou. Zde používáme jednu z metod třídy String, podřetězec() který vytiskne zadanou indexovanou část řetězce.

   StringExample.java

    public class StringExample { public static void main(String[] args) { // creating a string and initializing it String str = 'Hello! This is example of String type'; // applying substring() on above string String subStr = str.substring(0,14); // printing the string System.out.println(subStr); } } 

   Výstup:

    Hello! This is 

   4. Pole:

   An pole je datový typ, který může ukládat více homogenních proměnných, tj. proměnných stejného typu v sekvenci. Jsou uloženy indexovaným způsobem počínaje indexem 0. Proměnné mohou být buď primitivní nebo neprimitivní datové typy.

   Následující příklad ukazuje, jak deklarovat pole primitivního datového typu int :

    int [ ] marks; 

   Následující příklad ukazuje, jak deklarovat pole neprimitivního datového typu:

    Student [ ] students; 

   kde, Student je název třídy a [ ] vytváří pole objektů studentů .

   seznam do pole java

   Příklad:

   V následujícím příkladu vytváříme dvě základní pole, ve kterých je jedno inicializováno a druhé deklarováno (vstup je čten od uživatele). Dále tato pole tiskneme pomocí cyklu for.

   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;>

   Rozdíl mezi primitivními a neprimitivními datovými typy v Javě

   1. V Javě jsou primitivní datové typy systémově definované, my však musíme vytvořit a definovat neprimitivní datové typy.
   2. V primitivním datovém typu mohou proměnné uchovávat vždy pouze jednu hodnotu. V neprimitivních datových typech však lze uložit buď více hodnot stejného typu nebo jiného typu, nebo obojí.
   3. Všechna data pro proměnné primitivního typu jsou uložena v zásobníku, zatímco u referenčních typů zásobník obsahuje ukazatel na objekt na hromadě.
   4. Primitivní typ začíná malým písmenem, zatímco neprimitivní typy začínají velkým písmenem.
   5. Velikost primitivního typu závisí na datovém typu, zatímco neprimitivní typy mají všechny stejnou velikost.

   ---