Mis à jour le 05/10/2017
  • 4 heures
  • Facile

Ce cours est visible gratuitement en ligne.

Vous pouvez être accompagné et mentoré par un professeur particulier par visioconférence sur ce cours.

J'ai tout compris !

Les pré-requis

Connectez-vous ou inscrivez-vous gratuitement pour bénéficier de toutes les fonctionnalités de ce cours !

Ce tutoriel ne partira donc pas de zéro. Cela dit, je vais faire en sorte de ne pas trahir l'esprit du site en permettant à un zéro qui arriverait sur ce tutoriel de ne pas se sentir désorienté et découragé.

Comme je l'ai dit précédemment, JavaFX est une évolution du langage Java. C'est-à-dire que pour créer une application en JavaFX, on code en langage Java mais on utilise de nouvelles fonctionnalités. J'apprendrais dans ce tutoriel à utiliser ces nouvelles fonctionnalités mais il est nécessaire d'avoir certaines connaissances de base en Java. Pas besoin non plus d'être un expert, mais il faut maîtriser les différents concepts que je vais énumérer dans ce chapitre.

Si vous êtes un zéro en Java, vous trouverez ici la liste de tout ce que vous devrez connaître avant de pouvoir vous attaquer à ce tutoriel, je vous indiquerais les chapitres du tutoriel de cysboy sur le langage Java que vous devrez connaitre. Ce que je peux déjà vous dire, c'est que vous devrez impérativement suivre la partie 1 de son tutoriel [Bien commencer en Java], vous y apprendrez les base du langage. Pour ce qui est de la deuxième partie [Java Orienté Objet], je vous indiquerais les chapitres indispensables. Je dirais que vous en avez pour une bonne dizaine de jours pour vous mettre à niveau... Qu'est-ce que dix jours dans une vie ;) .

Si vous connaissez déjà le langage Java, ce chapitre ne sera pour vous qu'un rappel, c'est l'occasion de vous rafraîchir la mémoire si vous n'avez pas codé en Java depuis longtemps ;) . Au moins on se sera mis d'accord sur la base commune de laquelle on part :) .

Variables et méthodes

Vous devez savoir que tout code informatique est composé des éléments de base que sont les variables et les méthodes.

Les variables

Les variables permettent de stocker les informations de votre programme, elles peuvent contenir des valeurs numériques, des entiers, des nombre à virgule, des caractères, etc... Pour déclarer une variable en Java, on utilise la syntaxe suivante :

Type nom_variable = <valeur>;

exemple :

int age = 29;

Les principaux types de variables étant :

  • byte : entiers entre -128 et 127

  • short : entier entre -32768 et 32767

  • int : entier entre -2*109 et 2*109

  • long : entier entre -9*1018 et 9*1018

  • float : nombre à virgule entre -1.4*10-45 et 3.4*1038

  • double : nombre à virgule entre 4.9*10-324 à 1.7*10308

  • boolean : booléen égale à true ou à false;

Vous savez également faire des opérations grâce à ces variables grâce aux opérateurs suivant :

  • + : additionner

  • - : soustraire

  • * : multiplier

  • / : diviser

  • % : opérateur modulo pour récupérer le reste d'une division

Tous ces points sont expliqués dans le chapitre 3 : Les variables et les opérateurs

Les méthodes

Les méthodes sont des blocs d'instructions qui permettent de réaliser un certain nombre d'opérations et éventuellement de retourner un résultat. On peut grâce à elles découper notre code en petits bouts bien organisés. Voici la syntaxe Java pour déclarer une méthode :

Type nom_methode( parametres ){
	//instructions
}

exemple :

float conversion( float francs)
{
	//…
	return euro;
}

Le type de la méthode correspond au type de la valeur qu'elle retourne (ce type est void si elle ne retourne rien) et les paramètres entre parenthèses sont toutes les valeurs d'entrée de la méthode. Une méthode peut avoir autant de paramètres qu'on le souhaite tant qu'ils sont pré-définis.

La description d'une méthode est abordée dans le chapitre 2 : Votre premier programme, puis vous apprenez à créer vos propres méthodes dans le chapitre 7 : TP n°1 : un tableau de conversion Celsus - Farenheit !.

Les conditions et les boucles

Vous êtes capables de créer des conditions logiques de type if...else et switch ainsi que les différents types de boucles.

Les conditions logiques

La syntaxe d'une condition logique est la suivante :

if(condition)
{
	//instructions
}
else
{
	//instructions
}

Ces structures permettent de n'exécuter certaines instructions que sous certaines conditions, c'est un élément fondamental de tout programme informatique. Vous pouvez créer des conditions grâce aux opérateurs logiques suivants :

  • == : tester si deux valeurs sont égales

  • != : tester si deux valeurs sont différentes

  • < : tester si une valeur est inférieure à une autre

  • > : tester si une valeur est supérieure à une autre

  • <= : tester si une valeur est inférieure ou égale à une autre

  • >= : tester si une valeur est supérieure ou égale à une autre

  • && : le ET logique pour tester que deux conditions sont valides

  • || : le OU logique pour vérifier que sur deux conditions, au moins l'une est valide

  • ? : l'opérateur ternaire

Les conditions sont abordées dans le chapitre 5 : Les conditions.

Les boucles

Les boucles sont des blocs d'instructions qui peuvent être répétés plusieurs fois. Il existe trois types de boucles :

  • 1. La boucle while :

    while(<condition>)
    {
    	//instructions
    }
    

    Permet de répéter le bloc d'instructions tant que la condition est vérifiée.

  • 2. La boucle do...while :

    do
    {
    	//instructions
    }while(<condition>);
    

    Permet d'exécuter le bloc d'instructions au moins une fois, puis de le répéter tant que la condition est valide.

  • 3. Et la boucle for :

    for( int i = 0; i < n; i++)
    {
    	//instructions
    }
    

    Permet de répéter n fois le bloc d'instructions.

Les boucles sont vues dans le chapitre 6 : Les boucles

Les tableaux

Les tableaux permettent de stocker plusieurs informations les unes à la suite des autres pour pouvoir y avoir accès plus facilement. Un tableau ne peut stocker qu'un seul type d'information : des entiers, des nombres à virgule, des chaînes de caractères, etc... Vous savez donc déclarer un tableau grâce à la syntaxe suivante :

Type[] nom_tableau = new Type[taille];
//ou
Type[] nom_tableau = {valeur1, valeur2, valeur3, …};

exemple :

float[] notes = new float[30];

Vous savez à partir de là accéder à chaque case de ce tableau pour lire sa valeur ou la modifier comme ceci :

nom_tableau[numero_case] = valeur; //écriture
valeur = nom_tableau[numero_case]; //lecture

Tout ce que vous avez à savoir sur les tableaux est dans le chapitre 8 : Les tableaux

La programmation Orientée Objet

Savoir créer et utiliser des objets en Java est absolument fondamental, c'est également le cas en JavaFX. Quand on crée une application en JavaFX, chaque élément de notre interface graphique est un objet, il faut donc bien connaître les bases de la programmation orientée objet (POO) pour coder en JavaFX :) .

La deuxième partie du tutoriel de cysboy Java Orienté Objet y est consacrée. Cette deuxième partie est très riche et très complète et il n'est pas nécessaire de connaître tous les concepts qui y sont abordés pour savoir créer des applications en JavaFX, même si c'est très intéressant et très utile :) . Je vais donc indiquer ici les éléments de base de la POO qui sont vraiment indispensables avec les chapitres correspondants.

Les classes et les objets

Comme on peut s'en douter, savoir déclarer et utiliser un objet est le minimum requis. La syntaxe qui permet de déclarer et de construire un objet en Java est la suivante :

Type mon_objet = new Type();

On appelle la méthode Type() le constructeur de l'objet. Une fois déclaré et construit, nous pouvons avoir accès aux variables, méthodes et autres paramètres qui définissent cet objet de la façon suivante :

mon_objet.variable1;
mon_objet.methode1();
//etc...

C'est de cette façon que l'on manie les objets, qu'on modifie leurs paramètres, qu'on utilise leurs méthodes...
Il existe des types d'objets tout-fait comme le type String, mais il est aussi possible de définir nos propres types d'objets grâce aux classes. C'est en créant une classe que l'on définit toutes les variables et les méthodes qui constitueront notre type d'objet. Voici la syntaxe qui permet de définir une classe :

class Nom_classe{
	Nom_classe()
	{
		//instructions du constructeur
	}
	Type variable1;
	Type variable2;
	Type methode1()
	{
		//instructions
	}
	Type methode2()
	{
		//instructions
	}
}

La première méthode définit dans la classe : Nom_classe(), est le constructeur de la classe, c'est elle qui est appelée à chaque fois qu'un objet de type Nom_classe est construit.

Tout ce qu'il faut savoir sur les classes et les objets est expliqué dans le chapitre 1 de la deuxième partie : Les premiers pas en "Orienté Objet".

L'héritage

Vous devez savoir qu'en Java (comme dans beaucoup de langages orientés objet), il possible pour une classe d'hériter d'une autre classe, c'est-à-dire de reprendre toutes les variables, méthodes et divers paramètres qui définissent la classe mère dont elle hérite et d'y ajouter ses propres paramètres. Voici la syntaxe qui permet à une classe d'hériter d'une classe mère :

class Ma_classe extends Classe_mere{
	//définition de la classe fille
}

Le mécanisme de l'héritage est très utilisé en JavaFX. A chaque fois que nous créerons un type d'objet graphique quelconque, nous devrons faire hériter la classe qui définit cet objet de la classe Parent. Nous pourrons ainsi appliquer à notre objet toutes sortes d'actions, d'effets, de transformations... Bref, gardons cela pour plus tard ;). Le mécanisme de l'héritage est expliqué dans le chapitre 2 de la deuxième partie : L'héritage.

Les exceptions

Le mécanisme des exceptions est important à connaître. Une exception est un événement qui se déclenche quand une opération ne peut être gérée. Il peut arriver qu'une instruction ne se déroule pas comme elle le devrait, dans ce cas le langage Java permet de gérer cette défaillance. Pour gérer l'exception que pourrait déclencher un certain bloc d'instructions, on peut l'insérer dans une structure de type try{} catch{}, comme ceci :

try{
	//instructions pouvant engendrer une exception
}catch(Exception e){
	//instructions à exécuter en cas d'exception
}

Le fonctionnement des exceptions est décrit dans le chapitre 6 de la deuxième partie : Les exceptions.

Voilà ! Si vous avez lutté pour ne pas vous endormir en lisant ce chapitre tellement ce que je disais vous paressait évident, vous êtes prêt pour attaquer le langage JavaFX. Si certains concepts ne vous semblaient pas clairs, vous pouvez toujours réviser en allant voir les chapitres indiqués. Et si vous partez de zéro en Java, je récapitule tous les chapitres que vous devrez intégrer :

Ça vous fait en tout douze chapitres à intégrer. Bien sûre, rien ne vous empêche de lire l'intégralité du tutoriel, vous pourrez même y revenir après avoir appris à coder en JavaFX, cela améliorera la performance et l'efficacité de vos futures programmes ;) .
A partir du prochain chapitre, je considérerais que vous savez coder en Java et que vous connaissez les bases de ce langage que je viens d'énumérer :) .

Exemple de certificat de réussite
Exemple de certificat de réussite