IUT Limoges L.U.P

1. IUT LimogesL.U.P Programmation Objet - Java Michel Vergnaud 2004-2005

2. Qu'est-ce que Java ? • Un langage de programmation à objets • Une architecture de MachineVirtuelle • Un ensemble d'API variées (Application Programming Interface) • Un ensemble d'outils (le JDK)

3. Historique Origines dans les années 1990, chez Sun Microsystems. Au départ, projet d'environnement indépendant du matériel pouvant permettre la programmation d'appareils variés : téléviseurs, magnétoscopes, … Première réalisation en 1992 par James Grosling ingénieur, d’abord appelée Oak. Echec. Puis renommé Java en 1995, visant les applications pour Internet, par Bill Joy. Machine virtuelle et compilateur sont distribués gratuitement. Gros succès, y compris pour des applications indépendantes d’Internet.

4. Présentation - 1 • Langage portable : un programme une fois compilé fonctionnera aussi bien sous des stations Unix, que sous Windows ou autre, sans aucune modification. • Le code source Java est compilé non pas pour un processeur donné, mais pour une machinevirtuelle (c'est-à-dire qui n'a pas d'existence physique), la JVM (Java Virtual Machine). • Le code résultant est nommé ByteCode. • Lors de l'exécution le ByteCode est transformé en un code machine compréhensible par le processeur de la machine réelle. • Java est donc aussi un langage interprété. • L'interprète de la JVM est très élaboré pour être le plus rapide possible; il inclut un JIT (Just In Time Compiler) de façon à faire la traduction bytecode->code natif seulement lorsque c’est nécessaire (première instanciation d’une classe, boucles...).

5. Présentation - 2 • Java est un vrai langage de programmation, conçu selon « l’état de l’art » en la matière, tout en supprimant ce qui s'est avéré être des erreurs des langages plus anciens. • C’est est un langage à objets : • L ’élément de base du langage est l ’objet, instance d ’une classe. • Tous les éléments du langage sont des classes, sauf les types • primitifs (int, float, double, char). • Pas de fonctions autonomes, seulement des méthodes de classes. • La gestion de la mémoire n'est plus à la charge du programmeur : • la libération de la mémoire est automatique (Garbage collector, ramasse-miettes). • Il n’y a ni pré-processeur ni macro-instructions. • C’est est un langage réputé robuste et sûr.

6. Les identificateurs Java • Un identificateur est un nom qui identifie de façon unique une variable, une méthode ou une classe. • Un identificateur doit commencer par une lettre, un trait de soulignement ( _ ) ou un signe dollar ($), pas par un chiffre. • Un identificateur peut contenir des chiffres, mais pas d'espace, tabulation, retour chariot ... • Les identificateurs différencient les minuscules et les majuscules. • Les mots clés de Java ne peuvent pas servir d’identificateurs

7. Les identificateurs Java : conventions • Non obligatoires, mais facilitent la lisibilité. • Les noms de classes commencent par une majuscule. • Si le nom est composé de plusieurs mots, chacun commence par une majuscule. • Ex. Rectangle, RectanglePlein, ... • Les nom de méthodes et de variables commencent par une minuscule. Si le nom est composé de plusieurs mots, chacun commence par une majuscule. • Ex. définirLargeur, rayon, produitScalaire, ...

8. Les mots-clés Java Empruntés à C / C++ Toujours en minuscules. • Mots clés de déclaration des données (boolean, float, int, ...) • Mots clés de boucle (continue, while, for, ...) • Mots clés conditionnels (if, else, switch, ...) • Mots clés d’exception (try, throw, catch, ...) • Mots clés de classes (class, extends, implements, ...) • Mots clés de modification et d’accès (private, public, ...) • Mots clés divers (true, false, null, super, this, ... )

9. Les instructions Java • Séparées par le caractère ; (point-virgule) • Peuvent être écrites sur plusieurs lignes • Le caractère \ (barre oblique inversée) est utilisé pour écrire une chaîne de caractères sur plusieurs lignes. • Ex. • y = 10 * x ; • b = (b1 && b2 ) • || (b3 && b4 ) ;

10. Blocs de code • Délimités par des accolades • { } • Ex. • public void start() • { • if (thread == null) • { • thread = new Thread(this); • } • thread.start(); • }

11. Commentaires • Délimités par /* et */ • Ex. • /* • Ceci est un commentaire • sur plusieurs lignes • */ • Sur une fin de ligne, après // • Ex. • // Ceci est un commentaire • Délimités par /** et */ : • utilisés par l’outil javadoc du JDK pour générer automatiquement une documentation • Ex. • /** • Méthode renvoyant l'aire du rectangle • */

12. Une application Java Très proche des langages C et C++ Première application « Bonjour » Fichier « Bonjour.java » /* ------------------------------------------------ Ce programme se contente d'afficher le message "Bonjour tout le monde !" ------------------------------------------------- */ public class Bonjour { // Définition de la méthode statique main static public void main(String args[]) { System.out.println("Bonjour tout le monde !"); } } • Le nom du fichier doit être le même que le mot suivant le mot-clé class (ici : Bonjour) Le fichier doit être compilé par la ligne de commande javac Bonjour.java Un fichier « Bonjour.class » est créé Pour exécuter l ’application, commande java Bonjour

13. Types et variables Déclarer une variable : type nom ; ou type nom = valeur_initiale; Exemples int n ; // Déclaration de la variable de nom n et de type entier double x ; // Déclaration de la variable de nom x et de type réel en double précision int m = 0; // ... Valeur initiale 0 double x = 100.0; // ... Valeur initiale 100.0 • Les noms sont différents selon la casse (majuscules - minuscules) : x est différent de X • Ne pas oublier le point-virgule en fin de déclaration Déclarer une constante : mot-clé final final double PI = 3.14159 ; La valeur de PI ne pourra pas être modifiée. L'écriture PI = 0.0 ; sera refusée à la compilation.

14. Portée (visibilité) • Variables globales : visibles partout dans le programme. Leur utilisation est à éviter • Variables locales : Variables visibles uniquement dans le bloc de code où elles sont déclarées. class DémoPortée { int x =0; void méthode1() { int y = 0; y = x; //correct } void méthode2() { int z = 1; z = x; //correct z = y; //incorrect: y n'est pas visible, déclarée dans un autre bloc } }

15. Types primitifs Java • Les types numériques entiersbyte, short, int, long • Les types numériques réels float, double • Type boolean : deux valeurs : true, false. • Type caractère char : toutes les valeurs ASCII ou unicode ex. char c = ‘z’; char nl = ‘\n’ char uc = ‘\u0521’;

16. Types primitifs Java 2 Le transtypage (cast) est implicite s ’il n ’y a pas perte de données. int a = 4 ; double x = 2.5 ; double y = a; // ok, y = 4.0 int b = 1.5 ; // erreur à la compilation int c = a * (int)x ; // ok, c = 8 int n = 3; if (n > ‘A') { . . . } Ici la valeur ‘a ’ est convertie en entier (65, valeur ASCII de la lettre a ) avant d’être comparée à la valeur de n .

17. Classes et objets • En programmation structurée non objet : les données (variables) et les opérations associées (fonctions) sont séparées. • En programmation objet : les données et les opérations sont réunies dans une même entité. • Dans Java, il n’y a pas de constantes, variables ou fonctions autonomes, contrairement au C++ qui autorise une programmation non-objet. • La création d’un objet à partir d’une classe est appelé instanciation. Une classe définit un ensemble d ’objets utilisables. Un objet utilisable est une instance d ’une classe

18. Attributs et méthodes • L'unité de base d'un programme écrit dans un langage orienté objet, est la classe • Une classe contient : • des données ou attributs ou champs Un attribut possède un type. A tout moment, il a une valeur. L'ensemble des valeurs des attributs de l'objet détermine l'état courant de l'objet. • des actions pouvant être effectuées sur les attributs, nommées méthodes Les méthodes peuvent renvoyer une valeur (fonctions) ou non (procédures) La valeur des attributs ne devrait être modifiée que par les méthodes de l ’objet.

19. Programmation objet en Java - 1 La définition d'une classe se fait par le mot-clé class public class UneClasse { } La création d'un objet (instanciation) se fait en deux temps : • Déclaration d'une référence UneClasse unObjet ; • Création de l'objet par l'opérateur new : unObjet = new UneClasse(); Avant l'instanciation, une référence a pour valeur null La destruction de l'objet (libération des ressources allouées par new) est automatique dès que l’objet n'est plus référencé.

20. Programmation objet en Java - 2 Exemple On définit une classe « Cercle » dans un fichier « Cercle.java » public class Cercle { // Définition des attributs double xCentre; double yCentre; double rayon; } Cette classe ne contient que des attributs, pas de méthodes. Pour utiliser un objet de type Cercle, il faut instancier cet objet : Cercle unCercle; unCercle = new Cercle(); On peut accèder aux champs de l'objet par la notationpointée : unCercle.xCentre = 2.0; unCercle.yCentre = 3.0; unCercle.rayon = 10.0;

21. Méthodes : constructeur Un constructeur est une méthode automatiquement appelée lors de l'instanciation de l'objet Elle a le même nom que la classe. On ne précise pas le type de donnée retourné. Elle sert typiquement à initialiser les champs de l'objet. public class Cercle { // Constructeur Cercle() { xCentre = 0.0; yCentre = 0.0; rayon = 1.0; } // Définition des attributs double xCentre; double yCentre; double rayon; }

22. Plusieurs constructeurs Une classe peut posséder plusieurs constructeurs qui diffèrent par leurs arguments. Un seul des constructeurs est appelé lors de la construction de l'objet public class Cercle { // Constructeur par défaut Cercle() { xCentre = 0.0; yCentre = 0.0; rayon = 1.0; } // Constructeur avec trois arguments Cercle(double x, double y, double r) { xCentre = x; yCentre = y; rayon = r; } // Définition des attributs double xCentre; double yCentre; double rayon; }

23. Méthodes : exemples public class Cercle { // Constructeurs . . . // Déplacer le cercle void déplacer(double dx, double dy) { xCentre = xCentre + dx; yCentre = yCentre + dy; } // Calculer l'aire du cercle double aire() { return rayon * rayon * 3.14159; } . . . // Définition des attributs double xCentre; double yCentre; double rayon; }

24. Créer et utiliser des objets public class UneApplication { static public void main(String args[]) { Cercle c1; // déclaration d'une référence sur un objet de classe Cercle Cercle c2; // idem c1 = new Cercle(); // création de l'objet référencé par c1 c2 = new Cercle(12.0, 5.0, 2.5); // création de l'objet référencé par c2 System.out.println("Premier cercle"); System.out.print(" x = "); System.out.print(c1.xCentre); System.out.print(" y = "); System.out.print(c1.yCentre); System.out.print(" rayon = "); System.out.print(c1.rayon); System.out.println("\n"); System.out.println("Second cercle "); System.out.print(" x = " + c2.xCentre); System.out.print(" y = " + c2.yCentre); System.out.println(" rayon = " + c2.rayon); c2.déplacer(8.0,15.0); System.out.println("Second cercle "); System.out.print(" x = " + c2.xCentre); System.out.print(" y = " + c2.yCentre); System.out.println(" rayon = " + c2.rayon); } }

25. Exemples : classes Double et Integer Ces classes ont pour champ une valeur de type double pour Double et int pour Integer et proposent des méthodes permettant d'utiliser ces valeurs. Double 2 constructeurs : • Double(double value) • Double(String s) Quelques méthodes : • //Returns the double value of this Double. double doubleValue() // Compares two Doubles numerically. int compareTo(Double anotherDouble) Integer 2 constructeurs : • Integer(int value) • Integer(String s) Quelques méthodes : int intValue() int compareTo(Integer anotherInteger)

26. Tableaux En Java, (pas en C / C++) les tableaux sont des objets • Déclaration de tableaux ex. int[ ] unTableau; // un tableau d ’entiers int unTableau[ ]; // idem int unTableau[ ] [ ]; // un tableau d’entiers à 2 dimensions La définition des dimensions d ’un tableau se fait au moment de l ’instanciation (création de l'objet) avec l ’opérateur new. ex. int[ ] unTableau; // Déclaration unTableau = new int[100]; // Instanciation avec 100 éléments • Accès aux éléments d'un tableau par l'opérateur [ ] unTableau [0] = 140; // affecte 140 au premier élément du tableau n = unTableau [0] // affecte à n la valeur du premier élément du tableau • Dimension d'un tableau int nb_elem = unTableau.length; // nb_elem = 100

27. Arguments de la ligne de commande public class UneApplication { static public void main(String args[]) { // args fait référence au tableau d'arguments // passés en ligne de commande // On peut connaître le nombre d'arguments : int nbArgs = args.length; // et utiliser ces arguments for(int i=0; i < nbArgs; i++) { System.out.println("Argument " + i + " : " + args[i] ); } } }

28. Encapsulation des données - 1 L'accès aux champs de l'objet peut être interdit par le mot-clé private. Seules les méthodes membres de la classe pourront alors accéder aux champs. public class Cercle { // Constructeurs Cercle() { xCentre = 0.0; yCentre = 0.0; rayon = 1.0; } . . . // Définition des attributs private double xCentre ; private double yCentre ; private double rayon; }

29. Encapsulation des données - 2 Les lignes suivantes sont alors erronées : Cercle c = new Cercle(); System.out.println(c.rayon):// Le champ rayon est déclaré private c.rayon = 3.5; // on ne peut pas connaître sa valeur // ni la modifier depuis l'extérieur L'accès aux champs private ne peut se faire que par l'intermédiaire de méthodes membres, par exemple : class Cercle { . . . double getRayon() { return rayon; } void setRayon(double r) { if (r > 0.0) rayon = r; } . . . } On peut ainsi définir des données "en lecture seule" ou n'autoriser la modification des données qu'à certaines conditions.

30. Encapsulation des données - 3 Exemple : On veut représenter un article dans un magasin. Un article est défini par sa désignation, qui ne peut pas varier, et son prix, qui peut changer. public class Article { Article(String d, double p) { désignation = d; prix = p; } public String getDésignation() {return désignation ;} public double getPrix() {return prix ;} public void modifPrix(double pourCent) { prix = prix * (1.0 + pourCent / 100.0); } // Champs privés private String désignation ; private double prix; }

31. Héritage - 1 On veut définir un "disque" c'est-à-dire un cercle ayant une couleur de remplissage. Un disque est défini par - les coordonnées x et y de son centre // Comme un cercle - son rayon // Comme un cercle - sa couleur On veut pouvoir - le créer à partir de ses coordonnées et son rayon // Comme un cercle - le déplacer // Comme un cercle - connaître sa couleur L'héritage permet de réutiliser la définition de la classe Cercle en se contentant d'y ajouter l'attribut de couleur et les méthodes associées. La classe Disque hérite ou est dérivéeou estsous-classede la classe Cercle. La classe Cercle estparente ou classe de base ou superclasse de la classe Disque .

32. Héritage - 2 import java.awt.Color; // package pour la classe // Color public class Disque extends Cercle { // Constructeurs Disque () { // Appel au constructeur de la superclasse // Cet appel doit être fait en premiere ligne super(); couleur = Color.black; } Disque (double x, double y, double r) { super(x, y, r); couleur = Color.black; } Disque (double x, double y, double r, Color c) { super(x, y, r); couleur = c; } public Color getCouleur(){ return couleur;} // Définition des attributs private Color couleur; } Cercle Disque

33. Héritage : accès aux champs et méthodes • Une classe dérivée peut accéder à tous les champs et méthodes public ou protected de sa classe parente, mais pas aux champs private. public class Disque extends Cercle { . . . void test() { double r = rayon; // rayon est déclaré private // dans la classe parente Cercle double r = getRayon(); // correct } . . . }

34. Héritage et références • Une référence sur une classe peut référencer un objet d'une classe dérivée. • Elle ne peut pas référencer un objet d'une classe parente. Cercle c1; Cercle c2; Disque d1; Disque d2; c1 = new Cercle(12.0, 5.0, 40.0); c2 = new Disque(6.0, 5.0, 20.0); d1 = new Cercle(12.0, 5.0, 40.0); // erreur System.out.print(c2.getCouleur() ); // erreur UneApplication2.java:14: incompatible types found : Cercle required: Disque d1 = new Cercle(12.0, 5.0, 40.0); UneApplication2.java:17: cannot resolve symbol symbol : method getCouleur () location: class Cercleur() );

35. Héritage : généralités • Une classe ne peut hériter (extends) que d'une seule classe. • Si une classe C est déclarée final, on ne peut pas définir de classe dérivée de C. • Toutes les classes dérivent de java.lang.Object . • L'opérateur instanceof permet de déterminer la classe d'une instance. Cercle c1, c2; c1 = new Cercle(1.0, 1.0, 4.0); System.out.println(c1 instanceOf Cercle); // affiche true System.out.println(c1 instanceOf Disque); // affiche false c2 = new Disque(1.0, 1.0, 4.0); System.out.println(c2 instanceOf Cercle); // affiche true System.out.println(c2 instanceOf Disque); // affiche true

36. Polymorphisme - 1 class Cercle { . . . public void dessiner(Graphics g) { // on dessine le cercle... } . . . } class Disque extends Cercle { . . . public void dessiner(Graphics g) { // on dessine le disque... } . . . } Cercle c1 = new Cercle(. . .); Disque d1 = new Disque(. . .); . . . c1.dessiner(g); // les « bonnes » méthodes sont appelées d1.dessiner(g);

37. Polymorphisme - 2 Employé • Soit la hiérarchie de classes suivante class Employé { . . . public int ancienneté() { . . .} public void augmenterSalaire(double pourCent) { salaire *= 1.0 + pourCent / 100.0; } private double salaire; } Manager Secrétaire

38. Polymorphisme - 3 class Manager extends Employé { public void augmenterSalaire(double pourCent) { double bonus = 0.5 * ancienneté(); super.augmenterSalaire(pourCent + bonus); } } // Tout le personnel est conservé dans un tableau : Employé[] personnel = new Employé[100]; personnel[0] = new Secrétaire(. . .); personnel[1] = new Manager(. . .); // on augmente les salaires de 2% personnel[0].augmenterSalaire(2.0); personnel[1].augmenterSalaire(2.0); // le manager a eu son bonus !

39. La classe Vector Tableau « à taille variable » Contient uniquement des références sur des objets de classe « Object » On doit donc transtyper ces références pour les utiliser. int size() // nombre d’éléments du vecteur. add(Object o) // ajoute un élément au vecteur. remove(int index)// supprime l’élément à la position index Object elementAt(int index) //l’élément à la position index import java.util.Vector; Vector personnel = new Vector(); Manager m = new Manager(...); personnel.add( m ); personnel.add ( new Secrétaire(…) ); for(int i = 0; i < personnel.size(); i++) { Employé e = (Employé)personnel.elementAt(i); e.augmenterSalaire(5.0); }

40. La classe Object Classe de base de toutes les classes. Contient des méthodes généralement redéfinies dans les classes dérivées. Exemple : public String toString() retourne une représentation lisible de l’objet sous forme de chaîne de caractère, et est appelée par System.out.print Exemple class Cercle { . . . public String toString() { return " Rayon : " + rayon + " x : " + xCentre + " y : " + yCentre ; } } Cercle c = new Cercle(12.0, 5.0, 40.0); System.out.println(c); Rayon : 40.0 x : 12.0 y : 5.0

41. Modificateurs d'accès • Accès depuis l’intérieur du paquet d’une classe Modificateur d’accès Héritage Accessible Par défaut Oui Oui Public Oui Oui Protected Oui Oui Private Non Non • Accès depuis l’extérieur du paquet d’une classe Modificateur d’accès Héritage Accessible Par défaut Non Non Public Oui Oui Protected Oui Non Private Non Non

42. Classes abstraites - 1 • Une classe est dite abstraite si une de ses méthode au moins n'est pas implémentée (méthode abstraite). • Une classe abstraite ne peut pas être instanciée. • Une classe dérivée d'une classe abstraite doit implémenter toutes les méthodes abstraites pour pouvoir être instanciée. abstract public class ObjetGéométrique { . . . // Calcul de l'aire abstract public double aire(); // Calcul du périmètre abstract public double perimetre(); . . . } ObjetGéométrique unObjet; unObjet = new ObjetGéométrique(. . .);

43. Classes abstraites - 2 abstract class Employé { . . . abstract public void augmenterSalaire(double pourCent); . . . protected double salaire; } class Manager extends Employé { . . . public void augmenterSalaire(double pourCent) { double bonus = 0.5 * ancienneté(); salaire = salaire * (1 + (pourCent + bonus)/100.0); } } class Secrétaire extends Employé { . . . public void augmenterSalaire(double pourCent) { salaire = salaire * (1 + (pourCent + bonus)/100.0); } }

44. Interfaces - 1 • Une classe ne peut hériter (extends) que d'une seule classe. L'héritage multiple est interdit. Il est remplacé par l'utilisation d'interfaces. Une interface est une déclaration de classe qui contient des déclarations de méthodes, mais pas d’implémentation. Exemple : On veut pouvoir comparer des objets de classe Rectangle par leur aire. On définit une interface Comparable : public interface Comparable { public boolean isGreaterThan ( Object b); public boolean isSmallerThan ( Object b); } Cette interface pourra être utilisée par d’autres classes héritant de Object, c’est-à-dire toutes les classes…

45. Interfaces - 2 On indique que la classe Rectangle implémente cette interface : public class Rectangle implements Comparable Il faut maintenant implémenter toutes les méthodes de l'interface Comparable dans la classe Rectangle public class Rectangle implements Comparable { Rectangle (…) public boolean isGreaterThan ( Object b) { Rectangle R = (Rectangle)b; return aire() > R.aire(); } public boolean isSmallerThan ( Object b) { Rectangle R = (Rectangle)b; return aire() < R.aire(); } }

46. Champs et méthodes statiques • Les membres statiques (champs ou méthodes) d'une classe sont définis et peuvent être utilisés sans instanciation d'objet. • On y accède par le nom de la classe suivi d'un point. Exemples : Color.blueest un champ statique de la classe Color défini par public static final Color blue Double.MAX_VALUE est un champ statique de la classe Double défini par public static final double MAX_VALUE Double.parseDouble est une méthode statique de la classe Double définie par public static double parseDouble(String s) que l'on peut être utiliser sans instance : double valeur = Double.parseDouble( "123.45" ); • Les méthodes statiques ne peuvent pas accéder aux champs et méthodes non statiques d'un objet.

47. Méthode statique main - 1 class Test { int n; public static void main(String[] args) { n = 10; } } Test.java:6: non-static variable n cannot be referenced from a static context n = 10; ^ 1 error

48. Méthode statique main – 2 class Test { int n; public Test() { n = 10; } public static void main(String[] args) { new Test(); } }

49. Chaînes de caractères En Java, (pas en C / C++) les chaînes sont des objets Elles sont stockées dans des objets de classe String. String s; // déclaration s = "Bonjour"; // instanciation // ou s = new String("Bonjour"); // instanciation Longueur d'une chaîne : int n = s.length(); // n vaut 7 Caractère à une position donnée d'une chaîne : char unCar = s.charAt(3); // unCar vaut 'j' On ne peut pas modifier le contenu d'un objet String. Pour cela, utiliser la classe StringBuffer.

50. Egalité des objets Égalité de deux objets ou de leurs valeurs String ch1 = "Azerty"; // un objet de classe String String ch2 = "Azerty"; // un autre objet de classe String System.out.println(ch1 == ch2); // Affiche false : les 2 objets // sont distincts System.out.println(ch1.equals(ch2) ); // Affiche true : les deux // objets ont la même valeur ch2 = ch1; // ch1 et ch2 sont "le même objet" System.out.println(ch1 == ch2); // Affiche true ch2 = new String(ch1); // on re-crée ch2 System.out.println(ch1 == ch2); // Affiche false System.out.println(ch1.equals(ch2) ); // Affiche true