Poly Java 2023

Pr.
Mohamed Saad AZIZI
Ecole Nationale Supérieure de l'Intelligence. Artificielle et Sciences des Données - Taroudant
Programmation
Orientée Objet Java :

Table des matières
Chapitre 1 : Introduction à la Programmation Orientée Objet …………..2
Chapitre 2 : la syntaxe et les éléments de base de Java………………….....5
Chapitre 3 : Les Méthodes en Java………………………………………………19
Chapitre 4: Les Tableaux en Java………………………………………………..23
Chapitre 5: Les Chaines de caractères…………………………………………29
Chapitre 6 : Programmation Orientée Objet…………………………………43
Chapitre 7 : Héritage en Java……………………………………………………..58
Chapitre 8 : Classes abstraites……………………………………………………..64
Chapitre 9 : Les Interfaces……………………………………………………..70
Chapitre 10 : Les Applets……………………………………………………..78
Année 2023/2024
1
Pr. Mohamed Saad AZIZI
Chapitre 1
Introduction à Java
1. Historique
L'histoire de Java commence en 1991, lorsque Sun décide de lancer

un projet destiné à anticiper l'évolution de l'informatique. Ce projet,
appelé « Green Project » (en anglais « projet vert »), eu comme résultat
une plate-forme baptisée « Oak » (en anglais « chêne »), indépendante
du système, orientée objet et légère.
Lorsqu'il est révélé en 1995, Java profite de l'essor d'Internet en

permettant l'un des premiers mécanismes d'interactivité au niveau du
poste client : l'appliquette (applet) Java.
2. Langage Java
Java est un langage typé et orienté objet. Il est compilé et basé sur
une architecture logicielle très particulière nécessitant une machine
virtuelle Java. Il est accompagné d'un ensemble énorme de bibliothèques
standard couvrant de très nombreux domaines, notamment des
bibliothèques graphiques. C'est un langage qui présente d'excellentes
propriétés de portabilité du code.
3. Les composants Java sont :
➢ Java Virtual Machine (JVM) : interpréteur Java

➢ JVM possède un « garbage collector » : libération automatique de
la mémoire allouée.
➢ Java Runtime Environnement (JRE) : l’exécution des programmes
Java.
➢ Software Development Kit (SDK) : Ensemble de développement
qui contient l’environnement d’exécution java (JRE) et des outils
de compilation et d’exécution pour les programmes Java.
➢ Java Foundation Class (JFC) : Ensemble des classes du système
Java, principalement les classes «AWT » Abstact Windowing
Toolkit (AWT) : ensemble de classes conçu pour la création et
l’utilisation d’interfaces graphiques.
➢ SWING : le nouvel ensemble de classes pour la création d’interfaces
graphiques.
2
4. Principe de Fonctionnement de Java
Lorsque vous développez en Java, vous rencontrerez principalement

deux types de fichiers :
➢ Les fichiers ayant une extension .java : Ce sont de simples fichiers

textes qui contiennent le code JAVA nécessaire à votre
programme.
➢ Les fichiers ayant une extension .class : Ces fichiers ne sont pas
directement éditables. Ce sont des "compilations" effectuées par la
machine virtuelle. Ce sont ces fichiers qui seront interprétés par
la machine virtuelle lorsque vous exécuterez votre programme.
Pour exécuter des applications en JAVA sur votre système, vous

avez besoin de ce qu'on appelle une machine virtuelle. Cette machine
virtuelle va interpréter le code compilé, code généré à partir des fichiers
.java (et donc des sources du programme).
La compilation des fichiers .java en fichiers .class se fait au moyen de

la commande javac NomFichier.java. Pour exécuter ensuite ce fichier
qui vient d'être généré, vous devez utiliser la commande java
NomFichier (sans le .class).
3
5. Avantages du Langage Java
Indépendance de la plate-forme (Portabilité) :
Le « bytecode » d’un fichier « *.class » est identique peu importe le

système d’exploitation ou la plate-forme. L’environnement de travail
JVM s’occupe d’effectuer le lien avec la machine
Programmation orientée objet :
Java est un langage de programmation orientée objet et donc, bénéficie

de tous les avantages d’un langage orientée objet :
➢ Encapsulation (protection des données membres);

➢ Héritage (réutilisation et spécialisation des classes);
➢ Surcharge de fonctions;
➢ Polymorphisme (appels d’anciennes fonctions de classes mères).
Améliorations ont été apportées par rapport au langage C++ :
➢ Aucun pointeur.
➢ Aucun héritage multiple.
➢ Aucun passage par référence (passage par valeur uniquement).
➢ Aucune méthode de type destructeur.
Programmation réseau et multi-tâches : Thread
Programmation sécuritaire :
Programme est vérifié avant son interprétation.
Extensibilité.
4
Chapitre 2 :
la syntaxe et les éléments de base de Java
1. Caractéristique d’un programme Java
Un fichier de source Java peut contenir dans l’ordre :
➢ Déclaration de packages.
➢ Importation de packages ou de classes
➢ Une ou des définitions de classes ou d’interfaces
Tout comme en langage C, une application doit avoir une méthode «

main » à l’intérieur de la classe publique.
Le fameux Premier Programme :
public class Bonjour {
public static void main(String args[]) {
System.out.println(" Bonjour bienvenue au cours du Langage Java! ");
} //fin du main()
}//fin de la classe
2. Commentaires
➢ Les commentaires sur une ligne débutent par //....

➢ Les commentaires sur plusieurs lignes sont encadrés par
✓ /* ... */
✓ /**……*/
5
3. Importation de packages et de classes
Les packages sont des regroupements de classes ayant des points

communs.
L’importation de packages ou de classes se fait avec l’utilisation de

l’instruction « import ». Voici la syntaxe :
➢ import [ nom du package(*) ou de la classe ] ;

➢ import java.util.*; // Importation d’un package
➢ import java.awt.Menu; // Importation d’une classe
4. Terminologie
Voici quelques notes à retenir pour tout programme Java :
➢ Le langage Java fait la différence entre les majuscules et

minuscules
➢ Chaque instruction se termine par un point-virgule ;
➢ Les accolades permettent la création de blocs d’instructions
➢ Les espaces blancs ne sont pas traités par le compilateur java.
Voici quelques conventions d’écriture à respecter :
➢ Le nom des classes et interfaces commence avec une majuscule;

➢ Le nom des méthodes et variables commence avec une minuscule
chaque mot subséquent commence avec une majuscule;
➢ Le nom des constantes est en majuscules;
6
5. Les mots-clés réservés pour java
Abstract, Boolean, break, byte, case, catch, char, class, const, continue,
default, do, double, else, extends, false, final, finally, float, for, goto, if,
implements, import, instanceof, int, interface, long, native, new, null,
package, private, protected, public, return, short, static, strictfp, super,
switch, synchronized, this, throw, throws, transient, true, try, void,
volatile, while
6. Variables
Une variable est un nom pour un emplacement en mémoire.
Une variable peut être :
➢ Un type élémentaire de données.

➢ Une collection de plusieurs éléments de type élémentaire (Vecteurs
et Matrices).
➢ Un objet.
Les noms de variables doivent obligatoirement commencer avec une

lettre, un souligné « _ » ou le caractère « $ ».
Lors de sa déclaration, une variable prend par défaut la valeur 0 ou «

false » dans le cas d’une variable de type « boolean ».
7. Déclaration d’une constante
public static final int CONSTANTE = 15;
7
8. Types élémentaires de données.
Tableau des Types élémentaires en Java
Primitive Signification Taille (en Plage de valeurs acceptée

octets)
valeur du jeu de caractères Unicode (65536
char Caractère 2
caractères possibles)
Entier très
byte 1 -128 à 127
court
short Entier court 2 -32768 à 32767
int Entier 4 -2 147 483 648 à 2 147 483 647
long Entier long 8 -9223372036854775808 à 9223372036854775807
float flottant (réel) 4 -1.4*10-45 à 3.4*1038
double flottant double 8 4.9*10-324 à 1.7*10308
boolean booléen 1 true / false
8
9. Les opérateurs
Tableau des opérateurs utilisables en Java
Opérateur Description Type

++ Incrémentation post ou pré-fixée byte char short int long float double
-- Décrémentation post ou pré-fixée byte char short int long float double
+ Positif byte char short int long float double
- Négation byte short int long float double
! Non logique boolean
~ Non binaire byte char short int long
(type) Conversion de type tous
* Multiplication byte char short int long float double
/ Division byte char short int long float double
Modulo (reste de la division
% byte char short int long
entière)
byte char short int long float double
+ Addition
String (concaténation)
- Soustraction byte char short int long float double
< Inférieur byte char short int long float double
<= Inférieur ou égal byte char short int long float double
> Supérieur byte char short int long float double
>= Supérieur ou égal byte char short int long float double
== Egal
objet
!= Différent
objet
&& ET logique boolean
|| OU logique boolean
?: Opérateur ternaire de condition boolean ? tous : tous
= Affectation tous
+= Addition et affectation
String (concaténation)
-= Soustraction et affectation byte char short int long float double
*= Multiplication et affectation byte char short int long float double
/= Division et affectation byte char short int long float double
%= Modulo et affectation byte char short int long float double
9
10. Entrées et sorties de l’information
Le JRE fournit automatiquement au programme trois instances sur les

périphériques d’entrées («system.in »), de sortie (« system.out ») et
d’erreur («system.err »).
Périphérique de sortie
Les fonctions « print() » et « println() » permettent d’écrire sur le

périphérique de sortie standard.
import java.io
public class Hello {
System.out.print("Hello ");
System.out.println("World !");}}
Résultat :
➢ c:\>javac Hello.java
➢ c:\>java Hello
➢ Hello World !
➢ c:\>
10
Concaténation de sortie
L’opérateur « + » est très utile pour concaténer la sortie.
public class Exemple
{ public static void main(String args[]) {
int a = 4;
System.out.println("La valeur est : "+ a);
}}
Résultat :
➢ c:\>javac Exemple.java
➢ c:\>java Exemple
➢ La valeur est : 4
➢ c:\>
Escape Séquences
Escape Séquences suivants peuvent être utilisés à la sortie :
➢ Escape Séquences Description

➢ \n Nouvelle ligne
➢ \t TAB (5 espaces)
➢ \" Caractère guillemet
➢ \\ Caractère barre oblique inversée
➢ \’ Caractère apostropheLa
11
11. Périphérique d’entrée
a. Lectures simples au clavier : la classe Lecture
La classe « Lecture » possède plusieurs fonctions pour permettre la saisie

d’information avec le périphérique standard d’entrée. Ces fonctions
permettent la saisie de chaîne de caractères, de nombres entiers et de
nombres réels. Voici leur signature :
➢ [Chaîne de caractères] = Lecture.lire();

➢ [Chaîne de caractères] = Lecture.lire([Question]);
➢ [nombre entier] = Lecture.lireInt();
➢ [nombre entier] = Lecture.lireInt([Question]);
➢ [nombre réel] = Lecture.lireDouble();
➢ [nombre réel] = Lecture.lireDouble ([Question]);
import java.io.*;
import Lecture;
class SaisieClavier
public static void main (String[] arg)
System.out.println("Donnez votre prénom ");
String prenom = Lecture.lire();
int age = Lecture.lireInt("Entrer votre Age");
System.out.println(prenom + ", " + age + " ans " );
12
b. Lectures simples au clavier : la classe Scanner
La classe java.util.Scanner, qui permet d’effectuer simplement des

lectures à la console.
Scanner entree = new Scanner(System.in);
➢ Ensuite, pour lire un entier i il suffit d’écrire : i= entree.nextInt();

➢ Pour lire un flottant x : x = entree.nextFloat();
➢ Pour lire une chaîne s : s = entree.nextLine();
Exemple :
import java.util.Scanner;
class SaisieClavierBis { public static void main (String[] arg) {
//java.util.Scanner entree = new java.util.Scanner(System.in);
Scanner entree = new Scanner(System.in);
System.out.println("Donnez votre prénom et votre nom");
String prenom = entree.next();
String nom = entree.next();
System.out.println("Donnez votre âge");
int age = entree.nextInt(); entree.nextLine();
System.out.println("Ecrire votre phrase");
String phrase = entree.nextLine();
System.out.println(prenom + " " + nom + ", " + age + " ans, dit : " +
phrase);
} }
13
12. les structures de contrôle
Choix simple : L’énoncé if
if (''condition'') { instructions }
Choix simple : L’énoncé if ….else
if (condition) { instructions }
else
{ autres instructions }
Exemple :
public class Max {
public static void main (String [] args)
int a = Lecture.lireInt("Entrer le premier entier");
int b = Lecture.lireInt("Entrer le deuxime entier");
if ( (a>b) {
System.out.println( a + " plus grande que " + b ) ;
else {
System.out.println( b + " plus grande que " + a ) ;
}}}
14
L’opérateur conditionnel ?:
L’opérateur tertiaire « ? : » est la forme abrégée de l’instruction « if …

else ».
Voici la syntaxe :
[expression] ? [valeur si vrai]:[ valeur si faux ];
Exemple : Le maximum de deux entiers
public class Max {
public static void main (String [] args){
int a = Lecture.lireInt("Entrer le premier entier");
int b = Lecture.lireInt("Entrer le deuxime entier");
System.out.println( (a>b ) ? a + " plus grande que " + b : b + " plus grand
que "+ a );}}
Choix multiple : Enoncé switch ….case
switch ( [variable] ) {
case [valeur1] : instructions; break;
case [valeur2] : instructions; break;
default: instructions ;
15
Exemple : JourSem.java
imoport Lecture ;
public class JourSem{
public static void main(String[] args){
int jour = Lecture.lireInt("Entrez un chiffre entre 1 et 7 : ");
switch (jour) {
case 1: System.out.println("lundi");
break;
case 2: System.out.println("mardi");
break;
case 3: System.out.println("mercredi");
break;
case 4: System.out.println("jeudi");
break;
case 5: System.out.println("vendredi");
break;
case 6: System.out.println("samedi"); break;
case 7: System.out.println("dimanche"); break;
default: System.out.println("le nombre doit être entre 1 et 7!");
}}}
16
13. Les boucles
Boucle while
La syntaxe de while est la suivante :
while ( expression ) { instruction }
Tant que expression est vérifiée , instruction est exécutée.
Boucle do—while
do { Instruction } while ( expression );
Ici, instruction sera exécutée tant que expression vaut true. Cela signifie
donc que instruction est toujours exécutée au moins une fois.
Boucle for
La syntaxe de for est :
for ( expr-1 ; expr-2 ; expr-3) { instruction }
➢ expr-1 est la condition initiale de la boucle

➢ expr-2 est la condition de poursuite de la boucle
➢ expr-3 est une expression exécutée après chaque tour de boucle.
Par exemple,
for (int i=0; i<10; i=i+1)
System.out.println("Bonjour");
Affichera à l'écran 10 fois le mot Bonjour suivi d'un retour à la ligne.
17
Une version équivalente avec la boucle while serait :
int i = 0;
while (i < 10)
System.out.println("Bonjour");
i = i+1;
Exemple : SomChiffre.java
public class SomChiffre {
public static void main(String [] args) {
int nombre, somChiffre = 0 ;
do { System.out.print("Entrez un entier positif: " );
nombre = Lecture.lireInt();
} while(nombre<0) ;
while (nombre !=0){
somChiffre += nombre % 10 ;
nombre /= 10;}
System.out.println("La somme des chiffres du nombre est = " +

somChiffre);
}}
18
Chapitre 3
Les Méthodes en Java
1. Méthode
Une méthode est une fonction membre d’une classe.
Il existe différents types de méthodes que l'on peut classer en trois

familles :
➢ Les accesseurs : ces méthodes vont permettre de modifier un

attribut privé d'une classe par une autre classe (il s'agit d'une
méthode publique accessible aux autres classes).
➢ Les modificateurs : ces méthodes ne retournent rien et modifient
la valeur d'un attribut privé. Il s'agit de méthodes publiques.
➢ Le reste : toutes les fonctions qui ne rentrent pas dans ces deux
catégories.
2. Signature d’une méthode
Une signature de méthode correspond à l’en-tête de la fonction. Les

signatures peuvent être différentes selon les paramètres qu’elle accepte.
Voici la syntaxe d’une signature de méthode :
[modificateur_accès][modificateur][type_retour][nom_méthode]
([paramètres])
{ corps_de_méthode
[return ValeurDeRetour;] }
public static double add (double number1, double number2)
{ return (number1 +number2) ; }
19
a. Modificateur d'accès des membres
Types de protection qui permettent le contrôle de l'accès des membres

d'une classe :
➢ Public : Méthode est accessible de n'importe où.

➢ Protected : Méthode est accessible dans la classe où elle figure et
dans les classes héritées.
➢ Private : Méthode est accessible uniquement dans la classe où elle
figure
b. Modificateur membres
➢ Final
➢ Static
Méthode finale
Une méthode déclarée « final » ne peut être redéfinie (Héritage)
Méthode static
Une méthode static est elle aussi indépendante des objets. L’appel à cette
méthode se fait alors par le nom de sa classe.
NomDeLaCLASSE.nomDeLaFonction(Arguments)
c. Type de retour
L’instruction « return » permet de retourner une valeur à la méthode

appelante.
a. Paramètres d’une fonction
Les paramètres d’une fonction doivent être écrits sous forme suivante :
[type de l’argument] [nom de l’argument]
20
3. La méthode main ()
Tout programme Java nécessite un point d'entrée. Pour un programme

simple, le point d'entrée est la méthode "main"
4. Constructeur de classes
Le constructeur est la méthode qui a le même nom que la classe : permet

la construction des objets d’une classe.
5. Surcharge de fonctions
La surcharge de méthodes consiste à écrire une méthode dont le nom est

identique à une autre méthode mais avec une signature différente.
Ainsi, la méthode est choisie en fonctions de l’appel.
public class Surcharge {
public static long fctCarree( int x ) { return (x*x); }
public static float fctCarree( float x ) { return (x*x); }
public static void main(String args[] ) {
int valeur1=6;
float valeur2=0.2;
System.out.print("Le carree de ");
System.out.print(valeur1 + " = ");
System.out.println(fctCarree(valeur1));
System.out.print("Le carree de ");
System.out.print(valeur2 + " = ");
System.out.println(fctCarree(valeur2)); }}
➢ Résultat : Le carree de 6 = 36
➢ Le carree de 0.2 = 0.04
21
Exemple de Fonctions :
public int maximum( int a , int b){
if(a>b) return a ;
else return b ;
public int pgcd (int a, int b) {
if(a<b)
return (pgcd(b,a));
else if(b==0)
return (a);
else
return (pgcd(b , a % b));
public int factoriel ( int n){
if (n<0) return 0 ;
int fact = 1 ;
while(n>1)
fact *= n-- ;
return fact ;
22
Chapitre 4
Les Tableaux en Java
1. Tableau en Java
Les tableaux sont des structures de données regroupant plusieurs

valeurs de même type. Les tableaux constituent des collections
d'informations homogènes, c'est-à-dire, de valeurs primitives ou d'objets
de même type. Les éléments d'un tableau peuvent être :
➢ des primitives (float, int, char, etc.),

➢ des références d'objets (String, Object),
➢ des références de tableaux.
2. Vecteur
Un vecteur (tableau unidimensionnel) est une suite continue d’éléments

de même type. Ces éléments sont accessibles via un index de 0 à N-1, N
étant le nombre d’éléments. Il existe trois étapes dans la création d’un
vecteur :
➢ Déclaration du vecteur
➢ Construction du vecteur
➢ Initialisation du vecteur
a. Déclaration d’un vecteur
Déclaration du vecteur. Il existe deux syntaxes possibles en Java :
[type] [] [nom du vecteur];
[type] [nom du vecteur] [];
23
b. Construction du vecteur
La deuxième étape consiste en l’allocation de mémoire pour le vecteur.
La taille d'un tableau n'est spécifiée qu'à partir du moment de son

utilisation dans le programme. Ainsi, la mémoire ne sera allouée que
lorsque cela sera nécessaire. La définition d'une référence d'un tableau, c'est-à-
dire la spécification de la taille du tableau référencé par la variable,
s'accomplit en utilisant l'opérateur new.
[nom du vecteur] = new [type] [nombre d’éléments];
Exemple :
int[] tab1;
tab1 = new int[75];
La déclaration peut se combiner à la définition du tableau produisant

une instruction plus compacte comme suit :
int tab2[] = new int[5];
Propriétés des vecteurs
Les vecteurs possèdent la propriété « length » qui permet de connaître

le nombre d’éléments.
tab1 = new int[75];
System.out.print("Il y a " + tab1.length + " élements");
//résultat Il y a 75 éléments
24
Exemple : déterminer la taille la plus petite :
double plusPetiteTaille = Double.MAX_VALUE ;
for (int i = 0 ; i < taille.length ; i++)
if ( taille[i] < plusPetiteTaille)
plusPetiteTaille = taille[i];
c. Initialisation d’un vecteur
Par défaut, les valeurs de chaque élément d'un tableau sont égales à :
➢ 0 pour des entiers (int, short, ...),

➢ 0.0 pour des nombres à virgule flottante (double, float, ...),
➢ false pour des booléens (boolean),
➢ null pour des objets (Object, String).
Un vecteur peut être initialisé de deux façons : par une affectation

directe à l’aide de l’index ou dès la déclaration, par une liste
d’initialisation.
Syntaxe :
[type][nom du vecteur][]={[val1],[val2],…,[valN]};
int[] tab1 = {1,5,8,9};
Affichage des éléments du tableau
System.out.print("Valeur du tableau : ");
for (int i=0;i<tab1.length;i++)
System.out.print(tab1[i]+ " ");
Résultat : Valeur du tableau : 1 5 8 9

25
Exemple : Tableau.java
public class Tableau {
int taille;
double [] tab;
public void remplir(){
for( int i = 0 ; i<taille ; i++){
tab[i] = Lecture.lireDouble(" entrez la valeur de la case " + i + "/" + taille)

;} }
public void inverserTab(){
double temp=0.0;
for (int i=0 ; i <= (int)(taille/2); i++) {
temp = tab[i];
tab[i] = tab[taille - i - 1] ;
tab[taille - i -1 ] = temp ; }}
//affichage des éléments d’un tableau
public void afficheTab(){
for (int i=0 ; i < taille ; i++){
System.out.println(" l element de la case " + i + "/" + taille + " est : " +

tab[i]);} }
26
3. Matrice
Une matrice (tableau multidimensionnel) est un regroupement de

vecteurs. Il existe trois étapes dans la création d’une matrice :
➢ Déclaration de la matrice;
➢ Construction de la matrice;
➢ Initialisation de la matrice.
a. Déclaration d’une matrice
La première étape consiste en la déclaration de la matrice. Il existe deux

syntaxes possibles pour la déclaration de matrices en Java :
[type] [][] [nom de la matrice];
[type] [nom de la matrice] [][];
b. Construction de la matrice
La deuxième étape consiste en l’allocation de mémoire pour la matrice.
[nomMatrice] = new[type][nombre de vecteur][nombre d’éléments];
int[][] Mat1;
Mat1 = new int[2][5];
int Mat2[][] = new int[4][4];
//Affichage de la matrice
System.out.print("Valeur du la matrice : ");
for (int i=0;i<2;i++) { System.out.print("(");
for (int j=0;j<5;j++)
System.out.print(Mat1[i][j] + ",");
System.out.print(")"); }
Résultat : Valeur de la matrice : (0,0,0,0,0,)(0,0,0,0,0,)
27
c. Initialisation d’une matrice
Une matrice peut être initialisé de deux façons : par une affectation
directe à l’aide de l’index ou dès la déclaration, par une liste
d’initialisation.
Syntaxe : [type][nom de la matrice][][]={ {[valeur1],…,[valeur N]}, {…} };
int[][] Mat = { {2,3},{1,4},{5,3} };
System.out.print("Valeur de la matrice : {");
for (int i=0;i<3;i++)
{ System.out.print("(");
for (int j=0;j<2;j++)
System.out.print(Mat[i][j] + ",");
System.out.print(")"); }
System.out.print("}");
Résultat : Valeur de la matrice : {(2,3,)(1,4,)(5,3,)}
28
Chapitre 5
Les Chaines de caractères
Toute chaîne de caractères est un objet de la classe « String » ou de la
classe «StringBuffer ».
1. Classe String
La classe « String » permet la création d’objet contenant une chaîne de
caractères. Le contenu de ces objets ne peut être modifié. Lorsqu’un objet
de classe « String » est créé, son contenu ne peut être modifié. Toute
nouvelle affectation entraîne la création d’un nouvel objet de classe «
String » et la libération de l’ancien objet par le « Garbage Collector ».
La création d’un objet de classe « String » comporte deux étapes :
➢ déclaration
➢ construction de l’objet.
// Déclaration de l’objet :
String phrase ;
// Construction de l’objet
phrase = new String("Voici une phrase");
//Affichage de la phrase
System.out.println(phrase);
Constructeurs de la classe
29
Huit constructeurs sont disponibles pour l’instanciation de la classe.
new String( );
new String( [chaîne de caractères] );
new String( [vecteur de caractères] );
new String( [vecteur de type «byte»] );
new String( [vecteur de caractères],[index départ],[nombre] );
new String( [vecteur de type «byte»],[index départ],[nombre] );
new String( [objet de la classe « String »]);
new String( [objet de la classe « StringBuffer »]);
2. Méthode de la classe « String »
« length » permet de connaître la longueur d’une chaîne de caractères.
Exemple : Longueur.java
public class Longueur
public static void main(String args[] )
String phrase;
phrase = new String("Bonjour a tous");
System.out.print("Nombre de lettres : ");
System.out.println(phrase.length());}}
Résultat : Nombre de lettres : ……
La méthode « charAt » retourne le caractère à un index spécifié.
30
➢ Syntaxe : [variable caractère] = [objet].charAt([index]);
Exemple :PositionAt.java
public class PositionAt.java
String phrase = new String("A plus");
for (int i=0; i < phrase.length(); i++)
System.out.print(" Position (" + i + ")");
System.out.print(" : Lettre (");
System.out.println(phrase.charAt(i) + ")");}}}
Résultat : ….
« getChars » copie un certain nombre de caractères à partir d’une

chaîne de caractères dans un tableau de caractères à un index donné.
➢ Syntaxe : [objet].getChars([ X ],[ Y+1 ],[vecteur de caractères],[ Z ]);

➢ X Index de départ, Y Index d’arrivée, Z Index de départ du vecteur
Exemple : Copiecar.java
public class Copiecar
String phrase = new String("Voici une phrase");
char[] tableau1 = new char[6];
31
phrase.getChars(10, phrase.length(), tableau1, 0);
System.out.print ("Voici le mot copie : ");
for (int i=0; i < tableau1.length; i++)
System.out.print("(" + tableau1[i] + ") ");}}}
« equals » permet la comparaison de deux chaînes de caractères Cette

méthode accepte comme argument la chaîne de caractères à comparer.
Elle retourne «true » si les contenus sont identiques.
➢ Syntaxe : [objet].equals ([Chaîne de caractères]);
Exemple : Egalitechaine.java
class Egalitechaine
public static void main(String args[])
String phrase1 = "Bonjour a tous";
String phrase2 = new String ( "Bonjour a tous");
System.out.print("Les deux phrases sont : ");
if (phrase1.equals(phrase2))
System.out.println("identiques");
else
System.out.println("differentes");}}
Résultat : ….
« equalsIgnoreCase » identique à la précédente à l’exception qu’elle

32
permet de comparer deux chaînes de caractères sans faire la

différence entre majuscules ou minuscules.
➢ Syntaxe : [objet].equalsIgnoreCase ([Chaîne de caractères]);
Exemple :
if (phrase1.equalsIgnoreCase(phrase2))
else
System.out.println("differentes");
« compareTo » permet de comparer alphabétiquement deux chaînes de

caractères en retournant les résultats entiers suivants :
➢ 0 Les deux chaînes sont identiques
➢ < 0 La première chaîne est alphabétiquement plus petite
➢ 0 La deuxième chaîne est alphabétiquement plus grande
➢ Voici la syntaxe : [variable entière] = [objet].compareTo([Chaîne
de caractères]);
Exemple : Comparer.java
public class Comparer
String phrase1 = new String("Bonjour a tous");
String phrase2 = new String("Bonjour a tous bienvenue chez nous");
33
if ( phrase1.compareTo(phrase2) < 0 )
System.out.println("La phrase1 est plus petite");
else
System.out.println("La phrase1 est plus grande");}}
Résultat :……
« regionMatches » permet de comparer une portion d’une chaîne de

caractères.
syntaxes possibles : [objet].regionMatches([ X ], [objet], [ Y ], [ Z ]);
[objet].regionMatches([ V ], [ X ], [objet], [ Y ], [ Z ]);
➢ V Doit-on ignorer les majuscules (« true » ou « false ») ?

➢ X Index de départ de la chaîne de caractères
➢ Y Index de départ de l’objet en paramètres
➢ Z Nombre de caractères à comparer
Exemple : Regionm.java
public class Regionm
String phrase1 = new String("Voici une phrase");
String phrase2 = new String("Voici une autre phrase");
System.out.print("Les 10 premiers caracteres sont ");
if( phrase1.regionMatches(0,phrase2,0,10))
else
System.out.println("differents");}}
Résultat : ….
34
« startsWith » et « endsWith » permettent de comparer une chaîne

de caractères à partir du début ou de la fin d’une chaîne de caractères
contenue dans l’objet.
➢ Syntaxes : [objet].startsWith([ chaînes de caractères ]);
➢ [objet].startsWith([ chaînes de caractères ], [index départ]);
➢ [objet].endsWith ([ chaînes de caractères ]);
Exemple : Debutfin.java
public class Debutfin
String phrase1 = new String("Voici une phrase.");
System.out.print("La phrase ");
if (phrase1.startsWith("Voici"))
System.out.print("commence ");
else
System.out.print("ne commence pas ");
System.out.println("avec le mot \"Voici\" ");
if (phrase1.endsWith("phrase"))
System.out.print("finit ");
else
System.out.print("ne finit pas ");
System.out.println("avec le mot \"phrase\" ");
35
if (phrase1.startsWith("une", 6))
System.out.print("possède ");
else
System.out.print("ne possède pas ");
System.out.println("le mot \"une\" ");}}
Résultat : ….La phrase commence avec le mot "Voici"
La phrase ne finit pas avec le mot "phrase"
La phrase possède le mot "une"
« indexOf » et « lastIndexOf » : permettent de localiser la première («

indexOf») ou la dernière (« lastIndexOf ») occurrence d’un caractère ou
une chaîne de caractères à partir du début de la chaîne de caractères
ou d’un index de départ.
Ces deux méthodes retournent « -1 » si le caractère ou la chaîne de

caractères n’est pas trouvé.
➢ Syntaxes possibles : [objet].indexOf([ caractère ]);
➢ [objet].indexOf([chaînes de caractères]);
➢ [objet].indexOf([ caractère ],[index de départ]);
➢ [objet].indexOf([chaînes de caractères ] ,[index de départ]);
➢ [objet].lastIndexOf ([ caractère ]);
➢ [objet].lastIndexOf ([chaînes de caractères]);
➢ [objet].lastIndexOf ([ caractère ],[index de départ]);
➢ [objet].lastIndexOf ([chaînes de caractères],[index de départ]);
36
« substring » permet de copier une partie d’une chaîne de

caractères. Cette méthode accepte un argument qui correspond à
l’index de départ ou deux arguments, soit un index de départ et un
index d’arrivée.
➢ Syntaxes possibles : [objet].substring([index de départ]);

➢ [objet].substring([index de départ],[index d’arrivée+1]);
Exemple : Enlever.java
public class Enlever
String phrase = "Voici une petite petite phrase.";
System.out.println(phrase.substring(17));}}
Résultat : …..
« concat » Cette méthode permet de concaténer deux chaînes de

caractères ensemble. Elle retourne la nouvelle chaîne créée.
➢ Syntaxe : [objet] = [objet].concat([objet]);
Exemple : Ajouter.java
public class Ajouter
String phrase1 = "Voici ";
String phrase2 = "une phrase";
System.out.println(phrase1.concat(phrase2));}}
Résultat : …
37
« replace » permet de remplacer un caractère par un autre. Elle

accepte deux arguments soit le caractère à remplacer et le caractère
de remplacement.
Syntaxe : [objet]=[objet].replace([caractère recherché],[nouveau caractère]
Exemple : Remplacer.java
public class Remplacer
String phrase1 = "Bonjour a tout le monde";
System.out.println(phrase1.replace('o','Z'));}}
Résultat :….
« toUpperCase » et « toLowerCase » permettent respectivement de remplacer
les minuscules en majuscules et vice-versa.
➢ Voici les syntaxes : [objet] = [objet].toUpperCase();

➢ [objet] = [objet].toLowerCase ();
« trim » élimine tous les espaces blancs au commencement et à la fin

d’une chaîne de caractères. Syntaxe : [objet] = [objet].trim();
« valueOf » méthode permet de convertir le contenu d’une variable en chaîne

de caractères. Voici la syntaxe : [objet] = String.valueOf ([variable]);
« toString » permet de convertir un objet en objet de la classe« String ».
Syntaxe :[objet String] = [objet].toString ();
38
3. Classe « StringBuffer »
Lorsqu’un objet de classe « String » est créé, son contenu ne peut être
modifié. Toute nouvelle affectation entraîne la création d’un nouvel objet de
classe « String » et la libération de l’ancien objet pour le « Garbage Collector ».
Un objet de classe « StringBuffer » possède la particularité de pouvoir

s’adapter dynamiquement à tout changement.
Constructeurs de la classe
Trois constructeurs sont disponibles pour l’instanciation de la classe.
➢ new StringBuffer( );
➢ new StringBuffer ( [taille] );
➢ new StringBuffer ( [chaîne de caractères] );
4. Méthodes de la classe « StringBuffer »
« length » et « capacity » permettent respectivement de connaître la

longueur de la chaîne et la capacité maximum de caractères que peut
contenir l’objet avant une nouvelle allocation
➢ Syntaxes : [variable entière] = [objet].length() ;

➢ [variable entière] = [objet].capacity ();
« setLength » et « ensureCapacity » permettent respectivement de fixer la

longueur de la présente chaîne et la capacité minimum de caractères que
peut contenir l’objet.
➢ Syntaxes : [objet]. setLength ([taille]);

➢ [objet].ensureCapacity([taille]);
39
« CharAt » et « getChars » sont identiques aux méthodes de la classe «String».
« setCharAt » permet de modifier un caractère à un index précis.
➢ Syntaxe : [objet].setCharAt([index],[caractères]) ;
Exemple : Modifier.java
public class Modifier
StringBuffer phrase ;
char[] temp = {'l','i','g','n','e','.'};
phrase = new StringBuffer("Voici une phrase");
for (int i=10; i < phrase.length(); i++)
phrase.setCharAt(i,temp[i-10]);
System.out.println("Phrase : " + phrase);}}
Résultat :…
« reverse » inverse une chaîne de caractères.
➢ Syntaxe : [objet] = [objet].reverse();
40
Exemple : Inverser.java
public class Inverser
{ public static void main(String args[] )
StringBuffer phrase ;
phrase = new StringBuffer("Voici une phrase");
phrase = phrase.reverse();
System.out.println("Phrase : " + phrase);
Résultat : …
« append »
Cette méthode ajoute le contenu d’une variable ou d’un autre objet à la

chaîne de caractères de l’objet. Voici la syntaxe :
[objet] = [objet].append([variable ou objet]);
Exemple :
public class Ajouter
StringBuffer phrase;
phrase = new StringBuffer ("Une phrase ");
phrase = phrase.append("courte");
System.out.println(phrase);
}}
Résultat : ….
41
« insert » insère une chaîne de caractères, un caractère ou un tableau

de caractères à l’intérieur de la chaîne de caractères de l’objet.
➢ Syntaxe : [objet].insert([index de départ],[variable]);
Exemple : Inserer.java
public class Inserer
{ StringBuffer phrase;
phrase = new StringBuffer ("Une phrase ");
phrase.insert(4,"petite ");
System.out.println(phrase);}}
Méthode « delete » et « deleteCharAt » permettent d’effacer une

portion de la chaîne de caractères ou un caractère précis selon un
index.
➢ Syntaxes : [objet].delete([index de départ],[ index d’arrivée + 1]);

➢ [objet].deleteCharAt ([index]);
Exemple :
public class Supprimer
{ public static void main(String args[] )
StringBuffer phrase;
phrase = new StringBuffer ("Une petite phrases");
phrase.deleteCharAt(17);
phrase.delete(4,11);
System.out.println(phrase);}}
Résultat : Une phrase
42
Chapitre 6
Programmation Orientée Objet
Introduction
Le principe de base de la programmation orientée objets sont :
➢ d’une part à regrouper (ou à "encapsuler") au sein d’une même

unité (appelée classe) les données et les traitements.
➢ d’autre part à contrôler l’accès aux données en les déclarant
privées ce qui obligera l’utilisateur de la classe à employer les
traitements encapsulés pour agir sur celles-ci.
➢ Programme objet : réseau d'objets qui au cours d'exécution
s'envoie des messages.
1. Concept de la programmation orientée objet
En programmation orienté objet, on s'intéresse d'abord aux données qui

constituent la partie la plus stable, puis ensuite on leur associe des
traitements
Pour cela, on introduit les concepts suivants :
➢ classes et objets
➢ méthodes et attributs
➢ encapsulation
➢ héritage
➢ polymorphisme
2. Définitions
Classe : Une classe est un type utilisateur qui comporte des données et
des fonctions qui permettent de manipuler directement ces données.
43
Objet : Un objet (ou une instance) est une variable créée à partir d'une
classe.
Un objet peut être considéré comme une structure composée de 2

catégories de champs :
➢ ses attributs (ou champs de données ou propriétés) qui décrivent

les caractéristiques de l'objet.
➢ ses méthodes (ou procédures, fonctions, actions) qui décrivent les
comportements dont l'objet est doté (ces "comportements" influent
en général sur les valeurs des attributs).
➢ Un objet est alors une variable de la classe : on dit qu'il est une
instance de cette classe, c'est-à-dire un élément concret, un
exemplaire de cette classe.
➢ Une fois la classe déclarée, on peut créer autant d'instances de
cette classe que l'on veut.
Conclusion : en dehors des 8 types primaires, TOUT est CLASSE.
3. Spécificateur d’accès
Spécificateur d’accès représente le niveau de protection de la donnée; 2

niveaux Java:
➢ public : l’accès direct à la donnée est possible depuis tout

programme d’utilisation de la classe par la référence :
VariableObjet.VariableDInstance
➢ private : l’accès direct à la donnée n’est pas possible depuis un
programme d’utilisation de la classe. L’utilisateur devra utiliser
des traitements encapsulés pour lire ou mettre à jour ces données.
➢ Protected : l’accès dans la classe et dans la classe drivée (héritage)
44
4. Création d’un objet
La création d’un objet à partir d’une classe nécessite deux étapes :
➢ La déclaration d’une variable à partir d’une classe;

➢ La création de l’objet avec l’instruction « new ».
Exemple : classe Cercle
➢ données ou attributs : x, y = coordonnées du centre; r = le rayon

du cercle
➢ procédures ou méthodes : circonference() , surface()
Exemple : classe Personne
➢ attributs privés : String nom, prenom; entier age ; booléen salarie

➢ méthodes : getNom(), setNom() ..., afficher()..
Exemple : classe Point
➢ attributs : double abs, ord

➢ méthodes : translater(), distance(Point p) , getAbs()…
5. Déclaration des classes
Syntaxe générale
[modificateurs] class nomClasse[extends nomSurClasse]
[implements interface] {
[Déclaration des attributs]
[définition des méthodes] }
45
6. Les méthodes d’une classe (voir Chapitre 3)
Les méthodes d’une classe (encore appelées comportements ou

traitements) se répartissent en deux catégories :
Accesseurs et modificateurs
Accesseurs (accessor) : les méthodes get.Attribut() Donnes des

informations relatives aux valeurs de certains champs privés.
Modificateurs
Modificateurs (mutator) : les méthodes set.attribut() Modifies les valeurs

de certains champs (état d’un objet).
Surcharge
Dans une même classe, plusieurs méthodes peuvent posséder le même

nom, pourvu qu'elles diffèrent en nombre et/ou type de paramètres.
➢ On parle de surdéfinition ou surcharge, on encore en anglais

d’overloading en anglais.
➢ Le choix de la méthode à utiliser est fonction des paramètres
passés à l'appel. Ce choix est réalisé de façon statique(c-à-d à la
compilation).
➢ Très souvent les constructeurs sont surchargés (plusieurs
constructeurs prenant des paramètres différents et initialisant de
manières différents les objets)
➢ En effet, les méthodes surchargées doivent se distinguer par des
signatures clairement différentes :
✓ des nombres d'arguments différents

✓ types d'arguments différents
46
7. Encapsulation des données
L'encapsulation est un mécanisme consistant à rassembler les données

et les méthodes au sein d'une structure en cachant l'implémentation de
l'objet, c'est-à-dire en empêchant l'accès aux données par un autre
moyen que les services proposés. L'encapsulation permet donc de
garantir l'intégrité des données contenues dans l'objet.
Exemples :
public class Rectangle {
private int longueur, largeur;
public Rectangle(int lo, int la) {
longueur = lo;
largeur = la; }
public int perimetreRectangle() {
return 2 * (longueur + largeur);
} etc . . .}
47
La classe Cercle
public class Cercle {
// Attributs
private double x, y ;
private double r;
// méthodes
public double circonference() { return 2*Math.PI*r ;}
public double surface() {
return Math.PI *Math.pow(r,2) ; }
public void affiche() {
System.out.println("Le cercle a pour centre : (x , y ) = ( " + this.x

+" , "+ this.y+ " )" );
System.out.println("et pour rayon r = "+ this.r);
}// fin classe Cercle
48
La classe Personne
public class Personne {
private String nom, prenom, adresse ;
private String sexe ;
private int age;
// accesseur
public String getNom() { return nom ; }
public String getPrenom() { return prenom; }
//modificateur
public void setNom(String lenom) { nom=lenom ; }
public void setAdresse(String ladresse) { adresse=ladresse ; }
…………………….
} // fin classe Personne
49
8. Construction des objets
Les objets sont des instances de classe.
Si on a décrit, défini une classe (Cercle , Personne..), c'est pour créer

ensuite des objets de cette classe. Il s'agit d'exemplaires, d’instances de
cette classe. En Java, il ne suffit pas de nommer les variables objets, il
faut les construire explicitement et les initialiser
Syntaxe
➢ déclare le nom d'un objet de la classe sans définir l'objet lui-même

nomClasse nomObjet;
➢ construit l'objet
nomObjet = new constructeurClasse( [liste de paramètres] ) ;
➢ permet de fusionner les 2 étapes
nomClasse nomObjet = new constructeurClasse( [liste de

paramètres] ) ;
Exemple :
Cercle c;
Cercle c = new Cercle();
c = new Cercle();
L'instruction : Rectangle r = new Rectangle(10, 4);
Permet de déclarer un objet r de la classe Rectangle, de construire le

rectangle r de longueur 10 et de largeur 4.
50
9. L’autoréférence : this
Le mot réservé this, utilisé dans une méthode, désigne la référence

de l'instance à laquelle le message a été envoyé (donc celle sur
laquelle la méthode est « exécutée »). Il est utilisé principalement :
➢ lorsqu'une référence à l'instance courante doit être passée en

paramètre à une méthode,
➢ pour lever une ambiguïté,
➢ dans un constructeur, pour appeler un autre constructeur de la
même classe.
Exemple :
class Personne Pour lever l’ambiguïté sur le mot « nom »

{ et déterminer si c’est le nom du paramètre
public String nom; ou de l’attribut
Personne (String nom)
{
this.nom=nom;
}
}
public MaClasse(int a, int b) {...} Appelle le constructeur
public MaClasse (int c) MaClasse(int a, int b)
{
this(c,0);
}
public MaClasse () Appelle le constructeur
{ MaClasse(int c)
this(10);
}
51
10. Les constructeurs d'instances
Ces méthodes particulières sont chargées d'allouer de l'espace

mémoire à l'objet et à lui attribuer une référence Ce sont de véritables
"moules" à façonner les objets. Le constructeur d'un objet est une
méthode spéciale indispensable qui est appelée automatiquement
pour créer une instance.
Exemple : la classe Cercle
// Définition de différents constructeurs pour la classe Cercle
public class Cercle {
private double x, y, r ;
// Les constructeurs
public Cercle() {this.r = 1 ;}
public Cercle(double r) { this.r = r; }
public Cercle(double xo, double yo , double rayon) {
x = xo ; y = yo ; r = rayon ;}
………………….
…………………..
52
11. Utilisation des objets
a. Accès aux données
La référence à une donnée définie dans une classe d'objet a pour syntaxe
:
nomObjet . nomAttribut
Le point marque la séparation entre le nom de l'objet et le nom de la

méthode de cet objet
Exemple 1
Cercle c = new Cercle() ;
c.x=2 ;
c.y =3 ;
c.r =4;
// le cercle aura pour centre le point de coordonnées (2,3)et pour rayon

la valeur 4
System.out.println("Le cercle a pour centre : x = " + c.x + " ; y = "+ c.y );
System.out.println("et pour rayon r = "+ c.r);
53
b. Accès aux méthodes
Quand on applique les méthodes aux objets, on dit qu'on envoie des
messages aux objets Cela s'écrit de la même façon que vis à vis des
attributs :
nomObjet . nomMéthode()
Exemple :
// Méthode principale de la classe Cercle
Cercle C1 = new Cercle( 3 , 5 , 1);
double a = C1.surface() ;
……………… }
c. Mot clé static
En JAVA, le mot-clé static indique qu'un élément d'une classe est lié à
la classe et non à un objet particulier.
Attribut static
public class Etudiant {
static int maxnum= 0;
String nom;
……….. }}
Accès : NomClasse.nomDuCham
On y accède en écrivant : Etudiant.maxnum
54
Constantes de classe
Ce sont des cas particuliers de variables de classe, dont les valeurs ne

doivent pas être changées. On les déclare en combinant les modificateurs
final avec static Par exemple, dans la classe Math, Math.PI (ainsi que
Math.E) est une constante définie par :
public static final double PI
Exemple :
public static final double DOUBLE_PI = 2* Math.PI ;
Méthodes de classe (ou statiques)
De façon semblable aux variables de classe, elles sont déclarées avec le

mot-clé static. Elles sont appelées précédées du nom de la classe.
Exemple :
Math.sqrt() de la classe Math
Lecture.lireInt() de la classe Lecutre.
55
Exemple : classe Point
public class Point {
private float x, y;
//constructeur sans paramètre
public Point() {
x = 0;
y = 0;
//constructeur avec paramètre
public Point(float x, float y) {
this.x = x;
this.y = y;
//accesseurs
public float getX() {
return x;
public float getY() {
return y;
56
//modificateur
Public void setX( float abs) {
x= abs;
Public void setY( float ord) {
This.y= ord;
public float distance(Point a) {
return (float) Math.sqrt((x-a.getX())*(x-a.getX())+(y-a.getY())*(y-

a.getY()));
public String toString() {
return "("+x+","+y+")";
//A compléter la méthode main () pour tester toutes les méthodes
57
Chapitre 7 : Héritage en Java
1. Le concept de l’héritage :
La modélisation du monde réel nécessite une classification des objets qui

le composent
Classification = distribution systématique en catégories selon des

critères précis
Classification = hiérarchie de classes
Exemples :
➢ classification des éléments chimiques

➢ classification des êtres vivants
➢ Figure géométrique
Forme géométrique
Polygone Ellipse
Quadrilatère Triangle Cercle
Rectangle Triangle Triangle
equilateral Rectangle
Carré
58
2. Définition
Héritage : mécanisme permettant le partage et la réutilisation de

propriétés entre les objets. La relation d’héritage est une relation de
généralisation / spécialisation. La classe parente est la superclasse. La
classe qui hérite est la sous-classe.
Avantage
L'avantage essentiel d'un langage orienté-objet est que le code est

réutilisable. Grâce à l'héritage, on peut faire dériver une nouvelle classe
d'une classe existante et ainsi en récupérer les attributs et méthodes,
sans avoir à la réécrire complètement.
Terminologie :
On dit que la classe Enfant hérite de la classe Parent, qu'elle étend cette
ancienne classe.
Enfant est alors une sous-classe (subclassed) de Parent. Parent est une
super-classe (surclasse) de Enfant.
Java implémente le mécanisme d'héritage simple qui permet de

"factoriser" de l'information grâce à une relation de généralisation /
spécialisation entre deux classes.
L'héritage multiple n'existe pas en Java.
Mot réservé : extends
Notation :
[modificateur] class Enfant extends Parent {
......// la classe Enfant hérite de la classe Parent

59
3. Programme java et représentation UML
class Personne
{
private String nom;
private Date
date_naissance;
// ...
}
class Employe extends
Personne
{
private float salaire;
// ...
}
class Etudiant extends
Personne
{
private int
numero_carte_etudiant;
// ...
}
4. Constructeurs et héritage
Pour forcer l'appel d'un constructeur précis, on utilisera le mot réservé

super. Cet appel devra être la première instruction du constructeur.
60
public class Employe extends public class Personne

Personne {
{ public String nom, prenom;
public Employe () {} public int anNaissance;
public Employe (String nom, public Personne()
String prenom, {
int anNaissance) nom=""; prenom="";
{ }
super(nom, prenom, public Personne(String nom,
anNaissance); String prenom,
} int anNaissance)
} {
this.nom=nom;
Appel explicite à ce constructeur this.prenom=prenom;
avec le mot clé super this.anNaissance=anNaissance;
}
}
5. Redéfinition de méthodes
Une sous-classe peut redéfinir des méthodes existant dans une de ses
superclasses (directe ou indirectes), à des fins de spécialisation.
La méthode redéfinie doit avoir la même signature.
class Employe extends Personne class Cadre extends

{ Employe
private float salaire; redéfinition {
public calculePrime( ) public calculePrime()
{ {
// ... // ...
} }
} // ...
}
61
Remarque
Il n'est pas possible de redéfinir un constructeur, puisque celui-ci porte

le nom de la classe dans laquelle il est déclaré, et que les noms des deux
classes diffèrent obligatoirement
6. Le polymorphisme
Capacité pour une entité de prendre plusieurs formes.
Polymorphisme dit « d’héritage »
7. Le mécanisme de "lookup" dynamique
Déclenchement de la méthode la plus spécifique d’un objet, c'est-à-dire

celle correspondant au type réel de l'objet, déterminé à l'exécution
uniquement.
Cette dynamicité permet d'écrire du code plus générique.
8. Forçage de type / transtypage
Lorsqu'une référence du type d'une classe contient une instance d'une

sous-classe, il est nécessaire de forcer le type de la référence pour accéder
aux attributs spécifiques à la sous-classe.
Si ce n'est pas fait, le compilateur ne peut déterminer le type réel de

l'instance, ce qui provoque une erreur de compilation.
On utilise également le terme de transtypage
Similaire au « cast » en C.
62
class Personne A ce niveau pour le

{ compilateur dans la
private String nom; variable « jean » c’est
private Date date_naissance; un objet de la classe
// ... Personne, donc qui
} n’a pas d’attribut
class Employe extends Personne « salaire »
{
public float salaire;
// ... On « force » le type
} de la variable « jean »
Personne jean = new Employe (); pour pouvoir accéder
float i = jean.salaire; // Erreur de à l’attribut « salaire ».
compilation On peut le faire car c’est
float j = ( (Employe) jean ).salaire; // OK bien un objet Employe
qui est dans cette
variable
9. Référence à la superclasse
Le mot réservé super permet de faire référence au constructeur de la

superclasse directe mais aussi à d’autres informations provenant de
cette superclasse.
class Employe extends Personne

{ Appel à la méthode calculPrime()
private float salaire; de la superclasse de Cadre
public float calculePrime()
{
return (salaire * 0,05);
}
// ...
} class Cadre extends Employe
{
public calculePrime()
{
return (super.calculePrime() / 2);
}
// ...
}
63
Chapitre 8
Les Classe abstraite
Pourquoi ?
Lors de la conception d'une hiérarchie, on a besoin de créer des classes

plus générales d'abord et différer l'implémentation à des étapes plus
éloignées quand le comportement est très bien défini. Quand on parle
de figure géométrique, il est trop vague pour savoir comment calculer
un périmètre, une surface : ces méthodes sont encore abstraites. Il est
impossible de réaliser (implémenter) ces méthodes. Par contre, un
rectangle est une figure géométrique dont le calcul du périmètre et de
la surface est connu, on peut alors implémenter ces méthodes qui sont
très concrètes (pas du tout abstraites) pour un rectangle.
classe abstraite : Figure géométrique

peut-on calculer :
1) le périmètre de n'importe quelle figure ?
non! => ce calcul est abstrait!
2) la surface de n'importe quelle figure ?
non! => ce calcul est abstrait!
classe classe Cercle classe Triangle

Parallelogramme périmètre : Oui périmètre : Oui
périmètre : Oui 2xMath.Pi x rayon côté1+côté2+côté3
2x(cote1+cote2) surface : Oui surface : Non
surface : Non Math.Pi x rayon 2
encore abstraite
classe Rectangle classe TriangleRectangle

surface : Oui surface : Oui
longueur x largeur hauteur x base / 2
classe concrète classe concrète
En résumé : une classe abstraite est celle qui n'est que partiellement implantée
et dont l'intérêt est la conception d'une hiérarchie de l'héritage simple.
64
8.1. Classes abstraites
Définition :
Une classe abstraite est une classe n'ayant pas d'instances. Elle n'est
utilisable qu'à travers sa descendance. Autrement dit, une telle classe
ne peut pas être instanciée directement, et doit toujours être dérivée
pour pouvoir générer des objets.
Déclaration :
abstract class MaClasseAbstraite extends MaClasse { ...}
Elle sert uniquement à regrouper des attributs et méthodes communes
à un groupe de classes pour constituer une véritable "factorisation" de
ces classes et ne sera utilisable que par l'intermédiaire de ses sous-classes
(voir plus bas)
/** classe abstraite FigureGeometrique

* 1. Cette classe contient au moins une méthode abstraite
* la classe est donc abstraite
* 2. On n'a pas de formule pour calculer le périmètre
* ni de surface de n'importe quelle figure.
* À cette étape-ci, les deux méthodes sont encore abstraites
* 3. On n'a pas le droit d'avoir des objets construits (avec new)
* d'une classe abstraite
* 4. On a le droit d'avoir des méthodes non abstraites (concrètes)
* (la réalisation de la méthode est faite au complet,
* exemple toString() de FigureGeometrique)
*/
public abstract class FigureGeometrique
{
public abstract double perimetre();
public abstract double surface();

return "Perimetre : " + perimetre() + "\n" +
"Surface : " + surface() + "\n"; }}
/*Pour un parallélogramme (côtés opposés parallèles) :
* - le calcul du périmètre est concret : 2 x (côté1 + côté2)
* - le calcul de la surface est encore abstraite
* la classe Parallélogramme est encore abstraite
* On n'a pas le droit d'avoir d'objets construits avec new
65
* pour la classe abstraite Parallélogramme

* Cependant, on a le droit d'avoir des constructeurs!
* (pour appeler avec this(...) ou super(....) */
public abstract class Parallelogramme extends FigureGeometrique
{
private double cote1, cote2 ;
public Parallelogramme(double cote1, double cote2) {

this.cote1 = cote1;
this.cote2 = cote2; }
public double perimetre() { return 2 * (cote1+cote2); }
// public abstract double surface();
public double getCote1() { return cote1; }

public double getCote2() { return cote2; }
}
/**
* Les 2 méthodes :
* perimetre() : hériter de Parallelogramme
* surface() : implémentée ici (réaliser de A à Z)
* La classe Rectangle2 n'est plus abstraite. Elle est
* concrète.
*/
public class Rectangle2 extends Parallelogramme
{
// appel le constructeur d'une super-classe (qui est abstraite!)
public Rectangle2(double lo, double la) {

super(lo, la);
// ainsi côté1 <-> longueur,côté2 <-> largeur }
public double surface() {

return getCote1() * getCote2(); }

return "Rectangle : <longueur = " + getCote1() +
", largeur = " + getCote2() + ">\n" + super.toString();
// appel d'une méthode de la super-classe
/* notez que Java ne trouve pas toString() dans
Parallelogramme. Il va monter jusqu'à FigureGeometrique
66
et applique le toString() de FigureGeometrique

C'est le polymorphisme : appliquer la bonne méthode
*/
} }
// Révision de l'héritage, du polymorphisme
public class Carre2 extends Rectangle2

{
public Carre2(double cote) {
super(cote,cote);
}
public double diagonale() {

return getCote1() * Math.sqrt(2.0);
}

return super.toString() + "Diagonale : " +
diagonale() + "\n";
}
}
/**
* Circle.java
* Les 2 méthodes :
* perimetre() : implémentée ici (réaliser de A à Z)
* surface() : implémentée ici (réaliser de A à Z)
* La classe Circle n'est pas abstraite. Elle est
* concrète.
*/
public class Circle extends FigureGeometrique

{
private double rayon;
public Circle( double rayon ) {

this.rayon = rayon;
}
public double perimetre() { return 2 * Math.PI * rayon; }

public double surface() { return Math.PI * rayon * rayon;}
67

return "Cercle de rayon " + rayon + "\n" + super.toString();
}}
/** classe TestAbstraite
* Pour cet exemple, on se limite au minimum pour faire
* ressortir le concept de classe abstraite.
*
* Exercice :
* ajouter une classe Triangle. Pourquoi est-elle abstraite ?
* ajouter une sous-classe TriangleRectangle.
* Pourquoi est-elle concrète ?
* Tester le bon fonctionnement
*/
public class TestAbstraite
{
static double surfaceTotale(FigureGeometrique[] tableau) {
double totSurface = 0.0;
for (int i = 0 ; i < tableau.length ; i++)
totSurface += tableau[i].surface();
return totSurface;
}
public static void main (String[] args)

{
/*
Message d'erreur du genre suivant:
L'operateur new est interdit pour une instance de la
classe abstraite FigureGeometrique
FigureGeometrique fg = new FigureGeometrique();
*/
Rectangle2 rect1 = new Rectangle2(10.0,6.5);
System.out.println("Infos de rect1 :\n" + rect1);
Circle c1 = new Circle(10.0);

System.out.println("Infos du cercle c1 :\n" + c1);
FigureGeometrique[] tabFG =
{ new Rectangle2(10.0, 4.0),
new Circle(5.0),
new Rectangle2(8.6, 4.4),
new Rectangle2(14.2, 10.8),
new Carre2(6.0)};
68
System.out.println("Surface totale pour acheter " +

"de la peinture: " +
surfaceTotale(tabFG));
}}
/* Exécution:
Infos de rect1 :
Rectangle : <longueur = 10.0, largeur = 6.5>
Perimetre : 33.0
Surface : 65.0
Infos du cercle c1 :
Cercle de rayon 10.0
Perimetre : 62.83185307179586
Surface : 314.1592653589793
Surface totale pour acheter de la peinture: 345.73981633974483
*/
Règles à respecter d'une classe abstraite :
➢ pas d'instanciation (trop abstraite pour la

o construction d'un objet avec new)
➢ une classe abstraite a le droit des constructeurs
o (qui seront appelés par autres constructeurs avec
o this(…) ou super(…))
➢ une classe abstraite doit contenir au moins une
o déclaration de méthode abstraite (cas très fréquent)
o ou de variable abstraite
➢ une méthode abstraite déclarée dans la classe
➢ abstraite doit être implémentée dans une de ses
➢ sous-classes (pas nécessairement dans toutes ses sous-classes)
➢ la classe dans laquelle une méthode abstraite est déclarée ne
comporte pas de code pour cette méthode.
➢ Il n'est pas nécessaire d'implémenter une méthode abstraite dans
chaque sous-classe.
➢ une classe abstraite ne peut pas être déclarée comme final (pas de
sous-classes) ou private (car on ne peut pas utiliser ses méthodes à
l'extérieur de cette classe abstraite).
Déclaration :
visibilité abstract class nomDeClasse {
….
visibilité abstract type nomDeMethode(liste d'arguments) ;
…. }
69
Chapitre 9
Les Interfaces
Interface Pourquoi ?
En Java, l'héritage multiple n'existe pas comme en C++, on ne peut pas
faire hériter une classe de plusieurs classes. Pour contourner la
difficulté, on a créé des interfaces.
9.1. Définition
Une interface est une collection de déclarations de méthodes dépourvues
d'implémentation. Le code doit obligatoirement être précisé dans la
redéfinition des méthodes de l'interface. Voir ce mécanisme dans la
gestion des événements auxquels peut réagir une interface graphique
(voir plus bas)
super classe super classe super classe etc …

A1 A2 A3
classe dérivée en C++
En Java une classe n'a pas le droit d'hériter directement deux super-
classes. Par contre, Java permet à une classe d'être dérivée d'une seule
super-classe mais implémente une ou plusieurs interfaces.
super classe en Java

interface interface etc
A I1 I2
sous-classe B
dérivée de A
implémente I1, I2, etc
70
De plus, une interface contient souvent ses méthodes abstraites qui

présentent certaines comportements assez générales (
hasMoreElements() : avoir encore d’éléments, nextElement() : prochain
élément pour les structures linéaires, writeInt() : écrire un entier,
writeDouble() : écrire un réel, … pour les fichiers binaires, run() :
déplacer, pour animation, …). Ces méthodes abstraites seront réalisées
dans les classes qui implémentent cette interface.
Cas de Java : Vector
super classe en
Java interface interface interface
List Cloneable Serializable
AbstractList
public class Vector

extends AbstractList
implements List, Cloneable, Serializable
(note : Vector n’implémente pas l’interface Enumeration mais une de ses

méthodes retourne un objet de la « classe » Enumeration)
...
// cette méthode retourne une énumération des éléments de ce
// vecteur
public final Enumeration elements();
...
Pour afficher tous les éléments d’un vecteur v :

for (Enumeration elem = v.elements() ; elem.hasMoreElements() ; )
System.out.println(elem.nextElement());
71
9.2. Programmer nous-même les interfaces :
Pour trier un tableau des personnes selon leurs tailles, la méthode de tri
suivant fonctionne :
public static void trier(Personne [] pers, nbPers) {

Personne tempo;
for(int i = 0 ; i < nbPers-1; i++) {
int indMin = i;
for(int j = i+1 ; j < nbPers; j++)
if (pers[j].getTaille() < pers[indMin].getTaille() )
indMin = j;
if (indMin != i) {
tempo = pers[i];
pers[i]=pers[indMin];
pers[indMin]=tempo;
} }}
Pour trier un tableau des rectangles selon leurs surfaces, la méthode de

tri suivant répond aussi à nos besoins :
public static void trier(Rectangle [] rect, nbRect) {

Rectangle tempo;
for(int i = 0 ; i < nbRect-1; i++) {
int indMin = i;
for(int j = i+1 ; j < nbRect; j++)
if (rect[j].getSurface() < rect[indMin].getSurface() )
indMin = j;
if (indMin != i) {
tempo = rect[i];
rect[i] = rect[indMin];
rect[indMin] = tempo;
}}}
La seule différente entre ces deux méthodes est la Comparaison selon les
tailles ou selon les surfaces.
Peut-on écrire une seule méthode de tri ?
Supposons qu’on déclare l’interface suivante :
72
9.3. Interface
interface Comparable
{
public abstract boolean plusPetit(Object obj);
}
Supposons aussi que les classes Personne, Rectangle, … implémentent

l’interface Camparable (en réalisant au complet la méthode plusPetit
dans Personne, dans Rectangle, etc . . .).
Il suffit d’écrire une seule méthode de tri comme la suivante :
// comment trier un tableau des objets COMPARABLES ?
public class Tri
// tri par sélection, basée sur la méthode plusPetit de l'interface

Comparable
{
public static void trier(Comparable[] tableau, int nbElem) {
Comparable tempo;
for(int i = 0 ; i < nbElem-1; i++) {
int indMin = i;
for(int j = i+1 ; j < nbElem; j++)
if (tableau[j].plusPetit(tableau[indMin]))
indMin = j;
if (indMin != i) {
tempo = tableau[i];
tableau[i]=tableau[indMin];
tableau[indMin]=tempo;
}
}
}
}
Pour trier les personnes : Tri.trier(pers, nbPers) ;

Pour trier les rectangles : Tri.trier(rect, nbRect) ;
ect …..
73
/** Doit-on écrire plusieurs fonctions de tri pour :

* - trier des personnes selon leur taille ?
* - trier des rectangles selon leur surface ?
* - trier des pays selon leur capital ?
* - trier des . . . ?
*
* Réponse : NON, on peut utiliser une seule méthode
* Comment ?
* Pour trier, il faut COMPARER. Cependant, l'opérateur
* < (est plus petit que) n'est pas défini sur les objets
* On déclare une INTERFACE dont la méthode plusPetit n'est pas
* "réalisée" :
*
* interface Comparable {
* boolean plusPetit(Object c);
* }
* Chacune de ses sous-classes (exemple Personne,
* Rectangle, ...) doit s'ENGAGER à définir (réaliser) cette
* méthode
* Dans cet exemple, on n'a pas la notion d'héritage multiple */
public class TestInterface

{
// afficher le tableau d'objets (personnes, rectangles, ...)
static void afficher(Object [] obj, String message) {

System.out.println(message);
for(int i = 0 ; i < obj.length ; i++)
System.out.println(obj[i]);
System.out.println();
}
public static void main (String[] args)

{
Personne2 pers[] = { new Personne2(1.75, 65.3, 'M'),
new Personne2(1.62, 69.1, 'F'),
new Personne2(1.89, 76.5, 'F'),
new Personne2(1.45, 50.3, 'M'),
new Personne2(1.77, 90.1, 'M')
};
74
afficher(pers, "Lite des personnes avant le tri");

Tri.trier(pers, pers.length);
afficher(pers, "Lite des personnes apres le tri");
Rectangle3 rect[] = { new Rectangle3(12, 5),

new Rectangle3(9, 6),
new Rectangle3(60, 12),
new Rectangle3(5, 12)};
afficher(rect, "Liste des rectangles avant le tri" +

" selon la surface : ");
Tri.trier(rect, rect.length);
afficher(rect, "Liste des rectangles apres le tri selon" +
" la surface : ");
}}
/* Exécution :
Liste des personnes avant le tri
M mesure 1.75 metre et pese 65.3 kgs
F mesure 1.62 metre et pese 69.1 kgs
Liste des personnes apres le tri

Liste des rectangles avant le tri selon la surface :

<longueur : 12, 5, surface : 60>
Liste des rectangles apres selon la surface :

*/
75
public class Personne2 implements Comparable

{
private double taille, poids;
private char sexe ;
public Personne2(double t, double p, char s) {

taille = t ;
poids = p;
sexe = s;}
public double getTaille(){

return taille;
}
public char getSexe(){
return sexe;
}

return sexe + " mesure " + taille + " metre et pese " + poids +
" kgs";
}
// On s'engage à implémenter la méthode "plusPetit" :

public boolean plusPetit(Object p) {
return this.taille < ( (Personne2) p).getTaille();
}
}
public class Rectangle3 implements Comparable
{ // attributs (champs de données, membres de données)
private int longueur, largeur;
public Rectangle3() { }
public Rectangle3(int lo, int largeur) {
longueur = lo;
this.largeur = largeur;
}
public Rectangle3(int c) {
this(c, c);
}
// méthode pour calculer et retourner le périmètre

public int perimetre(){
76
return 2 * (longueur + largeur); }

// méthode pour calculer et retourner la surface
public int surface() {
return longueur * largeur ;
}
public int getLongueur() { return longueur ; }
public int getLargeur() { return largeur ; }
// On s'engage à IMPLÉMENTER la méthode "plusPetit"

public
public boolean plusPetit(Object r) {
return this.surface() < ( (Rectangle3) r).surface();
}

return "<longueur : " + longueur + ", " + largeur + ", surface : " +
surface() + ">"; }}
interface Comparable
{
public abstract boolean plusPetit(Object obj);
}
Classes concrètes vs abstraites vs interfaces :
Concrète Abstraite Interface

Création une instance avec Oui Non Non
new
Supporte des méthodes Non Oui Oui
abstraites
Supporte de l’héritage Non Non Oui
multiple
Droits des constructeurs Oui Oui Oui
Implémentation d’une nécessaire Oui si non Non car
méthode abstraite toutes sont
abstraites
Contenu Illimité Illimité public static
final
et
Méthodes
abstraites
77
Chapitre 10 :
Introduction aux applets
Une Applet = Application Internet écrite en Java intégrée à une page
HTML ne pouvant être qu'exécutée par un navigateur et s'affichant
dans la page HTML.
Une Applet est un programme Java (sans méthode main) exécuté dans
une page Web ou par un programme applet viewer.
Une page HTML est un fichier texte contenant des descriptions de la
mise en page du texte et des images. Ces descriptions sont destinées au
navigateur afin qu'il assure l'affichage de la page, elles s'effectuent par
l'intermédiaire de balises (parenthèses de description contextuelles). Un
fichier HTML commence toujours par la balise <HTML> et termine par
la balise </HTML>.
Une page HTML minimale contient deux sections :
❖ l'en-tête de la page balisée par <HEAD> ...</HEAD>
❖ le corps de la page balisé par <BODY> ... </BODY>
Voici un fichier texte minimal pour une page HTML :
<HTML>
<HEAD>
78
</HEAD>
<BODY>
</BODY>
</HTML>
Une applet Java est invoquée grâce à deux balises spéciales insérées au
sein du
corps de la page HTML : <APPLET CODE =.......> </APPLET>
10.1. La classe java.applet.Applet
Voici la hiérarchie des classes dont Applet dérive :
java.lang.Object
|
+--java.awt.Component
|
+--java.awt.Container
|
+--java.awt.Panel
|
+--java.applet.Applet
Minimum requis pour une applet :

Si vous voulez écrire des applets, il faut posséder un navigateur pour
exécuter
les applets et un éditeur de texte permettant d'écrire le code source
Java.
Vous pouvez aussi utiliser un environnement de développement Java
79
Tout environnement de développement java doit contenir un moyen de
visionner
le résultat de la programmation de votre applet, cet environnement
fera appel à
une visionneuse d'applet (dénommée AppletViewer dans le JDK).
Votre applet doit hériter de la classe Applet
public class AppletExemple extends Applet
{ .....……………..
…………………
Comme toutes les classes Java exécutables, le nom du fichier doit
correspondre très exactement au nom de la classe avec comme suffixe
java (ici : AppletExemple.java)
10.2. Fonctionnement d'une applet
10.2.1 La méthode init( )
La méthode init( ) est appelée une seule fois, lors du chargement de
l'applet avant que celui-ci ne soit affiché. Lorsqu'une applet s'exécute la
méthode principale qui s'appelait main( ) dans le cas d'une application
Java se dénomme ici init( ). Il nous appartient donc de surcharger
dynamiquement (redéfinir) la méthode init de la classe Applet afin que
notre applet fonctionne selon nos attentes.
Exemple d'applet vide :
80
import java.applet.*;
public class AppletExemple1 extends Applet
{
………………………………….
}
10.2.2 La méthode start( )
La méthode start( ) est appelée à chaque fois, soit :

❖ après la méthode init
❖ après chaque modification de la taille de l'applet (minimisation,...).
10.2.3 La méthode paint( )
La méthode paint( Graphics x ) est appelée à chaque fois, soit :
❖ après que l'applet a été masquée, déplacée, retaillée,...

❖ à chaque réaffichage de l'applet (après minimisation,...).
10.2.4 Les méthodes stop( ) et destroy( )
La méthode stop( ) est appelée à chaque fois, soit :
❖ que l'applet a été masquée dans la page du navigateur

(défilement vertical ou horizontal dans le navigateur), déplacée,
retaillée,...
❖ lors de l'abandon et du changement de la page dans le navigateur
81
La méthode destroy( ) est appelée à chaque fois, soit :
❖ que l'utilisateur charge une nouvelle page dans le navigateur

❖ lors de la fermeture du navigateur
10.3. Une applet dans une page HTML
6.3.1 Le code d'appel d'une applet
Le code d'appel d'une applet est intégré au texte source de la page dans
laquelle l'applet va être affichée. Ce sont les balises <APPLET CODE
=.......> et </APPLET> qui précisent les modalités de fonctionnement de
l'applet. En outre, l'applet s'affichera dans la page exactement à
l'emplacement de la balise dans le code HTML. Donc si l'on veut
déplacer la position d'une applet dans une page HTML, il suffit de
déplacer le code compris entre les deux balises <APPLET CODE =.......>
et </APPLET>.
Voici une page HTML dont le titre est "Exemple Applet " et ne
contenant qu'une applet
<HTML>
<HEAD>
<TITLE> Exemple Applet </TITLE>
</HEAD>
<BODY>
<APPLET CODE="NomApplet.class" WIDTH=200 HEIGHT=100>
</APPLET>
</BODY>
</HTML>
Il y a donc des paramètres obligatoires à transmettre à une applet, ce
sont les paramètres CODE, WIDTH et HEIGHT :
CODE : le nom du fichier contenant la classe applet à afficher.
82
WIDTH : la largeur de l'applet au démarrage dans la page HTML (en
pixels)
HEIGHT : la largeur de l'applet au démarrage dans la page
10.4. Quelques exemples sur les applets :
6.4.1. Premier exemple : quelques figures simples
/* Premier exemple simple sur Applet :
1) Applet : petite application exécutée par un navigateur Web
(exemple Netscape, Explorer, ....).
La méthode principale "void main" ne se présente pas.
2) AWT : Abstract Windowing Toolkit : un ensemble de classes pour
créer, surtout, une interface utilisateur graphique Graphics est une
classe de AWT
3) classe Applet : classe mère Les applets sont des sous-classes de la
classe Applet du paquetage (package) "java.applet" C'est la raison des
deux lignes d'importation
Syntaxe de quelques méthodes appliquées sur un objet (exemple g) de la
classe "Graphics" :
(dessiner) afficher une chaîne à partir d'une position
g.drawString(une chaîne de caractères, abscisse, ordonnée);
tracer une ligne reliée 2 points A et B
g.drawLine (A.x,A.y, B.x, B.y);
Dessiner un rectangle ABCD : g.drawRect(A.x, A.y, largeur
83
AB,hauteur BC);
A B
D C
dessiner un "arc" (d'une ellipse à l'intérieur d'un rectangle) à faire :

changer des paramètres, exécuter, observer pour comprendre le rôle
de ces paramètres
g.drawArc(A.x,A.y,largeur, hauteur,angle0, angleouverture);

drawArc(int x, int y, int width, int height, int startAngle, int
arcAngle)
import java.awt.*;
public class Applet1 extends Applet

{
public void paint(Graphics g)
{
g.drawString("Bonsoir", 10, 20);

g.drawLine (70,20, 150, 60);

g.drawLine (70,80, 150, 70);
g.drawRect(10, 90, 150,100);
g.drawArc(170,100,80,50, 200, 140);
g.drawOval(180,20, 260, 80);
}
}
Voici le fichier HTML qui lance cette applet :

<HTML>
<HEAD>
</HEAD>
<BODY>
84
<applet code= “Applet1.class” width=320 height=200 >

<param name=background value="008080">
<param name=foreground value="FFFFFF">
</applet>
</BODY>
</HTML>
Exécution
10.4.2) Deuxième exemple : quelques figures simples
/* Deuxième exemple simple sur Applet : affichage "ondulé" d'une

chaîne de caractères */
import java.awt.*;

{
//Phase initialisation d'une applet quand elle est chargée
public void init()
{
/* Le constructeur Font de la classe Font à 3 paramètres :
85
Font (police, style, taille)

Quelques exemples sur style :
Font.ITALIC : italique
Font.BOLD : en gras
Font.PLAIN: normal
Font.BOLD + Font.ITALIC : italique en gras etc ....
*/
setFont(new Font("TimesRoman", Font.PLAIN, 30));

}
public void paint(Graphics g) {
// chaîne de caractères à afficher

String souhait = "Bonsoir!" ; // 8 caractères
/* position de chaque lettre de la chaîne : tableau à deux indices : */

int [][] position = { {20, 80 },{40, 90 },{ 60, 100 },{80, 90 },{100, 80 },{ 120, 70
},{140,60 },{160,50 }};
// imposer la couleur (ici bleue)

g.setColor(Color.blue);
// affichage avec la méthode drawString

for (int i = 0 ; i < souhait.length() ; i++)
g.drawString( souhait.substring(i, i+1), position[i][0], position[i][1]); }}
<HTML>
<HEAD>
</HEAD>
<BODY>
</applet>
</BODY>
</HTML>
86
Execution
87
10.4.3) Troisième exemple : dessin d’un sourire!
/* Troisième exemple simple sur Applet : un sourire */
import java.awt.*;

{
static void dessinerSourire(Graphics g)
{
// dessiner la figure
g.drawOval(50, 40, 100, 120);
// coin en haut, à gauche (pour l'œil gauche) de la classe Point :
construire un point
Point p = new Point(70, 80);
/* notez que les 2 champs de données x et y de la classe Point ont

l'accès "public" qui est un cas très spécial g.fillRect(point.x, point.y,
longueur, largeur); ici on dessine l'œil gauche
*/
g.fillRect(p.x, p.y, 10, 10);
// Faire une translation pour le coin gauche, en haut de l'œil droit
p.translate(50,0);
// Dessiner l'œil droit
g.fillRect(p.x, p.y, 10, 10);
// dessiner le sourire (rire à toutes les dents? (2 derniers paramètres
g.drawArc(60,50, 70, 90, 200, 140);

}
88
// un cas de polymorphisme : surdéfinition de méthode
static void afficher(Graphics g, String texte, int x, int y)

{
g.setFont(new Font("Courier New", Font.ITALIC+Font.BOLD, 25));
g.setColor(Color.blue);
g.drawString(texte, x, y);
}
// un cas de polymorphisme : surdéfinition de méthode
static void afficher(String texte, Graphics g, int x, int y)

{
g.setColor(Color.black);
g.setFont(new Font("Courier New", Font.PLAIN, 14));
// à essayer de comprendre en observant l’exécution
for (int i = 0 ; i < texte.length() ; i++)

g.drawString(texte.substring(i, i+1), (x += 10), ((i >=texte.length()/2) ? (y
+=10):(y -=10)));
public void paint(Graphics g) {
dessinerSourire(g);
g.setColor(Color.darkGray);
g.drawLine(180,0, 180, 400);
afficher(g, "Vitamine S : un sourire!", 200, 50);
// un affichage spécial
afficher("Droit d'auteur à débarrasser!", g, 200, 250);
}
89
HTML>
<HEAD>
</HEAD>
<BODY>
</applet>
</BODY>
</HTML>
Execution
90

Poly Java 2023

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Poly Java 2023

Transféré par

Droits d'auteur :

Formats disponibles

Pr.

Mohamed Saad AZIZI

Ecole Nationale Supérieure de l'Intelligence. Artificielle et Sciences des Données - Taroudant

Orientée Objet Java :

Chapitre 1 : Introduction à la Programmation Orientée Objet …………..2

Chapitre 2 : la syntaxe et les éléments de base de Java………………….....5

Chapitre 3 : Les Méthodes en Java………………………………………………19

Chapitre 4: Les Tableaux en Java………………………………………………..23

Chapitre 5: Les Chaines de caractères…………………………………………29

Chapitre 6 : Programmation Orientée Objet…………………………………43

Chapitre 7 : Héritage en Java……………………………………………………..58

Chapitre 8 : Classes abstraites……………………………………………………..64

Chapitre 9 : Les Interfaces……………………………………………………..70

Chapitre 10 : Les Applets……………………………………………………..78

L'histoire de Java commence en 1991, lorsque Sun décide de lancer

Lorsqu'il est révélé en 1995, Java profite de l'essor d'Internet en

3. Les composants Java sont :

➢ Java Virtual Machine (JVM) : interpréteur Java

4. Principe de Fonctionnement de Java

Lorsque vous développez en Java, vous rencontrerez principalement

➢ Les fichiers ayant une extension .java : Ce sont de simples fichiers

Pour exécuter des applications en JAVA sur votre système, vous

La compilation des fichiers .java en fichiers .class se fait au moyen de

5. Avantages du Langage Java

Indépendance de la plate-forme (Portabilité) :

Le « bytecode » d’un fichier « *.class » est identique peu importe le

Programmation orientée objet :

Java est un langage de programmation orientée objet et donc, bénéficie

➢ Encapsulation (protection des données membres);

Améliorations ont été apportées par rapport au langage C++ :

Programmation réseau et multi-tâches : Thread

Programme est vérifié avant son interprétation.

la syntaxe et les éléments de base de Java

1. Caractéristique d’un programme Java

Un fichier de source Java peut contenir dans l’ordre :

Tout comme en langage C, une application doit avoir une méthode «

Le fameux Premier Programme :

public class Bonjour {

public static void main(String args[]) {

System.out.println(" Bonjour bienvenue au cours du Langage Java! ");

➢ Les commentaires sur une ligne débutent par //....

3. Importation de packages et de classes

Les packages sont des regroupements de classes ayant des points

L’importation de packages ou de classes se fait avec l’utilisation de

➢ import [ nom du package(*) ou de la classe ] ;

Voici quelques notes à retenir pour tout programme Java :

➢ Le langage Java fait la différence entre les majuscules et

Voici quelques conventions d’écriture à respecter :

➢ Le nom des classes et interfaces commence avec une majuscule;

5. Les mots-clés réservés pour java

Une variable est un nom pour un emplacement en mémoire.

Une variable peut être :

➢ Un type élémentaire de données.

Les noms de variables doivent obligatoirement commencer avec une

Lors de sa déclaration, une variable prend par défaut la valeur 0 ou «

7. Déclaration d’une constante

public static final int CONSTANTE = 15;

8. Types élémentaires de données.

Tableau des Types élémentaires en Java

Primitive Signification Taille (en Plage de valeurs acceptée

Tableau des opérateurs utilisables en Java

Opérateur Description Type

10. Entrées et sorties de l’information