Et si on dansait un peu ?

Je vous invite à ouvrir le bal en évoquant un peu la "philosophie" de Java, qui a été conçu pour répondre à trois impératifs : la simplicité, la portabilité, et l'exigence d'être un LOO (langage orienté objet) le plus "pur" possible dans le respect des deux exigences précédentes. La simplicité, elle est incontestablement au rendez-vous : à mon humble avis, aucun autre langage moderne de haut niveau n'est aussi accessible aux débutants. La portabilité aussi : une des particularités de Java est que les programmes sont compilés dans un code intermédiaire (bytecode) indépendant de la plateforme d'exécution, où il sera interprété par une machine virtuelle (JVM) spécifique à chaque environnement. Le développeur Java est donc totalement libéré des considérations de portabilité. Partout où une JVM existe, un programme Java a sa place, et ça va de nos ordinateurs aux systèmes embarqués de nos voitures, en passant par bon nombre d'appareils électroniques divers et variés : la portabilité contribue évidemment à la polyvalence.

Qu'en est-il de la "pureté" du paradigme objet de Java ? Sur ce point, la réponse est moins tranchée. Dans un langage objet pur, il n'existe que des objets (des entités qui regroupent les données et les fonctions qui les manipulent) et rien d'autre. Java s'en approche, mais ses concepteurs (sans doute pour éviter une certaine lourdeur dans le codage...) ont préféré conserver quelques types "primitifs" qui ne sont pas des objets. Comparaison (qui ne préférera pas la première version ?) :

// utilisation d'un type primitif (char)
char c = 'x';
// utilisation de son équivalent objet (Character)
Character c = new Character(c);
// le résultat est le même

A garder en mémoire aussi : Java est un langage fortement typé, ce qui signifie que le type de toute donnée doit être explicité ! A de rares exceptions près, il n'est jamais inféré à partir du contexte. C'est une contrainte, certes, mais elle permet de lever beaucoup de doutes et d'ambiguïtés.

[ à suivre ]

 tu commences trop fort, Moi ya na pa comprendu

Je suppose que // au début veut dire explication donc qui n'interfère pas avec le code proprement dit

Que veut dire char ?
Est-ce que c'est pour initialiser la variable C
Qu'est-ce que un type primitif ?
C'est quoi ce 'x';
Il faudrait explicader toute cette syntaxe de symbole chiadique 

Ne t'inquiète pas, les explications vont venir... Le morceau de code que j'ai mis était, à ce stade, seulement destiné à illustrer le fait que la syntaxe est beaucoup plus lourde avec un type objet (comme Character) qu'avec un type primitif (comme char), pas forcément à être compris en détail ! Je vais quand même répondre à tes questions, bien sûr...

Comme tu l'as deviné, tout ce qui suit (sur la même ligne) la double barre oblique // est considéré comme du commentaire, et est ignoré lors de la compilation.

char est le type primitif (c'est-à-dire non-objet) qui correspond à un caractère.

Merci pour la première leçon

En Java, les objets mènent la danse, parce que tout est objet, à l'exception des quelques types primitifs, au nombre de huit :
- boolean qui peut prendre les valeurs true ou false
- char (un caractère)
- byte, short, int, long (types de nombres entiers qui diffèrent par l'intervalle des valeurs acceptables)
- float, double (types de nombres à virgule qui diffèrent, de la même façon, par l'intervalle des valeurs acceptables)
La valeur d'une variable ayant un type primitif est définie par une simple affection avec le signe =, par exemple : int i = 3;
Le type String est un peu hybride, c'est un type objet, mais dont la valeur peut être définie par affectation directe : String s = "Hello !";
Ce sont les seules exceptions à l'omniprésence des objets !

Mais c'est quoi un "objet" [1] ? C'est une brique logicielle qui regroupe (on parle d'encapsulation) des données pertinentes pour ce qu'elle modélise, et les fonctions pour les manipuler. Les données d'un objet sont appelées attributs ou propriétés, les fonctions sont appelées méthodes. Le point de départ du processus de développement en Java consiste à réfléchir à la conception de ces briques logicielles, et à la façon de les articuler entre elles pour obtenir le résultat souhaité. Si cette conception est pertinente, si l'essentiel a été correctement pensé, alors l'écriture du code est en général fluide et ne pose pas de problème majeur !

[1] Le terme "objet" est en fait ambigu, parce qu'on a trop souvent tendance à l'employer indifféremment pour deux choses différentes :
- le "schéma de construction" appelé classe
- et une entité construite selon ce schéma, qu'on appelle une instance de cette classe 

Un exemple va suivre qui devrait (je l'espère...) clarifier un peu tout ça ! En attendant, si vous avez des questions, n'hésitez surtout pas !

:salut:Ca se complique

Comme promis, un premier exemple pour illustrer et clarifier la notation d'objet en Java. Nous allons modéliser une personne, avec son prénom, son nom, sa profession (des chaînes de caractères) et son année de naissance (un nombre entier) – ce seront les attributs – et la possibilité de simuler une reconversion (changement de profession) et de calculer son âge (année courante – année courante) – ce seront les méthodes.

Nous allons donc écrire une classe, avec la déclaration de 4 attributs et et la définition de 2 méthodes, de la façon suivante :


Le mot-clé qui précède le nom d'une méthode est le type de la valeur qu'elle renvoie (int pour âge) ou void si elle ne renvoie aucune valeur (reconversion).
Tout les éléments sont dotés du qualificatif public, pour les rendre accessibles partout ailleurs dans le programme.

Voici une capture d'écran du code complet de la classe Personne (le nom d'une classe commence toujours par une majuscule).
[ Ne vous préoccupez pas pour l'instant de la ligne qui commence par import, ni de la façon bizarre dont l'âge est calculé... ]

Cette classe étant créée, n'importe où ailleurs dans le programme on peut créer une "personne" (une instance de la classe Personne) : 


Et donner une valeur a ses attributs :


Deux choses à noter :
– le nom de la classe (Personne) est aussi le type de l'instance (p1)
– pour accéder à un attribut, on utilise la syntaxe p1.nom_attribut (ce sera la même chose pour une méthode)

Ensuite on peut s'amuser à changer la profession de p1 et à calculer son âge, en faisant quelques affichages !
[ System.out.println est ce qui permet d'afficher quelque chose sur la console de sortie... ]


Le résultat de ce qui précède est :


Ça marche !!! 

[ à suivre ]

Alors oui, ça marche, mais c'est pourtant l'exemple typique de ce qu'il ne faut surtout pas faire, pour deux raisons !
La première est la possibilité d'accéder à l'instance p1 avant d'avoir donné une valeur à ses attributs, avec un résultat forcément inattendu...
La deuxième est que les attributs étant totalement accessibles à cause de leur statut "public", il est peut (par exemple) de modifier a posteriori la date de naissance de la personne, ce qui évidemment ne devrait pas être possible !

Démonstration de ces deux problèmes :


Le résultat serait :


Ce n'est évidemment pas satisfaisant...
Nous allons résoudre ces deux problèmes l'un après l'autre !

[ à suivre ]

Pour éviter d'avoir une instance avec des attributs non-initialisés, nous allons avoir recours aux [Vous devez être inscrit et connecté pour voir ce lien].
Pour éviter les modifications intempestives de certains attributs, nous allons en modifier les droits d'accès.