TYPES DE DONNÉES NON PRIMITIFS EN JAVA

Les types de données définissent le type de données stockées dans la variable. Le type spécifie le type de données (différentes tailles et valeurs).

Le langage de programmation Java a deux types de types de données

Types de données non primitifs
Contrairement aux types de données primitifs, ceux-ci ne sont pas prédéfinis. Il s'agit de types de données définis par l'utilisateur et créés par les programmeurs. Ces types de données sont utilisés pour stocker plusieurs valeurs.
types de données primitifs en Java

Par exemple, considérons un tableau qui stocke un groupe de valeurs. La classe est également un type primitif qui stocke différentes méthodes et variables. Par conséquent, ceux-ci sont également appelés types de données avancés en Java.

Chaque fois qu'un type de données non primitif est défini, il fait référence à un emplacement mémoire où les données sont stockées dans la mémoire tas, c'est-à-dire qu'il fait référence à l'emplacement mémoire où un objet est placé. Par conséquent, une variable de type de données non primitive est également appelée type de données référencé ou variable de référence d'objet simplement .

Une variable de référence d'objet réside dans la mémoire de pile et l'objet vers lequel elle pointe réside toujours dans la mémoire tas. La pile contient un pointeur vers l'objet sur le tas.

En programmation Java, tous les types de données non primitifs sont simplement appelés objets créés en instanciant une classe.

Points clés:
1. La valeur par défaut de toute variable de référence est nulle.
2. Chaque fois que nous transmettons un type de données non primitif à une méthode, nous transmettons l'adresse de cet objet où les données sont stockées.
Types de types de données non primitifs

Il existe cinq types de types de données non primitifs en Java. Ils sont les suivants :
1. Classe
2. Objet
3. Chaîne
4. Tableau
5. Interface
1. Classe et objets :

UN classe en Java, il s'agit d'un type de données défini par l'utilisateur, c'est-à-dire qu'il est créé par l'utilisateur. Il agit comme un modèle pour les données composées de variables et de méthodes membres.

Un objet est la variable de la classe, qui peut accéder aux éléments de la classe, c'est-à-dire aux méthodes et aux variables.

Exemple:
exceptions Java

Dans l'exemple suivant, nous créons une classe contenant les variables et les méthodes ( add() et sub() ). Ici, nous accédons aux méthodes en utilisant l'objet de la Classe 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(); } } 
```
Sortir:
```
 Addition of numbers is: 30 Subtraction of numbers is: 10 
```
2.Interface :

Un interface est similaire à une classe mais la seule différence est que ses méthodes sont abstraites par défaut, c'est-à-dire qu'elles n'ont pas de corps. Une interface ne contient que les variables finales et les déclarations de méthode. On l'appelle également une classe entièrement abstraite.
mot-clé statique en Java

Remarque : Si la classe implémente une interface, elle doit implémenter toutes les méthodes de cette interface. Sinon, nous devons déclarer la classe comme abstraite.

Exemple:

Dans l'exemple suivant, nous créons l'interface CalcInterface avec deux méthodes abstraites ( multiplier() et diviser() ). Ici, la classe InterfaceExample implémente l'interface et définit plus en détail les méthodes de cette interface. Ensuite, l'objet de classe est utilisé pour accéder à ces méthodes.

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. Chaîne :

Une chaîne représente une séquence de caractères par exemple 'Javatpoint', 'Hello world', etc. String est la classe de Java.

L'une des façons de créer une chaîne et d'y stocker une valeur est présentée ci-dessous :
```
 String str = &apos;You&apos;re the best&apos;; 
```
Ici, variable de type String str a la valeur « Tu es le meilleur ». Cliquez ici pour en savoir plus sur Chaîne en Java .

Exemple:
classe abstraite en Java

Dans l'exemple suivant, nous créons une chaîne avec une valeur. Ici, nous utilisons l'une des méthodes de la classe String, sous-chaîne() qui imprime la partie indexée spécifiée de la chaîne.

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); } } 
```
Sortir:
```
 Hello! This is 
```
4. Tableau :

Un tableau est un type de données qui peut stocker plusieurs variables homogènes, c'est-à-dire des variables du même type dans une séquence. Elles sont stockées de manière indexée en commençant par l'index 0. Les variables peuvent être des types de données primitifs ou non primitifs.
où puis-je trouver les paramètres de mon navigateur

L'exemple suivant montre comment déclarer un tableau de type de données primitif int :
```
 int [ ] marks; 
```
L'exemple suivant montre comment déclarer un tableau de type de données non primitif :
```
 Student [ ] students; 
```
où, Étudiant est le nom de la classe et [ ] crée un tableau d'objets étudiants .

Exemple:

Dans l'exemple suivant, nous créons deux tableaux de base, dans lesquels l'un est initialisé et l'autre est déclaré (l'entrée est lue par l'utilisateur). De plus, nous imprimons ces tableaux en utilisant la boucle 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;>
```
Différence entre les types de données primitifs et non primitifs en Java
1. En Java, les types de données primitifs sont définis par le système, mais nous devons créer et définir les types de données non primitifs.
2. Dans le type de données primitif, les variables ne peuvent stocker qu'une seule valeur à la fois. Cependant, dans les types de données non primitifs, plusieurs valeurs du même type ou de type différent, ou les deux, peuvent être stockées.
3. Toutes les données des variables de type primitif sont stockées sur la pile alors que, pour les types référence, la pile contient un pointeur vers l'objet sur le tas.
4. Un type primitif commence par une lettre minuscule, tandis que les types non primitifs commencent par une lettre majuscule.
5. La taille d'un type primitif dépend du type de données, tandis que les types non primitifs ont tous la même taille.

TechCodeview

Types de données non primitifs en Java

Points clés:

Types de types de données non primitifs

1. Classe et objets :

2.Interface :

Remarque : Si la classe implémente une interface, elle doit implémenter toutes les méthodes de cette interface. Sinon, nous devons déclarer la classe comme abstraite.

3. Chaîne :

4. Tableau :

Différence entre les types de données primitifs et non primitifs en Java