IUT du Limousin L.U.P Michel Vergnaud Programmation Objet - Java

Présentation Java - 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 machine virtuelle (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...).

Présentation Java- 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.

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 */

Une application Java Très proche du langage 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 ex. par la ligne de commande javac Bonjour.java Un fichier « Bonjour.class » est créé Pour exécuter l ’application, commande java Bonjour

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  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 = ; La valeur de PI ne pourra pas être modifiée. L'écriture PI = 0.0 ; sera refusée à la compilation.

Portée (visibilité) lVariables globales : visibles partout dans le programme. Leur utilisation est à éviter l 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 }

Types primitifs Java Les types numériques entiers byte, 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’;

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.

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

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.

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é.

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 notation pointée : unCercle.xCentre = 2.0; unCercle.yCentre = 3.0; unCercle.rayon = 10.0;

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 * ; }... // Définition des attributs double xCentre; double yCentre; double rayon; }

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; }

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; }

Créer et utiliser des objets public class TestCercles { 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); }

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; }

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.

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; }

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ée ou est sous- classe de la classe Cercle. La classe Cercle est parente ou classe de base ou superclasse de la classe Disque.

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

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 }... }

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 Cercle ur() );

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

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

Les 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)

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] ); }

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.blue est 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.