Types de données non primitifs en Java

Les types de données non primitives sont les types de données en Java qui ont la même taille et fournissent des méthodes supplémentaires pour effectuer certaines opérations ; en bref, les types de données non primitifs en Java font référence à des objets et sont également appelés types de référence ; des exemples de types de données non primitifs disponibles en Java incluent les tableaux, les chaînes, les classes et les interfaces.

Commencez votre cours de développement de logiciels libres

Développement Web, langages de programmation, tests de logiciels et autres

Syntaxe

Vous trouverez ci-dessous la syntaxe montrant comment les types de données non primitifs sont utilisés en Java :

Array : Un tableau en Java est utilisé comme suit :

int[] intArray;                     // declaring array of type int
byte[] byteArray               // declaring array of type byte
long[] longArray;                     // declaring array of type long
short[] shortArray               // declaring array of type short
float[] floatArray;                     // declaring array of type float
long[] longArray               // declaring array of type long
char[] charArray               // declaring array of type char
ClassName[] classArray    // declaring array a particular class
Object[]  objectArray      // declaring array of objects

D'après ce qui précède, nous pouvons voir que nous pouvons créer un tableau de différents types de données ou même des objets et des classes. Notez que dans un tableau, tous les éléments doivent être du même type de données.

String : Une chaîne Java peut être utilisée comme suit :

String str = "Edubca";         // declaring a string in java

Classes : Voici comment une classe Java est créée :

package <package name>;     // declaring package of class
public class <ClassName>{
//contains data and methods
}

Interfaces : Voici comment est créée une interface en java :

package <package name>;     // declaring package of interface
public interface <InterfaceName>{
//contains unimplemented methods and data if needed
}

Types non primitifs en Java

Les types de données suivants sont non primitifs disponibles en Java :

• Array : Un tableau peut être défini comme une collection homogène d'éléments ayant une taille fixe. Les tableaux peuvent stocker une ou plusieurs valeurs appartenant au même type de données, et les éléments individuels d'un tableau sont accessibles via un index. Cela signifie qu'un tableau suit l'approche basée sur l'index pour accéder aux éléments.
• Chaîne : Une chaîne peut être définie comme une séquence de caractères. Une chaîne java est représentée comme un objet de la classe java.lang.String. Pour créer une instance de chaîne en Java, nous devons créer un objet de la classe java.lang.String est une classe immuable et thread-safe.
• Classe : Une classe Java peut être définie comme un plan de données défini par l'utilisateur et utilisé pour créer des objets. Une classe en Java définit un ensemble de propriétés ou de méthodes utilisées pour définir l'état ou le comportement d'un objet.
• Interface : L'interface en Java est utilisée pour fournir une abstraction sur les données. Semblables à une classe, les interfaces contiennent des données et des méthodes, mais les méthodes déclarées à l'intérieur d'une interface sont par défaut abstraites. Les méthodes abstraites sont les méthodes qui ne contiennent personne ; ils ne contiennent que la signature de la méthode.

Exemples de types de données non primitifs en Java

Différents exemples sont mentionnés ci-dessous

Exemple n°1

Dans cet exemple, nous allons montrer comment utiliser un tableau et une chaîne en Java :

import java.util.*;
public class DataTypeDemo {
public static void main(String[] args) {
byte[] byteArray= {88,77,66,55};                 //declaring byte Array
int[] intArray= {20,15,10,4};                    // declaring integer Array
short[] shortArray= {6000,5000,4000,3000};       //declaring short Array
long[] longArray = {20000000000000L,30000000000000L,40000000000000L,50000000000000L};  //declaring long Array
float[] floatArray= {1.1f,1.2f,1.3f,1.4f};            // declaring float Array
double[] doubleArray = {29.94d,19.98d,20,87d};       // declaring double Array
boolean[] booleanArray= {true,false,true, true};       //declaring boolean Array
char[] charArray = {'A','B','C','D'};            // declaring character Array
System.out.println("Array Declared using Byte Data Type is  " + Arrays.toString(byteArray));
System.out.println("Array Declared using Integer Data Type is  " + Arrays.toString(intArray));
System.out.println("Array Declared using Short Data Type is  " + Arrays.toString(shortArray));
System.out.println("Array Declared using Long Data Type is  " + Arrays.toString(longArray));
System.out.println("Array Declared using Float Data Type is  " + Arrays.toString(floatArray));
System.out.println("Array Declared using Double Data Type is  " + Arrays.toString(doubleArray));
System.out.println("Array Declared using Boolean Data Type is  " + Arrays.toString(booleanArray));
System.out.println("Array Declared using Character Data Type is  " + Arrays.toString(charArray));
}
}

Sortie :

Exemple n°2

Dans cet exemple, nous verrons comment les classes et les interfaces sont utilisées en java :

Voici comment une interface est déclarée en java :

// declaring an interface
interface namePrinter{
// declaring abstract method (method without body)
String getName();
}
//creating java class implementing interface namePrinter
public class Main implements namePrinter{
public static void main(String[] args) {
Main main =new Main();
String name=main.getName();
System.out.println("Name returned from getName method is >> " + name );
}
// overriding method of an interface
@Override
public String getName() {
String name ="Edubca";
// TODO Auto-generated method stub
return name;
}
}

Sortie :

Conclusion

Bien comprendre les différents types de données est très important pour apprendre n'importe quel langage de programmation. L'article ci-dessus explique les types en détail avec des exemples et la signification de chaque type de données.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!