I tipi di dati definiscono il tipo di dati archiviati nella variabile. Il tipo specifica il tipo di dati (dimensioni e valori diversi).
Il linguaggio di programmazione Java ha due tipi di tipi di dati
- Tipi di dati non primitivi
A differenza dei tipi di dati primitivi, questi non sono predefiniti. Questi sono tipi di dati definiti dall'utente creati dai programmatori. Questi tipi di dati vengono utilizzati per archiviare più valori.
ribasso con immagini
Consideriamo ad esempio un array che memorizza un gruppo di valori. La classe è anche un tipo primitivo che memorizza diversi metodi e variabili. Pertanto, questi sono anche chiamati come tipi di dati avanzati a Giava.
Ogni volta che viene definito un tipo di dati non primitivo, si riferisce a una posizione di memoria in cui i dati sono archiviati nella memoria heap, ovvero si riferisce alla posizione di memoria in cui viene posizionato un oggetto. Pertanto, viene chiamata anche una variabile di tipo dati non primitivo tipo di dati di riferimento O semplicemente variabile di riferimento dell'oggetto .
Una variabile di riferimento di un oggetto risiede nella memoria dello stack e l'oggetto a cui punta risiede sempre nella memoria dell'heap. Lo stack contiene un puntatore all'oggetto nell'heap.
Nella programmazione Java, tutti i tipi di dati non primitivi sono semplicemente chiamati oggetti creati istanziando una classe.
Punti chiave:
- Il valore predefinito di qualsiasi variabile di riferimento è null.
- Ogni volta che passiamo un tipo di dati non primitivo a un metodo, passiamo l'indirizzo di quell'oggetto in cui sono archiviati i dati.
Tipi di tipi di dati non primitivi
Esistono cinque tipi di tipi di dati non primitivi in Java. Sono i seguenti:
- Classe
- Oggetto
- Corda
- Vettore
- Interfaccia
1. Classe e oggetti:
UN classe in Java è un tipo di dati definito dall'utente, ovvero viene creato dall'utente. Agisce come un modello per i dati costituito da variabili e metodi membro.
UN oggetto è la variabile della classe, che può accedere agli elementi della classe, ovvero metodi e variabili.
Esempio:
ordine lessicografico
Nell'esempio seguente, stiamo creando una classe contenente le variabili e i metodi ( aggiungi() e sub() ). Qui accediamo ai metodi utilizzando l'oggetto della Classe ogg .
EsempioClass.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(); } }Produzione:
Addition of numbers is: 30 Subtraction of numbers is: 10
2. Interfaccia:
UN interfaccia è simile a una classe, tuttavia l'unica differenza è che i suoi metodi sono astratti per impostazione predefinita, ovvero non hanno un corpo. Un'interfaccia ha solo le variabili finali e le dichiarazioni dei metodi. È anche chiamata classe completamente astratta.
tipo variabili java
Nota: se la classe implementa un'interfaccia, deve implementare tutti i metodi di quell'interfaccia. In caso contrario, dobbiamo dichiarare la classe come astratta.
Esempio:
Nell'esempio seguente creiamo l'interfaccia CalcInterface con due metodi astratti ( moltiplica() e dividi() ). Qui, la classe InterfaceExample implementa l'interfaccia e definisce ulteriormente i metodi di tale interfaccia. Quindi, l'oggetto della classe viene utilizzato per accedere a tali metodi.
Esempio di interfaccia.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. Stringa:
Una stringa rappresenta una sequenza di caratteri, ad esempio 'Javatpoint', 'Hello world', ecc. String è la classe di Java.
Uno dei modi per creare una stringa e memorizzare un valore al suo interno è mostrato di seguito:
String str = 'You're the best';
Qui, variabile di tipo String stra ha il valore 'Sei il migliore'. Clicca qui per saperne di più Stringa in Java .
Esempio:
algoritmi di ordinamento per inserzione
Nell'esempio seguente, stiamo creando una stringa con un valore. Qui stiamo utilizzando uno dei metodi della classe String, sottostringa() che stampa la parte indicizzata specificata della stringa.
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); } }Produzione:
Hello! This is
4. Serie:
UN vettore è un tipo di dati che può memorizzare più variabili omogenee, ovvero variabili dello stesso tipo in una sequenza. Vengono archiviati in modo indicizzato a partire dall'indice 0. Le variabili possono essere tipi di dati primitivi o non primitivi.
scarica youtube con vlc
L'esempio seguente mostra come dichiarare un array di tipo di dati primitivo int :
int [ ] marks;
L'esempio seguente mostra come dichiarare un array di tipo dati non primitivo:
Student [ ] students;
Dove, Alunno è il nome della classe e [ ] crea un array di oggetti studenti .
Esempio:
Nell'esempio seguente, stiamo creando due array di base, in cui uno è inizializzato e l'altro è dichiarato (l'input viene letto dall'utente). Inoltre, stiamo stampando questi array utilizzando il ciclo 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('Enter the numbers (size = 5) :'); 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;>Differenza tra tipi di dati primitivi e non primitivi in Java
- In Java, i tipi di dati primitivi sono definiti dal sistema, tuttavia dobbiamo creare e definire i tipi di dati non primitivi.
- Nel tipo di dati primitivo, le variabili possono memorizzare un solo valore alla volta. Tuttavia, nei tipi di dati non primitivi, è possibile archiviare più valori dello stesso tipo o di tipo diverso o entrambi.
- Tutti i dati per le variabili di tipo primitivo vengono archiviati nello stack mentre, per i tipi di riferimento, lo stack contiene un puntatore all'oggetto nell'heap.
- Un tipo primitivo inizia con una lettera minuscola, mentre i tipi non primitivi iniziano con una lettera maiuscola.
- La dimensione di un tipo primitivo dipende dal tipo di dati, mentre i tipi non primitivi hanno tutti la stessa dimensione.