Java

Présentation

L’algorithme

Un algorithme est une suite d’instructions à appliquer à un ensemble fini de données. La traduction d’un algorithme en un langage de programmation s’appelle un programme.

Quel est le principe d’un algorithme ? Il utilise des données fournies par l’utilisateur (les entrées), réalise diverses opérations dessus (les traitements) et produit un ou plusieurs résultats (les sorties).

Principe de base :

Plusieurs exécutions d’un algorithme avec les mêmes données d’entrée fourniront toujours le même résultat (l’algorithme est déterministe).

Le programme

Des langages intermédiaires entre l’algorithme et le langage machine ont été développés. Ces langages, appelés langages de haut niveau, ont une grammaire et une syntaxe proches du programmeur. Ils utilisent des termes anglais. Il ne faut cependant pas oublier que l’ordinateur ne connaît que le langage machine. Des outils spéciaux, appelés compilateurs, sont donc chargés de transcrire automatiquement le langage de haut niveau en langage machine.

Le compilateur remplace les termes par d’autres (par exemple le terme multiplier par 001110). C’est une tâche purement mécanique, le compilateur n’a aucune idée de ce que représentent ces termes. Il réalise un travail syntaxique, pas sémantique. Ainsi, si vous écrivez « multiplie » ou « multiplier », il s’arrêtera, ne reconnaissant pas ce terme.
Les langages de hauts niveaux apportent donc plus de souplesse et de lisibilité, mais ils n’en demeurent pas moins sous la contrainte d’un formalisme strict.

Comment s’exécute un programme ? C’est très simple : il exécute la première instruction, puis la deuxième, la troisième et ainsi de suite jusqu’à la dernière. Le programme est alors terminé.

Les différents langages d’implémentation

Il existe plusieurs centaines de langages de programmation si on tient compte de toutes les variantes possibles d’un même langage. L’ordinateur ne comprend nativement qu’un seul langage, le langage machine. Voici divers langages :

Certains langages ont été développés pour être utilisés dans des domaines précis. D’autres langages, tels le Java, sont généralistes.

Certains langages ne sont pas compilés mais interprétés. Pour fonctionner ces programmes nécessitent un interpréteur qui est un autre programme. Il analyse la syntaxe et l’exécute au fur et à mesure. Un langage interprété sera plus lent qu’un langage compilé à cause de la conversion dynamique du programme. On peut citer le PHP.

D’autres utilisent une machine virtuelle. La machine virtuelle est un programme qui permet d’isoler l’application qu’il doit faire tourner du matériel et du système d’exploitation. Le programme conçu pour la machine virtuelle pourra donc fonctionner sur n’importe quel ordinateur. Le Java et le C# utilisent ce principe.

Les normes de développement

Il existe des conventions de codage pour la plupart des langages de programmation. Il existe des variantes d’un langage à l’autre mais les règles de présentation, les conventions de nommage et l’organisation du code sont communs.

Le langage Java

Créé en 1995 par Sun Microsystem et racheté par Oracle en 2009. Le langage le plus utilisé en entreprise depuis quelques années et dans les applications mobile grâce à Android.

Avantages

  • Populaire
  • Portabilité, indépendant de l’OS
  • Langage orienté objet
  • Langage de haut niveau
  • JDK et API tierces très riches
  • Application sécurisées
  • Compilé et multi tâches

Inconvénients

  • non adapté pour des exécutions rapides (plutôt le C ou le JavaScript dans ce cas)
  • interfaces web plus difficile à mettre en place
  • verbeux

Les métiers

 

Les variables

Un souci primordial lors de l’écriture d’un algorithme est sa lisibilité. Il sera lu et corrigé par différentes personnes, c’est pourquoi il est important de respecter la syntaxe et d’y ajouter le maximum de commentaires possibles.

Chaque donnée d’un programme a un nom que l’on appelle un identificateur. Il faut respecter certaines règles pour ce nom soit valide :

  • il est formé d’un seul mot ;
  • il ne peut contenir que des chiffres, des lettres non accentuées (syntaxe anglo-saxonne des compilateurs) et le caractère souligné ( _ ) ;
  • le premier caractère ne peut pas être un chiffre ;
  • il doit être explicite, très utile pour l’humain (ex : prix_ht plutôt que k) ;
  • il doit être unique.

L’espace est un séparateur de mot, il ne peut donc pas être utilisé dans l’identificateur. Le compilateur travaille mot après mot, il considère qu’un identificateur est terminé lorsqu’il rencontre un espace.

Une variable contient une valeur qui peut changer. Chaque variable doit avoir un nom (identifiant) et un type définissant les valeurs qu’elle peut prendre.

Si la variable age est de type entier, elle pourra valoir –9, 45, 987 mais pas 5.5 (réel) .
Les trois variables prix_ttc, taux_tva et prix_ht seront de type réel.
Que se passerait-il si on définissait prix_ttc comme un entier ?

Les types de données

Le type d’une donnée détermine les valeurs qu’elle peut prendre. Les principaux types sont entier, réel, caractère, chaîne de caractère (ou chaîne) et booléen. Il en existe d’autres.

Type Plage de valeurs Exemples de valeurs
Entier simple int -32768 +32767 -58, 0, 328
Entire long long -2147483648 +2147483647
Réel simple précision float -3.4*10~38 à -1.4*10~45

1.4*10~45 à 3.4*10~38

-58, 3.1415, -1.1
Réel double précision double -1.79*10~308 à -4.94*10~324

4.94*10~324 à 1.79*10~308

Caractère char 0-255 ‘c’, ‘7’, ‘ ‘
Chaîne String « oh la belle chaîne ! », «  »
Booléen booleen false – true vrai, faux

Les caractères et les chaînes

  • les caractères des identifiants : on les entoure d’apostrophes. Ainsi, c’est un identificateur, ‘c’ un caractère ;
  • les chaînes des identifiants : on les entoure de guillemets. « Bonjour maman », « maison » sont des chaînes.
  • Une chaîne de longueur 1 (ne contenant qu’un seul caractère) n’est pas assimilable à un caractère. Ainsi, « 7 », ‘7’ et 7 sont trois données de types différents et nullement interchangeables.

Les booléens

Ils permettent de réaliser des tests. Un booléen ne peut prendre que deux valeurs : soit true (vrai) ou false (faux)

La déclaration et l’affectation des variables

Donner le type des variables :

Le code Java suivant ne fonctionne pas, pourquoi ?

Le compilateur javac fournit :

Le transtypage

Le transtypage consiste à indiquer entre parenthèses avant la valeur à affecter le type final de celle-ci.

On peut aussi affecter une variable à une autre variable :

L’affichage

Le caractère saut de ligne :

Le caractère de contrôle « \n » (new ligne, saut de ligne) permet d’aller à la ligne. Ce caractère a la particularité de ne pas avoir de représentation visuelle graphique. La fonction System.out.println inclus le ln pour le retour à la ligne automatiquement.

Comme c’est un caractère, le saut de ligne peut très bien faire partie d’une chaîne. La chaîne sera alors coupée à l’affichage. Ce caractère de contrôle est issu du C.

Écrire le programme qui affiche le prix total ttc en fonction du prix ht, du taux de tva et de la quantité achetée ( on prendra des valeurs au hasard).

Saisir

On peut utiliser sc.nextInt()pour des int par exemple.

Seules les variables de type de base (entier, réel, caractère, chaîne, booléen) peuvent être initialisées par l’utilisateur.

Écrire un programme qui initialise deux variables entières et qui affiche directement la somme de ces deux nombres. N’oubliez pas d’afficher un message à l’utilisateur pour qu’il sache quoi saisir.

 

Les structures conditionnelles

La conditionnelle

Le booléen est la condition de l’instruction si. C’est généralement une expression booléenne.

Les instructions composant le si peuvent elles-mêmes être des si :

Deviens :

Indiquer si un nombre est supérieur à 30.

L’entreprise accorde une remise de 10 % sur le prix ttc pour tout achat de plus de 100 pièces ; écrire le programme calculant le prix ttc en fonction de la quantité, du prix ht et du taux de tva.

L’alternative

Le code ne fonctionne pas, il faut remplacer les chaine par des entiers. La branche default (facultative) permet de regrouper toutes les valeurs qui n’ont pas été énumérées. Si la branche default n’est pas présente et qu’aucune liste ne contient la valeur de l’expression, default n’a aucun effet.

Une agence de voyage propose des réductions sur les billets d’avion de 50€ selon la catégorie de chacun de ses clients. Si les personnes sont dans la catégorie senior, ils ont 50% de réductions. Dans la catégorie nourrisson, le prix du billet est forfaitaire, il sera de 20 euros. Pour les enfants, le prix sera de 30% de celui d’origine.
Écrire le programme qui affiche le prix final pour un client.

 

Les boucles

Tant que

La boucle de type « Tant que » permet la répétition d’un bloc d’instruction tant que la condition testée est vérifiée.

 Répéter … Tant que

Attention : on boucle quand le test est vrai, on s’arrête quand il est faux.

Écrire un programme qui saisit deux entiers et qui incrémente de 1 le premier tant qu’il n’est pas supérieur au deuxième.

Pour

On doit utiliser pour lorsque le nombre d’itérations est connu.

Afficher les nombres de 0 à 10 dans l’ordre décroissant :

Afficher les nombres pairs de 0 à 20 dans l’ordre décroissant

Que fait cette boucle ?

  • Le pas (incrément) de la boucle est donc un entier quelconque, mais il est fixe.
  • Un pas de zéro n’est pas une bonne idée : la boucle ne s’arrêtera jamais.
  • Le pour étant une instruction comme une autre, le corps d’un pour peut très bien contenir un autre pour (ou toute autre boucle).

Afficher pour chaque nombre de 1 à 10 les nombres qui lui précédent .

Pour chaque

La boucle pour chaque permet de faire défiler une collection que nous verrons dans les chapitres suivants.

Voici la même boucle avec la structure for classique

Écrire un programme qui saisit un entier positif.
Écrire un programme qui affiche n fois ‘coucou’, l’entier n sera saisi par l’utilisateur.
Écrire un programme qui saisit un nombre tant qu’il n’est pas égal à 10.
Écrire un programme qui saisit un nombre tant qu’il n’est pas égal à 10 et affiche un message du style ‘ce nombre n’est pas bon’.

Les méthodes

Lorsqu’un problème programme devient complexe, on le décompose en plusieurs sous-problèmes (sous-programmes).

Intérêts

– Réutilisation de la même procédure plusieurs fois au cours d’un programme en faisant un simple appel.
– Résoudre un programme long et complexe en plusieurs procédures plus simples.
– Obtenir des procédures totalement indépendantes du programme principal.

Une fonction est une suite d’instructions qui permet d’obtenir un résultat (s’il n’y a pas de résultat, on met void).

Écrire une fonction qui affiche cinq fois bonjour
Écrire une fonction qui renvoie bonjour
Écrire une fonction qui renvoie le carré de 23
Écrire une fonction qui renvoie la somme des nombres de 8 à 20
Écrire la fonction puissance qui renvoie un nombre x à la puissance y (x et y sont connus dans le programme principal).

Écrire une fonction qui prend en paramètre deux chaine de caractère et renvoie la concaténation de ces chaines
Écrire une fonction Multiplie qui prend en paramètre deux réels. Ainsi Multiplie(2,4) calculera 2*4

 

La Programmation objet

La classe

Une classe est définie par son nom, ses propriétés et ses fonctions. Les objets sont des instances de classe. Ils sont structurés par les propriétés définissant la classe. Ils peuvent exécuter les fonctions définies au sein de la classe.

Le nom de la classe commence toujours par une majuscule.
Les attributs ou propriétés sont : nom, annee_naissance et salaire.
Les fonctions sont affiche() et calcul_age().
Tout objet de la classe Personne est structuré par les trois propriétés précédentes. Et cet objet a à disposition les deux fonctions citées.

Exemple :

Soit p1 et p2 deux instances de la classe Personne, donc deux objets Personne.
P1 a pour nom Henri, pour anne_naissance 1980 et p2 a pour nom Duval et pour annee_naissance 1982. Le salaire du premier est de 1500 et du deuxième 2100.
La fonction affiche() permet à p1 d’afficher son propre contenu (idem pour p2). La fonction calcul_age() d’afficher leur propre âge.
On appelle aussi les propriétés d’une classe des variables d’instances et les fonctions des méthodes.
Le nom d’une classe doit toujours être le même que le nom du fichier java. Il faut toujours ajouter une classe principale qui va exécuter le programme. Elle contient au moins une méthode particulière, la méthode main.

Modifier le programme précédent pour qu’il puisse créer deux autres objets p3 et p4.
Réaliser une classe Sandwich qui possède comme propriété trois ingrédients, un poids et un prix.

Le constructeur

La plupart des classes doivent être dotées d’une fonction particulière appelée constructeur. Cette fonction doit porter le nom de la classe. Elle doit être déclarée en public. Elle prend en paramètre les variables que l’on souhaite initialiser.

Créer un objet correspondant à la classe Sandwich en utilisant le constructeur .
Réaliser une classe logement qui possède un nombre de pièce, une surface, une adresse, un prix.
Créer deux objets correspondant à la classe.

Implémenter une association en programmation objet

On doit définir une variable possede de type Voiture dans la classe Personne. Comme une personne possède ou non une voiture, c’est elle qui va acheter ou vendre son véhicule. La classe Personne doit donc implémenter deux méthodes, la méthode achat_voiture(v) et la methode vente_voiture(p)

Créer une classe Propriétaire. Cette classe possède comme propriété un nom, et un logement.
Créer deux objets correspondant à la classe.
Le premier achète un logement t1. Il le vend au propriétaire p2.
Ecrire le code correspondant.

 

Variables locales et variables globales :

Si les instructions constituant la procédure utilisent des variables (indice de boucle par exemple), ce sont des variables locales à la procédure (c’est-à-dire qui ne sont connues, et qui ne peuvent donc être utilisées que dans la méthode). Les variables du programme principal sont dites variables globales au programme. Elles sont lisibles par l’ensemble du programme contrairement aux variables locales.

Écrire une méthode afficherPersonne qui prend en paramètre le prénom et affiche le nom et le prénom de la personne. Le nom est déclaré en variable globale.
Ecrire la fonction principale qui utilise votre methode
Ecrire une fonction qui affiche la somme de trois nombres passés en paramètre.
Ecrire une fonction qui renvoie la soustraction de deux nombres
Ecrire une fonction qui ajoute 7 nombres saisis par l’utilisateur à un nombre passé en paramètre et le renvoie.

 Les méthodes static et d’instance

Les méthodes static

Le modificateur static permet de définir une variable comme variable de classe. Une variable de classe est la même pour chaque instance d’un objet.

Il peut aussi s’appliquer aux fonctions. La méthode est alors directement appelée par la classe sans nécessiter de déclaration d’objet

On emploie ces méthodes lorsqu’elles n’ont pas de rapport direct avec les objets de la classe.

On souhaite réaliser un objet carte réseau. On sauvegardera le nombre de port, le débit, l’adresse MAC.
Toute les cartes proviennent du même constructeur donc le code est 089AAB. L’adresse MAC est constituée en premier lieu du code du constructeur puis d’un code générique que l’on mettra au hasard. Réaliser la classe et le constructeur. Attention, l’adresse commencera donc toujours par le même code.

Les méthodes d’instances

Les méthodes d’instances correspondent à celle que vous réalisez déjà. Il est nécessaire de déclarer un objet de la classe pour pouvoir les utiliser.

Réaliser une méthode qui permet d’afficher l’adresse MAC et une méthode qui permet d’afficher le code du constructeur.

L’encapsulation

Encapsulation avec private et public

Pour que chaque objet soit responsable de son état interne, il faut protéger les objets des interventions extérieures. C’est ce qu’on désigne par l’encapsulation.
Ce sont les valeurs des modificateurs qui fixent le niveau de protection des données et des méthodes.
Le modificateur private devant la définition d’une propriété ou d’une méthode interdit à un objet appartenant à une autre classe d’utiliser directement la propriété ou la méthode.
Le modificateur public les rend utilisable par une autre classe.
Les éléments public sont visibles à l’extérieur, les éléments private sont réservés à un usage interne aux objets de la classe.

Les méthodes d’instance qui permettent d’accéder aux données privés sont appelées des accesseurs. Il existe aussi des méthodes d’instances qui permettent de modifier ces objets, ce sont des modificateurs.
En programmation objet, l’usage est d’utiliser get pour les accesseurs et set pour les modificateurs.

Réaliser une classe Eleve qui possède un nom, un prénom, un numéro, une date de naissance et une adresse. Ces éléments sont protégés. On réalisera les accesseurs et les modificateurs nécessaires.
Créer 3 élèves et modifier le nom du premier, afficher la date de naissance du deuxième, modifier le numéro du troisième tout en affichant son nom.

Les structures de données

Les tableaux à une dimension

Qu’est-ce qu’un tableau ?

Un tableau est dit à une dimension lorsqu’un seul indice suffit à adresser les éléments du tableau. Le tableau informatique n’a rien d’original par rapport au tableau de tous les jours. On le représente souvent comme une suite de cases contenant chacune une valeur.

1ière case 2ième case 3ième case nième case
58 12 27 0 -5 78

Variables complexes et variables simples :

La notion de « case contenant une valeur » doit faire penser à celle de variable. Et, en effet, les cases sont des variables. Il est indispensable de comprendre que le tableau est lui-même une variable. C’est une variable complexe (par opposition aux variables simples) car il est constitué de variables ; en effet, ce que l’on représente par des cases correspond à des variables.

Déclaration d’un tableau

On appelle indice le numéro d’une case du tableau ; i est donc l’indice de la ième case.

Initialisez le tableau valeurs déclaré ci-dessus

Pour le compilateur, le tableau n’est qu’une suite de variables. Il ne sait pas ce qu’elles contiennent.

Écrire un programme demandant à l’utilisateur d’entrer 10 entiers, puis, ensuite, afficher ces 10 entiers à l’envers.
Écrire les déclarations nécessaires à l’utilisation d’un tableau contenant les 12 mois de l’année.
Écrire un programme qui saisit 100 nombres et les affiche.
Écrire un programme qui saisit un nombre entre 1 et 12 et indique en toutes lettres à quel mois cela correspond. Vous devez conserver les mois dans un tableau.
Écrire un programme qui saisit une suite de notes dans un tableau et qui en calcule la moyenne.
Écrire un programme qui saisit un certain nombre d’entiers. La fin de la saisie sera reconnue par la saisie du nombre –1. Dans un deuxième temps, afficher le nombre de 0 saisis.

Tableaux à deux dimensions

Quelle(s) variable(s) utiliser pour représenter les notes de A, étudiant de BTS SIO? (français, maths, éco, anglais, S1 à S4). Nous allons utiliser un tableau qui contiendra les 8 notes.

La classe compte 18 élèves (A à R). Comment faire pour gérer toutes les notes de tous les élèves de la classe ? Une solution serait de déclarer 18 tableaux de notes (un par élève).

On retombe exactement sur les problèmes rencontrés en début de chapitre : on définit un grand nombre de variables qui sont homogènes et interchangeables. La seule différence est que ces variables sont des tableaux, et non plus des variables simples.
Comment avait-on réglé la situation ? En regroupant les variables dans un tableau. Et bien, on va faire pareil, en regroupant les tableaux dans un tableau. Cela donne un tableau de tableaux, soit un tableau à deux dimensions.

Il faut bien comprendre que cela correspond au tableau suivant :

Éco Fr Ang Maths S1 S2 S3 S4
A [1,1] [1,8]
B
C
R [18,1] [18,8]

Les étudiants sont identifiés par un numéro.

Comment peut-on stocker leur nom ? Ne pas oublier que les cases doivent toutes contenir des valeurs de même type. On ne peut donc pas rajouter une colonne où l’on aurait le nom de chaque étudiant (car on aurait un mélange de chaînes et de réels). La seule solution consiste à définir un tableau à une dimension, de longueur NbEtud, dont la case i contient le nom de l’étudiant i. Pour stocker des données de types différents, il faut des tableaux différents (même si ces données correspondent sémantiquement à la même entité).

Donner la déclaration du tableau qui permettrait de manipuler pour chaque pays (environ 250) le nombre d’habitants, le PIB, et la valeur de la monnaie par rapport au dollar.
Comment peut-on accéder à la valeur de la monnaie du pays numéro 20 ?
Comment pourrait-on avoir en clair le nom de chaque pays ?
Ecrire un programme qui saisit toutes les notes de tous les étudiants, puis qui calcule la moyenne de l’étudiant F, ainsi que la moyenne de la classe en S3.

La Collection ArrayList

Les collections fonctionnent comme des tableaux. Ils possèdent une différence importante, leur taille est dynamique. Dès que la collection est pleine, sa taille est doublée, triplée de façon automatique. En Java, il existe différentes collections qui servent à implémenter des tableaux dynamique comme ArrayList. La classe LinkedList permet de créer des listes chainées et les classes HashSet et TreeSet permettent d’implémenter des ensembles d’objets. Ces classes ont des méthodes qui permettent de manipuler les éléments.

Pour la classe ArrayList, nous avons

  • add( Type t) pour ajouter un élément
  • set(int i, Type t) qui permet de modifier un élément à la ieme place
  • get(int i) qui permet d’obtenir un élément de la ieme case
  • remove(Type t) et RemoveElementAt(int i) qui permettent de supprimer un élément
  • indexOf(Type t) qui retourne la position de l’objet t.
  • size() qui renvoie la taille de la collection.

L’affichage de tous les éléments d’une collection fonctionne sur le même principe qu’un tableau en Java.

On souhaite sauvegarder le nom et le prénom des élèves. Réaliser une classe Eleve puis réaliser une collection qui permette de sauvegarder les 24 élèves de la classe.
Ajouter les 24 élèves.
Afficher le nom de tous les élèves de la classe.
Supprimer le 4eme élève, supprimer l’élève qui s’appelle Dufour.

Les conventions de nommage et la documentation

Les packages

  • Tout en minuscule.
  • Utiliser seulement [a-z], [0-9] et le point ‘.’: Ne pas utiliser de tiret ‘-‘, d’underscore ‘_’, d’espace, ou d’autres caractères ($, *, accents, …).
  • tout package doit avoir comme root un des packages suivant: com, edu, gov, mil, net, org ou les deux lettres identifiants un pays (ISO Standard 3166, 1981).

Les classes

  • 1ère lettre en majuscule
  • Mélange de minuscule, majuscule avec la première lettre de chaque mot en majuscule
  • Donner des noms simples et descriptifs
  • Eviter les acronymes : hormis ceux commun (XML, URL, HTML, …)
  • N’utiliser que les lettres [a-z] et [A-Z] et [0-9] : Ne pas utiliser de tiret ‘-‘, d’underscore ‘_’, ou d’autres caractères ($, *, accents, …).

Variables

  • 1ère lettre en minuscule
  • Mélange de minuscule, majuscule avec la première lettre de chaque mot en majuscule
  • Donner des noms simples et descriptifs
  • Ne pas commencer les noms avec ‘$’ ou ‘_’ bien que ce soit possible.
  • Variable d’une seule lettre (pour un usage local)
  • N’utiliser que les lettres [a-z] et [A-Z] et [0-9] : Ne pas utiliser de tiret ‘-‘, d’underscore ‘_’, ou d’autres caractères ($, *, accents, …).

Constants

  • Tout en majuscule
  • Séparer les mots par underscore ‘_’
  • Donner des noms simples et descriptifs
  • N’utiliser que les lettres [A-Z], [0-9] et ‘_’ : Ne pas utiliser de tiret ‘-‘ ou d’autres caractères ($, *, accents, …).

Fichiers Jars

  • Tout en minuscule
  • Séparer les mots par un tiret ‘-‘
  • Utiliser seulement les lettres [a-z], [0-9] et ‘-‘ : Ne pas utiliser d’underscore ‘_’ ou d’autres caractères ($, accents, …).

La documentation

On peut générer automatiquement des pages HTML correspondants à la documentation de notre code. Que ce soit en Java ou en PHP, il suffit d’utiliser les annotations.
En renseignant ces annotations, l’utilitaire Javadoc va réaliser des pages HTML. Il est nécessaire de mettre ces annotations dans des balises de commentaires un peu particulière, :

Un ensemble de fichiers HTML a été créé accessibles à partir du fichier index.html.

Héritage et Polymorphisme

On peut hériter une classe d’une classe mère. La classe fille pourra utiliser les propriétés et méthodes de la classe mère comme ses propres propriétés. L’héritage permet de construire des hiérarchies de classe. En java, toutes les classes sont dérivées de la classe Object. Elles héritent par défaut de cette classe sans spécifier extends Objets. On ne peut hériter que d’une seule classe.

En dehors de la classe, nous avons accès au constructeur et à getNom.

On hérite la classe Client

Le mot extends permet d’hériter de la classe Client. Il faut utiliser le mot clef super dans la classe fille pour faire appel au constructeur de la classe mère en lui passant les paramètres dans l’ordre

On peut donc accéder aux propriétés de la classe Client depuis un objet ClientParticulier

Le client va ici posséder un nom, une adresse et une réduction et bien sûr son prénom.

Prenons comme exemple la classe Personne. Si on souhaite modéliser des clients et des fournisseurs. La classe Personne possède un nom, une adresse. La classe client possède un montant annuel d’achat, pourcentage de réduction et un éventuel nombre de point_fidelite. La classe fournisseur possède une catégorie, un délai de livraison, un compte pour le paiement des marchandises.

Lors de la définition du constructeur d’un objet de la classe dérivée, il faut faire appel au constructeur de la classe de base avec l’instruction super.

Créer une classe gateau et une classe pain. Celles-ci héritent de la classe produit. Le produit possède un prix, une date de fabrication et une date de fin de vente. La classe gateau possède une taille correspondant au nombre de personne, un ingrédient de base. La classe pain possède un type de farine, un type classique ou special, un poids.

La visibilité

Les objets qui héritent d’une classe ont accès :

  • aux propriétés et méthodes public.
  • aux propriétés et méthodes protected.

Et n’ont pas accès

  • aux propriétés et méthodes private.

z.getNom() ;
z.getAdresse() ;
z.getReducion() ;

Le mot clef protected limite donc l’accès aux objets qui l’hérite.
On peut noter que le modificateur protected (en plus de private et public) permet de rendre accessible les objets à d’autres classes au sein d’un héritage.

 

Les objets qui n’héritent pas d’une classe ont accès :

  • aux propriétés et méthodes public.

Et n’ont pas accès

  • aux propriétés et méthodes private.
  • aux propriétés et méthodes protected.

Le respect de l’encapsulation grâce au accesseurs et modificateurs implique que les propriétés sont déclarées à private. On ne peut donc plus acceder directement à celle-ci en dehors de la classe même avec l’héritage.

Le polymorphisme

La surcharge

La surcharge permet de déclarer des fonctions possédants le même nom mais avec des paramètres différents dans la même classe.

La redéfinition (spécialisation ou overriding)

La redéfinition est le fait de déclarer une méthode avec le même nom et les mêmes paramètres mais dans une classe qui l’hérite.

Le mot clef final

Une classe final est une classe qui ne peut pas avoir de filles. Une classe final ne peut pas être étendue: le mécanisme d’héritage est bloqué. Mais une classe final peut évidemment être la fille d’une autre classe.

Une méthode final est une méthode qui ne peut pas être redéfinie dans les sous-classes. Le mot clef final pour un paramètre bloque la modification de sa valeur (constante).

Le mot clef abstract

Une méthode abstraite ne contient pas de définition, uniquement sa signature. Une méthode abstraite ne peut pas être déclarée static ou private ou final.
Dès qu’une classe contient une méthode abstraite, elle doit elle aussi être déclarée abstraite, avec le modificateur abstract placé au début de son en-tête.

Une classe abstraite ne peut être instanciée. Si une classe l’étend, il faudra définir toutes les méthodes abstraites qu’elle contient pour pouvoir l’utiliser.
Une sous-classe d’une classe abstraite sera encore abstraite si elle ne définit pas toutes les méthodes abstraites dont elle hérite.

 

Le transtypage

Le transtypage (conversion de type ou cast en anglais) consiste à modifier le type d’une variable ou d’une expression.

Il est possible de convertir un objet d’une classe en un objet d’une autre classe si les classes ont un lien d’héritage

On imagine une classe Capitale qui hérite de Ville.

Toutefois, une ville n’est pas une capitale par défaut. Si on souhaite la transformer en capitale, il faut faire un transtypage ou un cast explicite.

Les interfaces

Une interface ne contient que des méthodes abstraites et des constantes. Il n’est pas utile de déclarer les méthodes avec le mot clef abstract. Toutes les méthodes sont abstraites et public.
Toutes les variables sont static et final, ce sont des constantes.

Si une interface hérite d’une autre interface, il faut utiliser le mot clef extends. L’interface ne peut hériter de plusieurs interfaces

Une classe implémente une ou plusieurs interfaces

Si une classe hérite d’une interface, il faut le mentionner avec le mot clef implements.

Réaliser une interface comportement qui possède une méthode manger prenant en paramètre de la nourriture et une quantité, une méthode boire prenant en paramètre une quantité, une méthode dormir prenant en paramètre un nombre d’heures.
Réaliser une deuxième interface techniqueChasse qui possède une méthode chasseGroupe et chasseSolitaire ainsi qu’une variable int du nombre moyen de congénère qui sont ensemble lors de la chasse.  Faire en sorte que la classe Sanglier implémente l’interface comportement et l’interface techniqueChasse.

La sérialisation

La sérialisation permet de conserver les objets en les transformant en chaine de caractères. Ils peuvent ainsi être enregistrés dans des fichiers. La sérialisation assure la sauvegarde des valeurs des données de chaque objet lorsque ces données sont de types élémentaires (int, double…) ainsi que la conservation des liens avec d’autres objets.

Accès aux bases de données

Pour accéder aux bases de données depuis du code Java, il y a plusieurs possibilités. Il est possible de télécharger le pilote JBDC du SGBDR. Par exemple, on peut installer le driver JDBC de MySQL. Il permet de se connecter via Java à un SGBDR.

Création de la requête, on affiche les valeurs de chaque colonne en supposant que la méthode toString de chaque objet est définit.

Modification de données

On modifie les options du statement pour le rendre modifiable

On exécute une requête et on se positionne à la première ligne.

On ferme le resultSet et le statement pour ne pas surcharger la mémoire du SGBDR après avoir effectué ses requêtes.

Les requêtes préparées ( à utiliser)

Comme en PHP, il est possible de préparer les requêtes.

Après avoir initialiser

On modifie les options du statement.

On utilise le ? pour définir une variable.

Chaque get correspond à un champ de la requête SQL. Par exemple getString(« prof_nom »)  renvoie le nom du professeur. Il est possible de remodifier les variables à tout moment

 

La composition ou l’agrégation

Lorsqu’un objet ne peut exister que s’il est constitué de plusieurs objets, on dit que le premier est composé des autres objets élémentaires. La relation qui en découle est une composition. Cette relation affecte le constructeur.
Si on représente une personne qui est constitué d’un état civil, la classe Personne devra être construit avec un objet de la classe Etat_Civil. Si un objet est composé de plusieurs objets, nous gérons cette composition en utilisant une collection d’objet et non plus un simple objet dans la classe.

Réaliser la classe logement. Elle est composée de pièces, possède une surface, une adresse, un prix.
Une pièce possède une largeur, une longueur et une hauteur. La pièce possède un libellé (chambre, cuisine etc).
Créer deux objets correspondant à la classe.

Les collections

Le Framework de Java définit 6 interfaces en relation directe avec les collections qui sont regroupées dans deux arborescences :

Le JDK ne fournit pas de classes qui implémentent directement l’interface Collection. Le tableau ci-dessous présente les différentes classes qui implémentent les interfaces de bases Set, List et Map :

Set
collection d’éléments uniques
List
collection avec doublons
Map
collection sous la forme clé/valeur
Tableau redimensionnable ArrayList
Arbre TreeSet TreeMap
Liste chaînée LinkedList
Collection utilisant une table de hachage HashSet HashMap

Les listes

Les ArrayList correspondent à des collections sans contraintes. La taille est dynamique, on peut mettre des doublons.

Les Listes Chaînées avec LinkedList

Une liste chaînée est une liste dont chaque élément est relié au suivant par une référence à ce dernier.
Une liste chaînée peut être utilisée dans le cadre d’une simulation de pile ou de file, FIFO(First In First Out) ou FILO(First In Last Out).
Pour bien comprendre le principe des listes chaînées, rien de mieux qu’un petit schéma :
liste
Chaque élément contient une référence sur son suivant. On remarque que la queue n’a pas de suivant. Son suivant est en fait null.

Une liste chaînée est une liste dont chaque élément est relié au suivant par une référence à ce dernier, sa taille n’est pas fixe. Les LinkedList acceptent tout type d’objet.
Chaque élément contient une référence sur l’élément suivant sauf pour le dernier : son suivant est en fait null.

Les listes chainées ne sont pas adaptés aux données volumineuses.

Les collections sans doublons avec HashSet

Un Set est une collection sans ordre de tri qui n’accepte pas les doublons. Elle n’accepte qu’une seule fois la valeur null, car deux fois cette valeur est considérée comme un doublon.

Les dictionnaires avec HashMap

Ce type d’objet rentre dans la catégorie des dictionnaires Map ou. Les données vont être enregistrées grâce à des clés. On accèdera à ces valeurs en renseignant la clef ou énumérant toute la collection.

Réaliser une collection ArrayList avec 15 entiers (positifs et négatifs)
Afficher les éléments de rang pair
Réaliser une collection HashMap qui permette d’enregistrer 4 voitures. La clef sera l’immatriculation.
Afficher les éléments de la collection grâce à leurs clefs.

Les exceptions

Le code peut générer des erreurs à l’exécution. Le programme va alors s’arrêter. Pour éviter que le programme s’arrête, il est possible de capturer ces erreurs.

hierarchie d'exceptions

La classe Error représente une erreur grave intervenue dans la machine virtuelle Java ou dans un sous-système Java. L’application Java s’arrête instantanément dès l’apparition d’une exception de la classe Error.
La classe Exception représente des erreurs moins graves. Les exceptions héritant de la classe RuntimeException n’ont pas besoin d’être détectées impérativement par des blocs try/catch.

Rattraper une exception

On capture l’erreur grâce au catch. Ici on capture les exceptions de type Exception.
On notera que l’instruction catch permet de prendre différents types d’exceptions que nous verrons ultérieurement.
La clause finally définit un bloc qui sera toujours exécuté,

Rattraper plusieurs exceptions

Il est également possible d’imbriquer les constructions try catch.

Créer un type d’exception

On ne peut créer d’exception héritant de la classe Error.

Lancer une exception

On lance une exception en utilisant le mot clef throw.

Affichage:

La déclaration des exceptions dans les méthodes

On déclare une fonction qui déclenche une exception en utilisant le mot clef throws.

Réaliser une classe EntierNaturel permettant de manipuler des entiers naturels (positifs ou nuls)
La classe possèdera un constructeur avec un seul argument de type int qui générera une exception de type ErrVal lorsque la valeur reçu n’est pas comprise entre 10 et 100 (grâce à throws). La classe possèdera un accesseur sur la valeur fournie
Ecrire ensuite un programme qui traite l’exception ErrVal en affichant un message.

La généricité

La généricité permet de définir des classes avec un (ou plusieurs) type d’objet inconnu, ou générique qui va être déterminé à l’exécution. Les collections utilisent des types génériques.

Soit la classe suivante :

Si jamais nous avons besoin de la même classe mais avec une variable de type double ou Client, nous sommes tenté de refaire une autre classe. En utilisant la généricité, nous n’allons faire qu’une seule classe. Ici on déclare une classe avec un type d’objet que l’on nomme T. La classe peut fonctionner avec n’importe quel type !

On peut aussi hériter la classe générique

Plusieurs types génériques dans une classe

On peut utiliser autant de type générique que l’on souhaite. Ici on déclare une classe avec un deux objets génériques que l’on nomme A et B.

Le Mapping Objet

Un mapping objet et base relationnel permet de créer l’illusion d’une correspondance entre la base de données et les objets du langage de programmation. On fait donc correspondre les attributs des objets avec les attributs de la base de données. On parle d’ORM (object-relational mapping).

Le pattern DAO consiste à ajouter un ensemble d’objets dont le rôle sera d’aller lire, écrire, modifier, supprimer. Cet ensemble d’objet s’appelle la couche DAO. Ce pattern utilise des classes génériques. On part de nos classes et on réalise des classes qui vont faire la liaison avec la base de données. Ces classes vont porter le nom du pattern : XxxDAO. Ces classes héritent d’une classe DAO qui définit la généricité.

Classe Langage

Notre classe de départ que l’on veut mapper dans la base

La classe générique DAO

On définit la signature de plusieurs méthodes abstraites qui permettent de manipuler des données.

La classe LangageDAO

Elle hérite de la classe DAO pour MYSQL

Liaison automatique

La plupart des logiciels de développement génère la couche DAO automatiquement. En pratique, on ne gère pas la base de données. On définit la plupart du temps des annotations spécifiques pour que le service qui effectue la liaison réalise la correspondance entre table et objet. L’ORM Doctrine permet de gérer automatiquement la liaison avec la base de données. On ne s’occupe plus du pattern DAO. Nous le verrons grâce à Symfony qui utilise cet ORM.

Les Tests

Les tests permettent de vérifier que le programme effectue bien les services demandés. Ces tests vont informer les développeurs des erreurs éventuelles du code testé.

Un service correspond à ce qu’on attend de la fonction. Une fonction peut rendre plusieurs services, comme ajouter une valeur à un nombre ET vérifier qu’il est positif.

Pour tester, il faut réaliser quatre étapes :

  1. on définit les services de chaque fonction
  2. on définit par la suite les tests de chaque service
  3. on implémente les fonctions
  4. on teste les fonctions

On définit les tests selon des services avant l’implémentation de la fonction. Sénèque le jeune : ’Errare humanum est’. L’erreur est humaine. Il est donc important de tester pour être certain que nous avons bien réalisé notre code. Les tests informent de la qualité du code.

Le contrôle de résultat

Voici une classe adition que l’on souhait tester.

La première approche est de tester le code en renvoyant le résultat.

 

On pourra comparer directement si l’on obtient ce que l’on souhaite
L’addition de 6 et 3 retourne 9
On s’assure que le résultat obtenu est bien celui attendu. Mais il faut un contrôle humain pour s’assurer du bon résultat.
Dans un deuxième temps, on peut demander à l’utilisateur de renvoyer un résultat binaire : OK.

En améliorant le test on obtient :

La console affiche maintenant :

Rapport de tests

Ajoutons maintenant un nouveau test sur la méthode lireSymbole :

La console affiche maintenant deux résultats :

Le second test échoue. Il va falloir déterminer où est l’erreur. Avec plusieurs tests d’affiler, il devient très difficile de repérer la fonction correspondante.

Création de tests unitaires

En Java, nous allons utiliser JUnit pour réaliser des tests. JUnit est intégré dans l’environnement de développement avec l’ajout de plug in. Il permet d’avoir un rapport de test en plus du rapport de compilation. Il donne un résultat binaire de l’exécution des tests avec un descriptif de l’erreur.

Il affiche une interface en couleur qui permet d’observer rapidement si nos fonctions ont passé les tests.

Structuration des tests avec JUnit

Les tests portant sur une classe X seront regroupés dans une classe nommée XTest.

On utilise les annotations commençant par @ pour définir les tests. L’annotation @before définit que la fonction sera lancée avant les tests. Ce qui est utile pour initialiser des variables par exemple.

Les assertion avec JUnit

Dans la classe de test, nous allons définir des assertions. Les assertions sont des éléments de validation qui permettent de tester le programme automatiquement avec JUnit.

Réaliser une classe TVA qui possède une variable TVA, implémente les accesseurs et modificateurs. Cette classe définit une méthode qui permet de calculer le prix ttc en fonction du prix HT.
Ecrire ensuite la classe Test correspondante avec des assertions.

Réaliser une classe Salarier. Un salarié possède un nom, un prénom, un salaire brut mensuel.
Réaliser une méthode qui permet de renvoyer le salaire net qui correspond à 83% du salaire brut plus 25 euros de prime.
Réaliser une méthode qui renvoie le salaire annuel net.
Ecrire ensuite la classe Test correspondante.
On affichera un message « debut Test » au commencement des tests

On trouvera les différentes fonctions sur ce site :
http://junit.sourceforge.net/javadoc/org/junit/Assert.html

assertTrue(java.lang.String message, boolean condition)
Asserts that a condition is true.
assertFalse(java.lang.String message, boolean condition)
Asserts that a condition is false.
assertEquals(java.lang.String message, java.lang.Object expected, java.lang.Object actual)
Asserts that two objects are equal.

Les différents tests

Les tests unitaires
Un test est dit unitaire lorsqu’il teste les méthodes d’une classe de façon atomique et indépendante. Ces tests ne font intervenir en général que la classe et la méthode ciblée par le test.

Les tests d’intégration
Les tests d’intégration permettent de valider que l’application fonctionne correctement après la mise en commun des différentes parties. On peut y voir une double position.

Les tests fonctionnels
Les tests fonctionnels viennent valider le fonctionnement de l’application et du service rendu au client. Ces tests portent en général sur des classes de haut niveau d’abstraction. Ils permettent typiquement de valider un enchaînement d’actions au travers d’un scénario client.

Les tests de performance
La phase de validation permet également de vérifier que les contraintes de performance sont atteintes. Ces tests valident typiquement le passage à l’échelle d’un système et valident la qualité de service maximale.

Les tests de recette
Les tests de recette sont sous la responsabilité du client et sont réalisés par un panel d’utilisateurs représentatifs. Ils mettent en œuvre l’application livrée dans des conditions réelles et vérifient son bon comportement.

2018-07-01T18:58:36+00:00By |Tags: |

Leave A Comment