COURS_JAVA 2009/2010

Java


Motivation :

Pourquoi Java et l’orienté objet ? La réponse a cette question repose sur l’intérêt de l’orienté objet en général et le langage Java en particulier. Actuellement, la plus part des organisations sont entrains de porter leurs applications au monde distribué basé sur le model client/serveur. Il se trouve que l’orienté objet (Java est un de ces langages) est bien adapté aux besoins du model client/serveur et les logiciels distribués.
La différence entre un objet et une procédure une fonction de la programmation traditionnelles et que l’objet à un cycle de vie plus grand que celui de son créateur. Dans un monde distribué en client/serveur, un nœud peut créer un objet, le faire circuler au niveau du réseau et le sauvegarder probablement ailleurs dans une base de données pour une utilisation ultérieure.
En tant qu’un langage orienté objet, Java possède les meilleurs concepts des langages orienté objet qui le précèdent tel que Eiffel, small talk, objective C et C++. Dans Java à l’exception des types de données primitifs tout est objet.

Caractéristiques d’un langage orienté objet :

Un vrai langage orienté objet doit avoir au minimum quatre caractéristiques :
1. Encapsulation : implémentant la modularité
2. Polymorphisme : permettant au même message de provoquer des comportements dépendants de la nature de l’objet qui le recevra.
3. L’héritage : permettant la définition d’autres classes et comportements à base de classes déjà existantes aboutissant à une réutilisation du code.
4. Liaison dynamique : prévoyant d’offrir une flexibilité maximale en faisant une liaison dynamique au moment de l’exécution d’un programme. Cette liaison dynamique se traduit par la capacité d’envoyer des messages aux objets sans connaître leurs types pendant la phase de l’écriture du code.

Présentation du langage Java

Aspects du langage Java :

Dans ce support cours nous aborderons les concepts de base du langage Java tel que :

• Classes
• Constructeurs
• Class messaging
• Finalizers
• Sous-classes
• Java interfaces
• Contrôle d’accès
• Packages
• Variables et Méthodes de classes, méthodes abstraites.
Ensuite, la manière d’améliorer les performances via les threads sera traitée. L’intégration des threads à l’intérieur du langage Java a l’objectif de rendre leurs emplois plus faciles. Les threads sont utilisés dans le langage Java pour améliorer les performances des applications graphiques gourmandes en temps du CPU. Le multi-threading est la manière d’établir rapidité et concurrence à l’intérieur d’un espace d’un seul processus. Dans Java la synchronisation des threads utilise la construction moniteur. Le moniteur est une construction de langage de haut niveau. Les threads dans le langage Java sont pre-emptive où servis par tranche de temps. Dans les systèmes non temps partagé, une fois un thread est exécuté, le seul moyen de lui retirer le processeur est que :
1. Un autre thread de priorité supérieure arrive.
2. Une méthode yield est invoquée. Ceci permettra aux applications de calcule intensive telles les applications graphiques de réduire leur temps de réponse.
L’autre point fort du langage Java réside dans les exceptions permettant la programmation défensive. Une exception dans Java indiquera à une méthode appelante qu’une condition anormale est arrivée. Quand une méthode rencontre une situation anormale sans être capable de la gérer, elle génère (throw) une exception. Throwing une exception est similaire à faire un beeping, flashing une lumière rouge, pour attester qu’un problème impossible a traiter à cet endroit est survenu.


Chapitre 1 :

1.Technologie objets

Dans sa base, la technologie objets est une collection d’analyses, de conceptions et méthodologies de programmation pour modéliser et concevoir les caractéristiques et le comportement des objets dans le monde réel.
Les objets des modèles de la programmation software sont les interfaces utilisateurs, menus etc… Ces objets ont un état et un comportement. Les objets du monde réel peuvent être représentés avec la construction « objets ». Dans le transport de tous les jours on a besoin par exemple d’une voiture. Cette voiture peut être modélisé par un objet. Un objet voiture a un état composé de sa vitesse actuelle, sa direction, sa consommation d’essence, etc… et un comportement avec démarrer, arrêter, tourner, etc ..


2. Les éléments d’un objet logiciel dans Java










Un comportement d’un objet est défini par ses méthodes. Les méthodes manipulent les variables d’instances pour créer un état nouveau de l’objet. En plus les méthodes de l’objet peuvent aussi créer d’autres objets.
La représentation graphique d’un objet est similaire à celle de la figure 1. Elle illustre la structure conceptuelle d’un objet software. Un objet software est équivalent à une cellule avec une membrane extérieure constituant son interface au monde et un noyau intérieur protégé par son interface.
Les variables d’instances d’un objet (données) sont encapsuler dans l’objet c.a.d. entourées par les méthodes de l’objet. Mise à part quelques exceptions, les méthodes de l’objet sont le seul moyen1 par lequel d’autres objets peuvent accéder et changer les variables d’instances de l’objet en question. Dans une classe les variables d’instances peuvent préfixées le spécificateur d’accessibilité public où elles sont globalement accessibles aux autres objets. Plus tard ne détaillerons dans une section séparée les règles régissant la visibilité dans le langage Java. Avant d’aller plus loin nous allons maintenant aborder la construction de base du langage Java, celle d’une classe.


3. Classe De Java
Une classe est une construction software définissant les données (data) ou ce qu’on appel « état » et les méthodes (behavior) des objets concrets construis à base de cette classe. Dans la terminologie java, une classe est construite de membres qui sont des champs (fields ou variables) ou des méthodes. Les champs dans une classe Java sont les données de la classe alors que les méthodes sont les séquences d’instructions opérants sur ses données. En générale, les champs son propre à un objet. En d’autres termes, chaque objet construit de la définition d’une classe contiendra sa propre copie des champs de la classe. Ces champs sont connus sous le nom des variables d’instances. Semblablement, les méthodes opérant sur ces variables d’instances sont appelées les méthodes d’instances.
Il faut se rappeler qu’une classe n’est pas en elle-même un objet. Il faut regarder une classe comme un blue print c.a.d. un moule définissant la structure et le comportement d’un objet qui sera crée dans le langage Java instancier de cette spécification qui est la classe. Dans Java, il est possible d’instancier plusieurs objets d’une même définition d’une classe, comme on construit plusieurs maisons d’un même plan établit par un architecte. En voici une déclaration d’une classe très simple appelée Point :


class Point extends Object {
public double x ; /* instance variable x*/
public double y ; /* instance variable y*/
.
.
.
.
.
.

}
Cette déclaration définit un moule (template) d’objets instanciers. Abordons maintenant dans le langage Java un objet est crée d’une classe.

1.3. Instanciation d’objets
Dans un souci de clarté les exemples de création d’objets utiliseront la spécification de classe Point énoncée précédemment. Un objet est instancier de la classe Point par un segment de code semblable à :


Point mypoint ; // déclaration d’une variable mypoint se référant à un objet Point
mypoint = new Point() ; // allouer une instance de l’objet Point à la variable mypoint

Maintenant et après avoir instancier un objet mypoint, les variables de cet objet sont accédées en qualifiant chaque variable par le nom de l’objet, comme dans :
mypoint.x = 10.0 ;
mypoint.y = 25.7 ;

Nous remarquons dans cet exemple que les variables d’instances de l’objet mypoint x et y sont directement accessibles car elles étaient qualifiées par le mot clé public. En réalité, elle montre l’exception mentionnée précédemment. Lorsque, ces mêmes variables sont qualifiées autrement que par le mot clé public, elles ne seront accessibles que les méthodes de l’objet mypoint. Plus loin, de telles situations sont envisagées. Une dernière explication concernant l’exemple, s’intéresse à la partie de la classe Point responsable de l’allocation physique de l’objet à instancier en l’occurrence la ligne du code mypoint = new Point() ; . Ceci nous ramène vers la notion de constructeurs dans le langage Java.


1.4. Constructeurs :
Dans le langage Java une méthode portant le même nom que la classe est appelée constructeur. Le rôle du constructeur est d’initialiser l’état de l’objet à instancier. Comme les initialisations peuvent être différentes, une classe dans java peut comporter plusieurs constructeurs, chacun donnant une valeur précise à l’état de l’objet. Revenons à notre classe Point pour rapprocher l’idée du constructeur. Dans ce nouveau exemple nous ferrons apparaître deux constructeurs, un donnant une valeur par défaut égale a zéro à l’objet alors que l’autre initialise l’objet à une valeur précise, valeur du parametre.

class Point extends Object {
public double x ; /* instance variable*/
public double y ; /* instance variable/*
Point() { /* constructor to initialize to default zero value*/
x = 0.0;
y = 0.0;
}
Point(double x, double y) { /* constructor */
this.x = x ;
this.y = y ; /* set instancevariable to passed parameters */
}
}

Cet exemple est une variation de la classe précédente Point. Elle comporte deux constructeurs. Une particularité des constructeurs dans Java et qu’ils portent le même nom que le nom de la classe. Lorsque on veut créer un objet de la classe Point, on invoque l’un de ses constructeurs. Ce dernier fera l’initialisation nécessaire et donne des valeurs initiales aux variables d’instance de l’objet. Voici des exemples de code pour invoquer les deux constructeurs de la classe point :

Point lowerleft ;
Point upperright ;
lowerleft = new Point() ; /* creating an object whose initial value is zero*/
upperright = new Point(100.0, 200.0); creating and initializing to non-zero */

La distinction entre les constructeurs d’une classe lors d’une instanciation se fait sur la base du type et le nombre de paramètres. Dans la dernière ligne du code précédent la variable x et la variable y sont préfixées par le mot clé this. This est une référence à l’objet actuel pour distinguer entre les variables d’instances et les paramètres de même nom du constructeur. Il est important de remarquer que l’existence des constructeurs dans la classe Point est dictée par une raison de convenabilité. On pouvait bien s’en passer de ces deux constructeurs sans problème. Cependant, des situations se présentent où les constructeurs sont une nécessité, lorsque un objet instancier lui-même instancier d’autres objets. Détaillons l’idée dans l’exemple suivant du rectangle :
Ici le rectangle est déclaré comme deux objets Point

class Rectangle extends Objects {
private Point lowerleft ;
private Point upperright;
Rectangle () {
lowerleft = new Point();
upperright = new point();
}
…………….
Instance methodes appear in here
……………….
}


L’exemple du rectangle montre la nécessité de l’utilisation d’un constructeur ici pour assurer que les deux objets Point sont instancier au moment où l’objet rectangle est instancier. Dans l’absence du constructeur du rectangle, l’objet rectangle se refera à des points qui ne sont pas encore allouées et c’est un cas d’erreur.

1.5. Méthodes et Messages
Si un objet voudrait qu’un autre objet lui fasse un travail, alors la terminologie programmation orienté objet, le premier objet envoi un message au second. Le second objet sélectionnera la méthode appropriée et l’invoque (activer). L’invocation de méthodes en Java est similaire celle des fonctions du langage C et C++.
En utilisant le paradigme de passage de messages dans l’orienté objet on pourra construire un réseau ou bien un web d’objets où les messages serviront à changer l’état. Ce style de programmation est le meilleur moyen pour créer des modèles et des simulations de systèmes complexes du monde réel. Rajoutons maintenant à notre classe initiale Point des méthodes pour accéder aux champs maintenant visible uniquement dans la classe.


class Point extends Object {
private double x ; /* private instance variable x*/
private double y ; /* private instance variable y*/
public Point() { /* constructor to initialize to zero*/
x=0.0;
y=0.0;
}
public Point(double x, double y) {/*constructor to initialize to specific value*/
this.x= x;
this.y = y;
}
public void setX(double x) {/* accessor method */
this.x = x;
}
public void setY(double y) {/* accesor method*/
this.y = y;
}
public double getX() {/*accessor method*/
return x;
}
public double getY() {/*accessor method */
return y;
} }
Dans cette spécification de la classe point les méthodes sont le seul moyen d’accéder aux variables d’instances à partir de l’extérieur. Donnons maintenant un semblable de code utilisant les méthodes :

Point my_point ; /* référence à un objet de type Point*/
my_point = new Point() ; /* allouer une instance de l’objet point*/
my_point.setX(10.0) ; // donner une valeur à x via setX
my_point.setY(25.7) ;

1.6. Finalizers
Une classe peut aussi contenir un seul finalizer optionnel avec l’objectif de récupérer les ressources allouées à l’objet lorsque le ramasse miette (garbage collector) libérera l’espace occupé par l’objet en question. La raison d’existence d’un tel finalizer est que le garbage collector ne récupère pas des ressources comme les descripteurs des fichiers ouverts ou les connexions réseaux. Le code suivant montre la méthode finalize :

/* close the stream when garbage is collected
*/
protected void finalize() {
try {
File.close();
} catch (exception e) {
}
}
Contrairement aux constructeurs une classe ne peut contenir q’un et un seul finalizer. Le finalizer est une méthode sans résultat (void) et qui ne peut être généralement réécrite que dans une sous classe (protected). Le finalizer de l’exemple est une manière ordonnée de fermeture d’un fichier pour libérer son descripteur.


1.7. Sous_classes (sub_class)

Les sous classes sont le mécanisme d’enrichissement d’objets définis en termes d’objets déjà existants. Ce mécanisme offre l’opportunité de réutiliser un code écrit déjà. Le mot réservé extends informe le compilateur java d’une qualité de sous classe. Un exemple type est la classe d’un point en trois dimension réutilisant la classe Point en deux dimension précédente :

class Point extends Object {
protected double x ;
protected double y;
Point() {
x = 0.0;
y = 0.0;
} }
class TreePoint extends Point {
protected double z;
Treepoint() {
x = 0.0;
y = 0.0;
z = 0.0;
}
Treepoint(double x, double y, double z) {
this.x = x ;
this.y = y ;
this.z = z ;
} }

Cet exemple montre clairement que la class TreePoint a rajouter une nouvelle variable d’instance z aux coordonnées x et y héritées de la classe point d’origine et bien sur non déclarées dans la classe Treepoint. On remarque que les variables d’instances de la classe Point sont déclarées protected au lieu de private comme auparavant. Protected est un modificateur d’accès permettant aux sous classe (TreePoint) l’accès aux variables d’instances de la classe mère (Point). Dans le langage java toutes les classes héritent de la classe générique Object. En résumé une sous classe rajoute de la fonctionnalité aux classes mères (super_class).

1.8. La hiérarchie des classes et l’héritage
Le paragraphe des sous classes explorait le concept d’enrichissement d’une classe de base (classe mère). Une sous classe hérite le comportement, les propriétés souhaitées et réécrit celui ou celle qui sont inadéquat. Cette approche aide à réduire la redondance du code et des erreurs. Maintenant, nous allons examiner un peu en détail l’héritage en java. Contrairement à d’autres langage, java n’implémente pas l’héritage multiple, une sous classe dans java est contrainte à n’enrichir qu’une seule classe mère. L’héritage peut être utilisé de façon plus générale, plus de deux sous_classes peuvent hériter de la même classe mère, et une sous_classe peut à son tour être une super_classe d’autres sous_classes formant une hiérarchie d’héritage. Exemple :










L’héritage multiple est très bénéfique lorsque un objet à besoin d’hériter le comportement et les propriétés de plusieurs classes. Cependant, hériter de plusieurs classes en même temps peut s’avérer confus dans certaines situations. Clarifions cette difficulté à l’aide d’un exemple. Soit l’exemple des animaux suivant :

public class Animal extends Object {
/* common fields*/
.
.
.
protected string getLivingEnvironment() {
return “earth” ; } }
public class LandAnimal extends Animal {
/* new fields /*
.
.
.
protected string getLivingEnvironment() {
return “land” ; } }
public class WaterAnimal extends Animal {
/* new fields */
.
.
.
protected string getLivingEnvironment() {
return “water” ; } }

Admettons que maintenant nous souhaitons définir une classe encapsulant un frog. Un frog est un petit animal vivant en terre comme en eau. Naturellement, la classe Frog héritera des deux super_classes LandAnimal et WaterAnimal. Le problème dans ce cas précis lorsque on veut avoir l’environnement de vie du Frog, clairement une confusion est à apparaître. L’environnement est-il Water de WaterAnimal ou land de LandAnimal ? La réponse Dépend du compilateur. Le langage java ecatre l’éventualité d’héritage multiple au niveaux des classes, mais il permet à un objet de prendre plusieurs personnages en utilisant les interfaces.

1.9. Les interfaces dans java
Les interfaces de java enrichissent le model de l’héritage simple. C’est une manière élégante de résoudre quelques problèmes de l’héritage simple.
Une interface dans java est simplement une spécification de méthodes d’un objet. Une interface dans java ne comporte pas des variables d’instances ou du code. Elle ne contient que de déclarations de constante et de méthodes. Dans java une classe peut héritée de plusieurs interfaces sans aucun problème, alors on dira que la classe implémente plusieurs interfaces. Reprenons l’exemple précédent des animaux. La solution au problème posé par l’héritage multiple des classes est aisément réalisée par les interfaces. L’exemple suivant montre une définition possible des deux catégories des animaux de Land et de Water comme interfaces :


public interface LandAnimal {
public int getNumberOfLegs () ;
public boolean hasATail (); }
public interface WaterAnimal {
public boolean hasGills (); }

La classe Frog utilise le mot réservé implements à la place de extends utilisé avec les classes toute en offrant les définitions des interfaces comme :

public class Frog extends Animal implements LandAnimal, WaterAnimal {

/* proper fields and méthods*/
.
.
.
public int getNumberOfLegs () {
/* method’s code*/
}
public boolean hasATail () {
/* method’s code */
}
public boolean hasGills () {
/* method’s code*/ } }
Une interface ne définie aucune fonctionnalité, par contre, elle représente un contrat vis a vis l’utilisation d’objet implémentant l’interface. L’interface garantie que l’objet en question réalise les méthodes de cette interface. De même un objet réalisant une interface peut prendre le rôle de l’interface par un casting lors de l’exécution. Un code responsable du casting de notre exemple s’illustre comme suit :

Frog aFrog = new Frog() ;
int legCount = (( LandAnimal) aFrog).getNumberOfLeg();
boolean gillFlag = ((WaterAnimal)) aFrog).hasGills();

Observons que l’objet aFrog est casté pour jouer un rôle de LandAnimal ou bien celui de WaterAnimal. Cela, nous permettra de faire référence à un objet grâce à une de ces personnages pendant l’exécution en s’appuyant sur la liaison dynamique.

1.10. Contrôle d’accès :

Les modificateurs d’accès de java fournissent une capacité de limitation d’accès aux méthodes et champs. Ceci permettra ce qu’on appelle l’encapsulation des données dans les classes pour par exemple les cacher des accès extérieurs.
L’encapsulation est un concept fondamental dans l’orienté objet, elle permet l’isolation des données d’un objet aux autre objets. Ceci se réalise à l’aide de règles de visibilité. Java à un mécanisme de contrôle d’accès composé de quatre niveaux de visibilité associés aux mots clés public, protected, private. Le quatrième niveau package est considéré lorsque aucun des trois mots clés précédents n’est spécifié. Chaque classe, méthode, champs (instance) déclarée public est visible dans les autres classes. Les membres déclarés protected sont seulement accessibles dans les sous_classes. Alors que les membres déclarés private sont accessibles uniquement dans la classe. Enfin, les membres non qualifiés par public, protected, private sont accessibles aux objets du même package.

1.11. Espace de Nommage et Package
Un espace de nommage peut être vu comme un groupe de noms ou bien identificateurs associés à un contexte. Dans un même espace de nommage il est impossible d’avoir des noms ou bien des identificateurs identiques dans le même contexte. En d’autres termes les noms ou les identificateurs identiques sont associés à des noms d’espaces différents. Le langage java utilise le concept de package pour implémenter les noms d’espaces et le contrôle de visibilité.

Un package est un ensemble de classes et interfaces regroupées sous un nom commun. Chaque classe ou interface java existera dans un espace de nommage définit par dans un package avec la déclaration : package com.mycompany.apps.HelloWord ;.
Celle-ci est une déclaration d’une classe ou une interface avec le nom HelloWord existante dans le package com.compagny.apps. Une déclaration de package est placée au début d’un fichier contenant la définition d’une classe ou interface.
Java contraint chaque fichier source de ne contenir qu’une seule classe publique. Le nom du fichier source doit avoir le même nom que celle de la classe publique. Une classe HelloWord doit être placée dans un fichier qui porte le nom HelloWord.java. Lorsque il y a des classes qui appartiennent à des packages différents, le mécanisme de l’import doit être utilisé. L’exemple suivant montre l’utilisation de ce mécanisme : import com.mycompagny.apps.HelloWord. Cette ligne importe une seule classe du package com.mycompagny.apps package. Cependant, Lorsque on veut importer l’ensemble des classes d’un package on utilise une ligne de la forme suivante : import com.mycompagny.apps.* ;.

1.12. Variables et Méthodes de classe
Chaque variable d’instance est une copie séparée dans un objet. Une variable de classe est locale à la classe elle-même. Il y a une seule copie de cette variable et elle est partagée par les objets instanciers de la classe. Pour déclarer une variable ou une méthode de classe dans le langage java le mot static est utilisé, comme par exemple :
Class Rectangle extends Object {
static final int VERSION = 2 ;
static final int REVISION = 0; }
Les méthodes d’une classe sont communes à la classe entière. En général, on utilise les méthodes de classe lorsque on a un comportement commun pour tous les objets d’une classe. En général, les méthodes de classe opèrent seulement sur les variables de classes. Elles ne peuvent ni invoquer les méthodes d’instances ni utiliser les variables d’instances. Une bonne programmation sépare les opérations du niveau classe de celles du niveau objet. Les méthodes d’une classe sont aussi utilisées pour regrouper les calcules arithmétiques. Admettons que nous voulons calculer la racine carrée de 2.0 dans un programme java. Le model de l’orienté objet suggère l’envoi d’un message à 2.0 pour trouver la racine carrée. Cependant, une telle chose est impossible dans java car 2.0 est un type primitif pas un objet. Pour calculer la racine carrée dans java nous utiliserons la méthode de classe sqrt, déclarée dans la bibliothèque mathématique de java comme suit :
public static double sqrt( double d ). Parce que c’est une méthode de classe, on l’invoque par envoi de message à la classe Math au lieu à une instance de classe c.a.d. un objet. Ainsi, alors l’expression Math.sqrt( 2.0) ; retourne la valeur 1.4142135623730951.

1.13. Méthodes Abstraites
Les méthodes abstraites sont une construction principale du paradigme orienté objet. Pour mieux comprendre les méthodes abstraites examinons la notion de la super classe abstraite. Une super classe abstraite est une classe dans laquelle on déclare des méthodes sans le corps du code. C’est la responsabilité des sous classes (classes filles) pour faire la surcharge en fournissant le code manquant. L’intérêt des classes abstraites est double, à savoir hériter du code de la super classe. Cela permet la réutilisation du code et évite sa duplication. Second, les sous classe deviennent un sous type de la super classe. Cela autorise les variables et les appels de méthodes polymorphes. Autrement dit, on peut traiter uniformément, comme instance du super type, différentes catégories d’objets (instances des sous classes). Cet avantage et celui déjà trouvé dans les interfaces. Explicitons l’idée par un exemple d’une application graphique dessinant des formes comme les triangles, les lignes, les cercles, polygones etc. Remarquons qu’il y a plusieurs actions à fournir dans cette application, notamment TRANSLATION, ROTATION, COLORE. Pour solutionner le problème posé par l’application plusieurs alternatives son envisageables. La première est de proposer une classe pour chaque forme de dessin c.a.d. une pour le rectangle, et une pour la ligne etc. On peut constater que ces classes contiennent des parties qui sont semblables. Telles que les variables dénotant la position, la taille, et la couleur ainsi que les méthodes pour les lire et les écrire. Une meilleure alternative regroupe l’ensemble des variables d’instances dans une super classe et ensuite coder la plus part des méthodes manipulant ces variables d’instances de cette super classe abstraite. Cette classe est abstraite car elle n’implémente pas la méthode de dessin, d’ailleurs elle ne sait le faire. Une structure plausible de la classe abstraite Graphical est donnée ci-après :

Public abstract class Graphical extends Object {
Protected Point lowerLeft ; // first boundry of the box
Protected Point upperRight ; // second boundry of the box
…………
More instances variables
………….
Public void setPosition( Point ll, Point ur) {
lowerLeft = ll;
upperRight = ur; }
public abstract void drawMyself() ; // abstract method
}
La classe Graphical comme toute classe ne peut être instancier malgré qu’elle peut avoir un constructeur (une interface ne peut en effet avoir un constructeur). Toute classe qui hérite d’une classe abstraite profitera de la réutilisation du code ainsi que de la capacité de faire référence à un objet grâce à une de ces personnages pendant l’exécution. Pour terminer l’exemple choisit, nous détaillerons la classe fille rectangle. La classe Rectangle surchargera la méthode drawMyself() ; en fournissant un code qu’elle sait faire celui du dessin d’un rectangle :
public class Rectangle extends Graphical {
public void drawMysel() {
moveTo(lowerLeft.x, lowerLeft.y);
lineTo(upperRight.x, lowerLeft.y);
lineTo(upperRight.x, upperRight.y);
lineTo(lowerLeft.x, upperRight.y);
…….and so on………
} }

Examinons maintenant en détaille un autre exemple d’une classe abstraite montrant clairement des variables et méthodes polymorphes. Dans cette exemple une classe abstraite Line ainsi que ses deux dérivées Hline et Vline sont décrites en java. Premièrement donnons un schéma explicatif :


Line : lenght, paintChar ;
getLenght() ; setLenght() ;
getPaintChar(), setPaintChar;
paintOn();



Hline : paintOn(); Vline : paintOn();

Le code java correspondant est:

public abstarct class Line {
protected int lenght ; // lenght in (character) pixels
protected char paintChar; //character used for printing

Peut etre omis protected Line( int length, char paintChar) {

this.lenght = length;
this.lenght = paintChar; }
public void paintOn(Screen s) {
paintOn(s,0,0); }
public abstract void paintOn(Screen s, int x, int y);
public int getLenght() {
return length; }
public void setLenght( int length) {
this.length = length; }
public char getPaintChar() {
return paintChar; }
public void setPaintChar( char paintChar) {
this.paintChar = paintChar; } }

Nous nous examinerons que la dérivée Hline de Line. Voici ci-après son code java :

public class Hline extends Line {
public void paintOn(Sceen screen, int x, int y) {
for ( int I = 0; I < length; i++)
Scren.painAt(paintChar, x+I, y); }
public Hline( int length, char paintChar) {
super(length, paintChar); }}
public static void main( String[] args {
Line hline = new Hline(10, ‘x’);
hline.paintOn(screen);
hline.setLenght(5);
hline.paintOn(screen,0,1); }

La ligne Line hline = new Hline(10,’x’); déclare une hline de type Line et l’initialise avec une instance de Hline. Nous pouvant déclarer ainsi une variable de type Line malgré que Line est abstraite. La valeur de cette variable peut être n’importe quel type de Line c.a.d. une sous-classe concrète de Line. En d’autres termes elle est polymorphe.
La ligne hline.paintOn( screen, 0, 1) ; envoi l’objet hline un message paintOn. La JVM recherche cette méthode dans hline et elle la trouve car sa signature est conforme au paintOn(Screen, int, int) ; et l’exécute. Dans ligne hline.setLenght(5) ; hline reçoit le message setLength. La JVM cherche cette méthode dans Hline où elle ne se trouve pas. De suite la recherche continue dans la classe mère Line avec succès est la variable d’instance lenght est changée à 5. Enfin, la linge hline.paintOn(screen) ; équivalente au premier message de la première ligne déjà considérée, c.a.d. une méthode polymorphe mais avec une signature différente conforme à paintOn(screen) inexistante dans Hline, donc la recherche remonte à la classe mère Line et active son exécution. Cette dernière invoque paintOn(s, 0, 0) en s’envoyant le message. Parce que l’objet actuel est une instance de Hline la recherche de la JVM se solde par un succès et elle l’exécute.

Résumé :

Dans ce chapitre de présentation du langage java on a passé en revue un ensemble fondamental de concepts.
• Classes
• Constructeurs
• Class messaging
• Finalizers
• Sous-classes
• Java interfaces
• Contrôle d’accès
• Packages
• Variables et Méthodes de classes, méthodes abstraites.
Dans ce résumé nous allons reprendre les concepts liés à l’héritage pour les décrire d’une manière brève et succincte pour élucider les interprétations erronées. Ensuite un tableau récapitulatif du contrôle sera donné. Dans ce chapitre nous avons étudié de nombreux aspects des techniques d’héritage, en particulier l’héritage de code, le sous-typage, l’héritage à partir d’interfaces, les classes abstraites et les classes concrètes. De manière générale, nous pouvons distinguer deux objectifs principaux à l’usage de l’héritage : l’héritage de code et l’héritage de type (sous-type). Le premier permet la réutilisation de code, le deuxième sert au polymorphisme et la spécialisation. Lorsque nous héritons de classes concrètes (extends), nous visons ces deux objectifs : nous héritons le code et le type. Lorsque nous héritons d’interfaces (implements), nous séparons les deux aspects : nous héritons le type mais aucune implémentation. Dans le cas où nous visons une partie de chacun des objectifs, nous pouvons employer les classes abstraites : nous héritons le type et une implémentation partielle.
Lorsque nous héritons une implémentation complète, nous avons la possibilité d’ajouter ou de surcharger des méthodes. Si une sous-classe hérite d’une implémentation partielle, elle doit fournir une implémentation complète pour qu’on puisse l’instancier. Signalons quelques propriétés spécifiques aux interfaces et classes abstraites :

 
Interface Classe abstraite
Le mot interface au lieu du mot class Le mot abstract
Toutes les méthodes sont abstraites Au moins une méthode est abstraite
Pas de constructeur A un constructeur
Constantes uniquement Champs

Nous incluons aussi dans ce petit résumé un tableau récapitulatif sur la notion de visibilité liée aux classes et aux membres de classes, donnée ci-après :

Classe Package Sous-classe Ailleurs
public oui oui oui oui
protected oui oui oui non
default oui oui non non
private oui non non non

Enfin nous terminerons par donner un peu plus de détailles sur les opérateurs this et super. L’opérateur this désigne l’objet courant. this([arguments]) est un appel d’un constructeur, appel valide uniquement dans autre constructeur et en première ligne du code. L’opérateur super désigne la mère de l’objet. super([argument]) est un appel du constructeur de la classe mère. Un appel d’un constructeur de la classe mère ne peut se faire qu’en première ligne de la classe. Il n’est pas possible d’appeler un constructeur ailleurs que dans un autre constructeur.