Nous allons revenir à présent sur l’instanciation d’un objet. Comme nous venons de le voir, nous utilisons le mot clé new pour créer une instance d’un objet. C’est lui qui permet la création d’un objet. Il appelle le constructeur correspondant. Si aucun constructeur n’existe, il ne se passera rien de plus qu’une création de base. Par exemple :
Code : C#
Voiture voitureNicolas = new Voiture();
Pour rentrer un peu dans la technique, au moment de l’instanciation d’un objet, l’opérateur new crée l’objet et le met à une place disponible en mémoire. Cette adresse mémoire est conservée dans la variable voitureNicolas. On dit que
voitureNicolas contient une référence vers l’objet. Nous verrons un peu plus tard ce que cela implique.
Ce principe ressemble un peu au « pointeur » que nous pourrions trouver dans des langages comme le C ou le C++. Mais typiquement, si vous savez ce qu’est un pointeur, vous pouvez vous représenter une référence comme un pointeur évolué.
Comme pour les types que nous avons vus plus haut, nous sommes obligés d’initialiser un objet avant de l’utiliser. Sinon, Visual C# Express nous génèrera une erreur de compilation. Par exemple, les instructions suivantes :
Code : C#
Voiture voitureNicolas; voitureNicolas.Vitesse = 5;
provoqueront l’erreur de compilation suivante : Code : Console
Utilisation d'une variable locale non assignée 'voitureNicolas'
En effet, Visual C# Express est assez intelligent pour se rendre compte que l’on va essayer d’accéder à un objet qui n’a pas été initialisé.
Il faut toujours initialiser une variable avant de pouvoir l’utiliser. Comme pour les types précédents, il est possible de dissocier la déclaration d’un objet de son instanciation, en écrivant les instructions sur plusieurs lignes, par exemple :
Code : C#
Voiture voitureNicolas;
// des choses
voitureNicolas = new Voiture();
ceci est possible tant que nous n’utilisons pas la variable voitureNicolas avant de l’avoir instanciée.
Les objets peuvent également avoir une valeur nulle. Ceci est différent de l’absence d’initialisation car la variable est bien initialisée et sa valeur vaut « nul ». Ceci est possible grâce à l’emploi du mot-clé null.
Code : C#
Voiture voitureNicolas = null;
Attention, il est par contre impossible d’accéder à un objet qui vaut null. Eh oui, comment voulez-vous vous asseoir sur une chaise qui n’existe pas ?
Eh bien vous vous retrouverez avec les fesses par terre, personne ne vous a indiqué que la chaise n’existait pas.
C’est pareil pour notre application, si nous tentons d’utiliser une voiture qui n’existe pas, nous aurons droit à un beau plantage. Par exemple, avec le code suivant :
Code : C#
Voiture voitureNicolas = null; voitureNicolas.Vitesse = 5;
Comme nous l’avons déjà vu, le programme nous affiche une exception ; nous avons dit que c’était simplement une erreur qui faisait planter notre programme.
Pas bien ! Surtout que cela se passe au moment de l’exécution. Nous perdons toute crédibilité ! Ici, le programme nous dit que la référence d’un objet n’est pas définie à une instance d’un objet. Concrètement, cela veut dire que nous essayons de travailler sur un objet null.
Pour éviter ce genre d’erreur à l’exécution, il faut impérativement instancier ses objets, en utilisant l’opérateur new, comme nous l’avons déjà vu.
Il n’est cependant pas toujours pertinent d’instancier un objet dont on pourrait ne pas avoir besoin. Le C# nous offre donc la possibilité de tester la nullité d’un objet. Il suffit d’utiliser l’opérateur de comparaison « == » en comparant un objet au mot-clé
null, par exemple : Code : C#
string prenom = "Nicolas"; Voiture voiture = null;
if (prenom == "Nicolas")
voiture = new Voiture { Vitesse = 50 };
if (voiture == null) {
Console.WriteLine("Vous n'avez pas de voiture"); }
else
{
voiture.Rouler(); }
Ainsi, seul Nicolas possédera une voiture et le test de nullité sur l’objet permet d’éviter une erreur d’exécution si le prénom est différent.
Maintenant que vous connaissez le mot-clé null et que vous savez qu’un objet peut prendre une valeur nulle, nous allons revenir sur un point que j’ai rapidement abordé auparavant.
Je ne sais pas si vous vous en rappelez, mais lors de l’étude des opérateurs logiques j’ai parlé du fait que l’opérateur OU ( || ) évaluait la première condition et si elle était vraie alors il n’évaluait pas la suivante, considérant que de toutes façons, le résultat allait être vrai.
Code : C#
if (voiture == null || voiture.Couleur == "Bleue") {
// faire quelque chose
}
Dans ce cas, si la voiture est effectivement nulle, alors le fait d’évaluer la propriété Couleur de la voiture devrait renvoyer une erreur. Heureusement, le C# avait prévu le coup, si la première condition est vraie alors la seconde ne sera pas évaluée, ce qui évitera l’erreur. Ainsi, nous sommes sûrs de n’avoir aucune voiture bleue.
Il est par contre évident qu’une telle condition utilisant l’opérateur ET (&&) est une hérésie car pour que la condition soit vraie, le C# a besoin d’évaluer les deux opérandes. Et donc si la voiture est nulle, l’utilisation d’une propriété sur une valeur nulle renverra une erreur.
Notons également que lorsque nous utilisons l’opérateur ET (&&) si la première opérande est fausse, alors de la même façon, il n’évalue pas la seconde, car pour que la condition soit vraie il faut que les deux le soient.
Ce qui fait qu’il est également possible d’écrire ce code : Code : C#
if (voiture != null && voiture.Couleur == "Rouge") {
// faire autre chose
}
qui ne provoquera pas d’erreur à l’exécution, même si voiture vaut null car dans ce cas, le fait que le premier test soit faux évitera le test de l’autre partie de l’expression.
Vous verrez que vous aurez l’occasion d’utiliser le mot-clé null régulièrement.