Types de données (C# et Java)

Article
01/07/2009

Mise à jour : novembre 2007

Cette rubrique présente quelques-unes des principales similitudes et différences dans la façon dont les données sont représentées, allouées et récupérées par le garbage collector en Java et en C#.

Types de données composés

Le concept d'une classe en tant que type de données composé avec des champs, des méthodes, et des événements est semblable en Java et C#. (L'héritage de classes est discuté séparément dans la rubrique intitulée Héritage et classes dérivées (C# et Java).) C# introduit le concept d'un struct comme type de données composé alloué par pile qui ne prend pas en charge l'héritage. Dans la plupart des autres aspects, les struct sont très semblables aux classes. Ils proposent un moyen facile de regrouper des champs et des méthodes connexes à utiliser dans des boucles serrées et d'autres scénarios où les performances sont importantes.

C# vous permet de créer une méthode de destructeur qui est appelée avant que les instances d'une classe soient récupérées par le garbage collector. En Java, une méthode finalize peut être utilisée pour contenir un code qui nettoie les ressources avant que l'objet ne soit récupéré par le garbage collector. En C#, cette fonction est exécutée par le destructeur de classe. Le destructeur ressemble à un constructeur sans arguments et précédé d'un caractère tilde (~).

Types de données intégrées

C# fournit tous les types de données qui sont disponibles en Java et assure la prise en charge des chiffres non signés et d'un nouveau type virgule flottante 128 bits de haute précision.

Pour chaque type de données primitif en Java, la bibliothèque de classes principale fournit une classe wrapper pour le représenter comme un objet Java. Par exemple, la classe Int32 encapsule le type de données int, et la classe Double encapsule le type de données double.

En revanche, tous les types de données primitifs en C# sont des objets dans l'espace de noms System. Pour chaque type de données, un nom court, ou alias, est fourni. Par exemple, int est le nom court pour System.Int32 et double est l'abréviation de System.Double.

La liste des types de données C# et de leurs alias est fournie dans le tableau suivant. Comme vous le constatez, les huit premiers correspondent aux types primitifs disponibles en Java. Notez toutefois que le boolean de Java est appelé bool en C#.

Nom court	.NET Class	Type	Largeur	Plage (bits)
byte	Byte	Entier non signé	8	0 à 255
sbyte	SByte	Entier signé	8	- 128 à 127
int	Int32	Entier signé	32	- 2 147 483 648 à 2 147 483 647
uint	UInt32	Entier non signé	32	0 à 4294967295
short	Int16	Entier signé	16	- 32 768 à 32 767
ushort	UInt16	Entier non signé	16	0 à 65535
long	Int64	Entier signé	64	- 922337203685477508 à 922337203685477507
ulong	UInt64	Entier non signé	64	0 à 18446744073709551615
float	Single	Type virgule flottante à simple précision	32	-3.402823e38 à 3.402823e38
double	Double	Type virgule flottante à double précision	64	-1.79769313486232e308 à 1.79769313486232e308
char	Char	Caractère Unicode unique	16	Symboles Unicode utilisés dans le texte
bool	Boolean	Type booléen logique	8	True ou false
object	Object	Type de base de tous les autres types
string	String	Séquence de caractères
decimal	Decimal	Type fractionnaire ou intégral précis qui peut représenter des nombres décimaux avec 29 bits significatifs	128	±1,0 × 10e-28 à ±7,9 × 10e28

Étant donné que C# représente tous les types de données primitifs comme des objets, il est possible d'appeler une méthode d'objet sur un type de données primitif. Par exemple :

static void Main()
{
    int i = 10;
    object o = i;
    System.Console.WriteLine(o.ToString());
}

Cela est réalisé à l'aide des conversions boxing et unboxing automatiques. Pour plus d'informations, consultez Conversion boxing et unboxing (Guide de programmation C#).

Constantes

Java et C# permettent tous deux de déclarer une variable dont la valeur est spécifiée au moment de la compilation et ne peut pas être changée pendant l'exécution. Java utilise le modificateur de champ final pour déclarer cette variable, alors que C# utilise le mot clé const. Outre const, C# fournit le mot clé readonly pour déclarer des variables auxquelles une valeur peut être assignée une fois au moment de l'exécution, soit dans l'instruction de déclaration soit dans le constructeur. Après l'initialisation, la valeur d'une variable readonly ne peut pas changer. Un scénario dans lequel les variables readonly sont utiles est lorsque les modules qui ont été compilés séparément doivent partager des données telles qu'un numéro de version. Si le module A est mis à jour et recompilé avec un nouveau numéro de version, le module B peut être initialisé avec cette nouvelle valeur de constante sans devoir être recompilé.

Énumérations

Des énumérations, ou enums, sont utilisées pour grouper des constantes nommées, un peu comme elles sont utilisées en C et C++. Elles ne sont pas disponibles en Java. L'exemple suivant définit une énumération Color simple.

public enum Color
{
    Green,   //defaults to 0
    Orange,  //defaults to 1
    Red,     //defaults to 2
    Blue     //defaults to 3
}

Des valeurs intégrales peuvent également être assignées aux énumérations, comme l'illustre la déclaration enum suivante :

public enum Color2
{
    Green = 10,
    Orange = 20,
    Red = 30,
    Blue = 40
}

L'exemple de code suivant appelle la méthode GetNames du type Enum pour afficher les constantes disponibles pour une énumération. Il assigne ensuite une valeur à une énumération et affiche la valeur.

class TestEnums
{
    static void Main()
    {
        System.Console.WriteLine("Possible color choices: ");

        //Enum.GetNames returns a string array of named constants for the enum.
        foreach(string s in System.Enum.GetNames(typeof(Color)))
        {
            System.Console.WriteLine(s);
        }

        Color favorite = Color.Blue;

        System.Console.WriteLine("Favorite Color is {0}", favorite);
        System.Console.WriteLine("Favorite Color value is {0}", (int) favorite);
    }
}

Sortie

Possible color choices:

Green

Orange

Red

Blue

Favorite Color is Blue

Favorite Color value is 3

Chaînes

Les types de chaîne en Java et C# manifestent un comportement identique, à quelques différences près. Les deux types de chaînes sont immuables, ce qui signifie que les valeurs des chaînes ne peuvent plus être changées une fois les chaînes créées. Dans les deux instances, les méthodes qui semblent modifier le contenu réel d'une chaîne créent en fait une nouvelle chaîne à retourner, et laissent la chaîne d'origine inchangée. Le processus de comparaison de valeurs de chaîne est différent en C# et en Java. Pour comparer des valeurs de chaîne en Java, les développeurs doivent appeler la méthode equals sur un type de chaîne puisque l'opérateur == compare les types référence par défaut. En C#, les développeurs peuvent utiliser les opérateurs == ou != pour comparer directement les valeurs de chaîne. Bien qu'une chaîne soit un type référence en C#, l'opérateur == et != comparera, par défaut, les valeurs de chaîne plutôt que les références.

Comme en Java, les développeurs C# ne doivent pas utiliser le type chaîne pour concaténer des chaînes et éviter de devoir créer de nouvelles classes de chaîne chaque fois que la chaîne est concaténée. À la place, les développeurs peuvent utiliser la classe StringBuilder, qui fonctionne comme la classe StringBuffer de Java.

Littéraux de chaîne

C# permet d'éviter l'utilisation de séquences d'échappement comme "\t" pour tabulation ou "\" pour barre oblique inverse dans les constantes de chaîne. Pour ce faire, il vous suffit de déclarer la chaîne mot pour mot à l'aide du symbole @ pour précéder l'assignation de la valeur de chaîne. Les exemples suivants montrent comment utiliser les caractères d'échappement et comment assigner les littéraux de chaîne :

static void Main()
{
    //Using escaped characters:
    string path1 = "\\\\FileShare\\Directory\\file.txt";
    System.Console.WriteLine(path1);

    //Using String Literals:
    string path2 = @"\\FileShare\Directory\file.txt";
    System.Console.WriteLine(path2);
}

Conversion et casting

Java et C# suivent tous deux des règles similaires pour la conversion automatique et le casting de types de données.

Comme Java, C# prend en charge les conversions de types implicites et explicites. Dans le cas de conversions étendues, les conversions sont implicites. Par exemple, la conversion suivante entre int et long est implicite, comme en Java :

int int1 = 5;
long long1 = int1;  //implicit conversion

Ci-dessous une liste de conversions implicites entre types de données .NET Framework :

Type de source	Type de cible
Byte	short, ushort, int, uint, long, ulong, float, double ou decimal
Sbyte	short, int, long, float, double ou decimal
Int	long, float, double ou decimal
Uint	long, ulong, float, double ou decimal
Short	int, long, float, double ou decimal
Ushort	int, uint, long, ulong, float, double ou decimal
Long	float, double ou decimal
Ulong	float, double ou decimal
Float	double
Char	ushort, int, uint, long, ulong, float, double ou decimal

Vous effectuez un cast des expressions que vous souhaitez convertir explicitement à l'aide de la même syntaxe que Java :

long long2 = 5483;
int int2 = (int)long2;  //explicit conversion

Le tableau suivant répertorie les conversions explicites.

Type de source	Type de cible
Byte	sbyte ou char
Sbyte	byte, ushort, uint, ulong ou char
Int	sbyte, byte, short, ushort, uint, ulong ou char
Uint	sbyte, byte, short, ushort, int ou char
Short	sbyte, byte, ushort, uint, ulong ou char
Ushort	sbyte, byte, short ou char
Long	sbyte, byte, short, ushort, int, uint, ulong ou char
Ulong	sbyte, byte, short, ushort, int, uint, long ou char
Float	sbyte, byte, short, ushort, int, uint, long, ulong, char ou decimal
Double	sbyte, byte, short, ushort, int, uint, long, ulong, char, float ou decimal
Char	sbyte, byte ou short
Decimal	sbyte, byte, short, ushort, int, uint, long, ulong, char, float ou double

Types valeur et référence

C# prend en charge deux sortes de types de variables :

Types valeur

Ce sont les types de données primitifs intégrés, tels que char, int et float, ainsi que des types définis par l'utilisateur déclarés avec struct.
Types référence

Les classes et autres types de données complexes qui sont construits à partir de types primitifs. Les variables de ces types ne contiennent pas d'instance du type, mais une référence à cette instance.

Si vous créez deux variables de type valeur, i et j, comme suit, i et j sont complètement indépendants l'un de l'autre :

int i = 10;
int j = 20;

Ils reçoivent des emplacements de mémoire distincts :

Si vous modifiez la valeur de l'une de ces variables, l'autre n'en sera aucunement affectée. Par exemple, si vous avez une expression telle que la suivante, il n'y a toujours pas de connexion entre les variables :

int k = i;

C'est-à-dire que si vous modifiez la valeur de i, k conservera la valeur que i avait au moment de son assignation.

i = 30;

System.Console.WriteLine(i.ToString());  // 30
System.Console.WriteLine(k.ToString());  // 10

En revanche, les types référence fonctionnent différemment. Par exemple, vous pouvez déclarer deux variables comme suit :

Employee ee1 = new Employee();
Employee ee2 = ee1;

Maintenant, parce que les classes sont des types référence en C#, ee1 est désigné comme étant une référence à Employee. La première des deux lignes précédentes crée une instance de Employee en mémoire et définit ee1 pour la référencer. Ainsi, lorsque vous définissez ee2 pour égaler ee1, elle contient une copie de la référence à la classe en mémoire. Si vous modifiez à présent les propriétés sur ee2, les propriétés sur ee1 reflètent ces modifications, car tous deux pointent vers le même objet en mémoire, comme le montre l'exemple suivant :

Conversions boxing et unboxing

Le processus de la conversion d'un type valeur en un type référence s'appelle la conversion boxing. Le processus inverse, la conversion d'un type référence en un type valeur, s'appelle la conversion unboxing. C'est ce que montre le code suivant :

int i = 123;      // a value type
object o = i;     // boxing
int j = (int)o;  // unboxing

Dans Java, vous devez effectuer ces conversions manuellement. Les types de données primitifs peuvent être convertis en objets de classes wrapper par construction de ces objets, ou par conversion boxing. De même, les valeurs des types de données primitifs peuvent être extraites des objets de classes wrapper en appelant une méthode appropriée sur les objets de ce type ou en effectuant une conversion unboxing. Pour plus d'informations sur les conversions boxing et unboxing, consultez Conversion boxing et unboxing (Guide de programmation C#).

Voir aussi