Java est un langage de programmation orient\u00e9e objet, cr\u00e9\u00e9 par James Gosling et Patrick Naughton en 1990 pour la compagnie Sun Microsyst\u00e8me (qui a \u00e9t\u00e9 vendu \u00e0 Oracle en 2009).<\/p>\n
Voici les caract\u00e9ristiques principales du langage Java:<\/p>\n
La JDK contient une grande quantit\u00e9 d’outils. Mais nous allons voir les trois (3) outils principaux dans cette section. Il va de soi que cette section ne pr\u00e9sente qu’une base et que ces outils peuvent n\u00e9cessiter beaucoup plus d’options que ceux pr\u00e9sent\u00e9s.<\/p>\n
La commande javac<\/strong> permet la compilation d’une ou plusieurs classes Java. Voici un exemple d’utilisation de la commande javac<\/strong>.<\/p>\n Si les classes sp\u00e9cifi\u00e9es dans la commande utilisent d’autres classes dont le fichier .java est accessible, les autres classes seront \u00e9galement compil\u00e9es. Il n’est donc pas n\u00e9cessaire de sp\u00e9cifier l’enti\u00e8ret\u00e9 des classes du syst\u00e8me dans la ligne de commande. En g\u00e9n\u00e9ral, seule la classe contenant la fonction principale main<\/strong> doit \u00eatre compil\u00e9e.<\/p>\n La commande java<\/strong> permet d’ex\u00e9cuter un programme Java dans la JVM du JDK. Il est important de noter que l’argument de cette commande est le nom de la classe \u00e0 ex\u00e9cuter (contenant la routine principale main<\/strong>), et non le nom du fichier. Voici un exemple d’utilisation de la commande:<\/p>\n La classe sp\u00e9cifi\u00e9e en argument doit avoir pr\u00e9alablement \u00e9t\u00e9 compil\u00e9e par la commande javac<\/strong>.<\/p>\n Si nous souhaitons envoyer des arguments aux programmes, on peut les sp\u00e9cifier apr\u00e8s le nom de la classe. Par exemple:<\/p>\n Les arguments sont accessibles en utilisant le tableau re\u00e7u en argument de la routine principale main<\/strong>.<\/p>\n Pour effectuer du d\u00e9bogage, il est g\u00e9n\u00e9ralement mieux d’avoir une interface graphique. Par contre, il peut arriver qu’il soit important de pouvoir effectuer du d\u00e9bogage en ligne de commande. Par exemple, si l’ordinateur ayant le probl\u00e8me se trouve sur un ordinateur sans \u00e9diteur haut niveau (IDE). Ou bien lorsqu’on veut d\u00e9boguer sur un serveur distant. La commande jdb<\/strong> permet ce d\u00e9bogage en ligne de commande.<\/p>\n Premi\u00e8rement, pour utiliser le d\u00e9bogueur Java, vous devez compiler avec l’option de d\u00e9boguage, c’est \u00e0 dire \u00ab\u00a0-g\u00a0\u00bb:<\/p>\n Ensuite, pour lancer le d\u00e9bogueur, on lance la commande jdb<\/strong> de la m\u00eame mani\u00e8re que nous lancerions la commande java<\/strong>. Par exemple:<\/p>\n ou<\/p>\n Ensuite, on doit mettre un point d’arr\u00eat (ou \u00ab\u00a0breakpoint\u00a0\u00bb) en utilisant la commande stop<\/strong>. On peut arr\u00eater \u00e0 une ligne en particulier comme ceci:<\/p>\n Ou bien on peut arr\u00eater \u00e0 une routine particuli\u00e8re comme ceci:<\/p>\n Une fois le ou les points d’arr\u00eat sont pr\u00e9cis\u00e9s, on peut lancer l’application avec la commande run<\/strong>:<\/p>\n Pour \u00e9valuer le contenu d’une variable, on peut utiliser la commande print<\/strong>:<\/p>\n Pour ex\u00e9cuter une ligne de code, on utilise la commande next<\/strong>:<\/p>\n Pour entrer dans un appel de routine, on utilise la commande step<\/strong>:<\/p>\n \u00c0 noter que si la ligne de code n’est pas une routine, la commande step<\/strong> fait exactement la m\u00eame chose que la commande next<\/strong>. La commande where<\/strong> permet de voir la pile d’ex\u00e9cution de la m\u00e9thode en cours:<\/p>\n Finalement, la commande quit<\/strong> permet de terminer l’ex\u00e9cution du programme et de sortir du d\u00e9bogueur.<\/p>\n En g\u00e9n\u00e9ral, une classe se trouve dans son propre fichier (une classe par fichier) et le nom du fichier doit \u00eatre identique au nom de la classe (sans prendre en compte l’extension \u00ab\u00a0.java\u00a0\u00bb). La syntaxe de base d’une classe Java se fait de la mani\u00e8re suivante:<\/p>\n Prendre en note qu’\u00e0 moins d’avoir une bonne raison de le faire, toutes les classes de fichiers java devraient \u00eatre publiques.<\/p>\n Pour qu’un programme Java puisse \u00eatre ex\u00e9cut\u00e9, il doit y avoir une routine appel\u00e9e main<\/strong>. Cette routine doit avoir la signature suivante:<\/p>\n Utiliser une signature diff\u00e9rente pour une routine principale en Java peut faire en sorte que le programme Java ne d\u00e9marre pas. Il est donc important de bien respecter cette signature. De plus, une fois la routine principale cr\u00e9\u00e9e, pour lancer le programme, il faut lancer la classe compil\u00e9e avec le programme Java.<\/p>\n Il est \u00e0 noter que lorsque nous commencerons \u00e0 programmer en paradigme orient\u00e9 objet, nous devrions avoir tr\u00e8s peu de code \u00e0 l’int\u00e9rieur de cette routine. G\u00e9n\u00e9ralement, on ne fait que lancer un constructeur d’un objet.<\/p>\n Afin d’afficher des messages \u00e0 l’utilisateur et d’obtenir des valeurs de l’utilisateur, il faut utiliser des m\u00e9canismes d’entr\u00e9es\/sorties. Il existe plusieurs m\u00e9canismes d’entr\u00e9es\/sorties en Java. Pour le d\u00e9but de ce cours, nous utiliserons l’entr\u00e9e et la sortie console standard de Java.<\/p>\n Pour afficher un texte \u00e0 l’utilisateur, nous utiliserons l’instruction suivante:<\/p>\n Il est important de noter que cette instruction terminera la ligne inscrite \u00e0 la console. Si vous voulez inscrire une seule ligne de sortie avec plusieurs instructions, on peut utiliser print<\/strong> au lieu de println<\/strong>:<\/p>\n Normalement, nous devrions utiliser la sortie d’erreur afin d’afficher une erreur \u00e0 un utilisateur. \u00c7a permet entre autres de voir les erreurs, m\u00eame lorsque nous utilisons une redirection en ligne de commande. Pour utiliser la sortie d’erreur, on utiliser l’instruction suivante:<\/p>\n Tout comme dans le cas de la sortie standard, on peut \u00e9galement utiliser print<\/strong> au lieu de println<\/strong> pour ne pas terminer la ligne affich\u00e9e.<\/p>\n Voici un exemple:<\/p>\n Si j’utilise ce programme normalement:<\/p>\n J’obtiens le r\u00e9sultat attendu:<\/p>\n Par contre, si je fais une redirection standard:<\/p>\n J’obtiens le r\u00e9sultat suivant dans la ligne de commande:<\/p>\n Et le contenu du fichier \u00ab\u00a0mon_fichier.log\u00a0\u00bb devient:<\/p>\n Pour demander de l’information \u00e0 l’utilisateur, il faut utiliser le \u00ab\u00a0stream\u00a0\u00bb System.in<\/strong>. Par contre, ce \u00ab\u00a0stream\u00a0\u00bb n’est pas utilisable directement (principalement \u00e0 cause de l’absence d’h\u00e9ritage multiple en Java). Pour utiliser System.in<\/strong>, nous devons utiliser un objet utilitaire qui s’occupera de lire l’information. Dans le cadre du cours, je recommande d’utiliser un Scanner<\/strong>. Malgr\u00e9 certains petits d\u00e9fauts, il s’agit de la m\u00e9canique la plus simple d’utilisation. Par contre, si vous pr\u00e9f\u00e9rez une autre m\u00e9thode, libre \u00e0 vous de l’utiliser.<\/p>\n Pour utiliser un Scanner<\/strong>, il faut d’abord l’importer puisque \u00e7a ne fait pas partie d’une classe de base de Java:<\/p>\n En suite, nous instancions l’objet Scanner<\/strong> en y sp\u00e9cifiant System.in<\/strong> comme entr\u00e9e.<\/p>\n Ensuite, nous pouvons utiliser les utilitaires next[Type]<\/strong> pour lire un type quelconque au clavier. Par exemple, nous pouvons utiliser nextInt<\/strong> pour lire un entier, nextFloat<\/strong> pour lire un nombre \u00e0 virgule, etc. Pour lire une ligne compl\u00e8te, nous utilisons nextLine<\/strong>.<\/p>\n Voici un exemple simple d’utilisation des entr\u00e9es\/sorties en Java:<\/p>\njavac MaClasse.java\r\n<\/pre>\n
Java: Lanceur d’application Java<\/h3>\n
java MaClasse\r\n<\/pre>\n
java MaClasse Argument1 Argument2 Argument3\r\n<\/pre>\n
jdb: Le d\u00e9bogueur Java<\/h3>\n
javac -g MaClasse.java\r\n<\/pre>\n
jdb MaClasse\r\n<\/pre>\n
jdb MaClasse Argument1 Argument2 Argument3\r\n<\/pre>\n
stop at MaClasse:17\r\n<\/pre>\n
stop in MaClasse.main\r\n<\/pre>\n
run\r\n<\/pre>\n
print maVariable\r\n<\/pre>\n
next\r\n<\/pre>\n
step\r\n<\/pre>\n
\nPour continuer l’ex\u00e9cution normale du programme (apr\u00e8s qu’un point d’arr\u00eat ait \u00e9t\u00e9 utilis\u00e9), on utilise la commande cont<\/strong>:<\/p>\ncont\r\n<\/pre>\n
where\r\n<\/pre>\n
quit\r\n<\/pre>\n
La syntaxe de Java<\/h2>\n
Syntaxe d’une classe<\/h3>\n
public<\/span> class<\/span> MaClasse<\/span> {<\/span>\r\n\r\n}<\/span>\r\n<\/pre>\n<\/div>\nLa routine principale (\u00ab\u00a0main\u00a0\u00bb)<\/h3>\n
public<\/span> static<\/span> void<\/span> main<\/span>(<\/span>String<\/span>[]<\/span> arguments<\/span>)<\/span><\/pre>\n<\/div>\nLes entr\u00e9es\/sorties console<\/h3>\n
Afficher un texte \u00e0 l’utilisateur<\/h4>\n
System<\/span>.<\/span>out<\/span>.<\/span>println<\/span>(<\/span>\"...\"<\/span>);<\/span>\r\n<\/pre>\n<\/div>\nSystem<\/span>.<\/span>out<\/span>.<\/span>print<\/span>(<\/span>\"...\"<\/span>);<\/span>\r\n<\/pre>\n<\/div>\nAfficher une erreur \u00e0 l’utilisateur<\/h4>\n
System<\/span>.<\/span>err<\/span>.<\/span>println<\/span>(<\/span>\"...\"<\/span>);<\/span>\r\n<\/pre>\n<\/div>\npublic<\/span> class<\/span> Programme<\/span>\r\n{<\/span>\r\n public<\/span> static<\/span> void<\/span> main<\/span>(<\/span>String<\/span>[]<\/span> arguments<\/span>)<\/span> {<\/span>\r\n System<\/span>.<\/span>out<\/span>.<\/span>println<\/span>(<\/span>\"Message standard.\"<\/span>);<\/span>\r\n System<\/span>.<\/span>err<\/span>.<\/span>println<\/span>(<\/span>\"Message d'erreur!\"<\/span>);<\/span>\r\n }<\/span>\r\n}<\/span>\r\n<\/pre>\n<\/div>\njava Programme\r\n<\/pre>\n
Message standard.\r\nMessage d'erreur!\r\n<\/pre>\n
java Programme > mon_fichier.log\r\n<\/pre>\n
Message d'erreur!\r\n<\/pre>\n
Message standard.\r\n<\/pre>\n
Demander de l’information \u00e0 l’utilisateur<\/h4>\n
import<\/span> java.util.Scanner<\/span>;<\/span>\r\n<\/pre>\n<\/div>\nScanner<\/span> lScanner<\/span> =<\/span> new<\/span> Scanner<\/span>(<\/span>System<\/span>.<\/span>in<\/span>);<\/span>\r\n<\/pre>\n<\/div>\nimport<\/span> java.util.Scanner<\/span>;<\/span>\r\n\r\npublic<\/span> class<\/span> Programme<\/span>\r\n{<\/span>\r\n public<\/span> static<\/span> void<\/span> main<\/span>(<\/span>String<\/span>[]<\/span> arguments<\/span>)<\/span> {<\/span>\r\n Scanner<\/span> lScanner<\/span> =<\/span> new<\/span> Scanner<\/span>(<\/span>System<\/span>.<\/span>in<\/span>);<\/span>\r\n String<\/span> lNom<\/span>;<\/span>\r\n int<\/span> lAge<\/span>;<\/span>\r\n System<\/span>.<\/span>out<\/span>.<\/span>print<\/span>(<\/span>\"Entrez votre nom: \"<\/span>);<\/span>\r\n lNom<\/span> =<\/span> lScanner<\/span>.<\/span>nextLine<\/span>();<\/span>\r\n System<\/span>.<\/span>out<\/span>.<\/span>print<\/span>(<\/span>\"Entrez votre \u00e2ge: \"<\/span>);<\/span>\r\n lAge<\/span> =<\/span> lScanner<\/span>.<\/span>nextInt<\/span>();<\/span>\r\n System<\/span>.<\/span>out<\/span>.<\/span>println<\/span>(<\/span>\"Bonjour \"<\/span> +<\/span> lNom<\/span>