1. Introduction

TP Traitement d’images
RAPPEL DE JAVA
Sujets abordés: Java et Programmation Orientée Objets
1. Introduction
Le but de ce TP est de rappeler différentes notions de Java avant d’aborder les TP de traitements
d’images « applications industrielles ». Les différentes questions de ce TP sont optionnelles et
dépendent surtout de votre niveau dans ce langage, aborder donc celles qui vous paraissent nécessaires.
Une lecture attentive du TP est au moins demandée.
2. Introduction à Java
Java est un langage développé dans le milieu des années 1990. La particularité de Java réside dans son
indépendance au matériel grâce à l’utilisation d’une machine dite virtuelle. Java est un langage O.O
(Orienté Objets). La programmation Java est donc basée sur la manipulation d’objets composés de
données membres et de méthodes. Les objets sont des instances de classes. La classe correspond à la
généralisation de type, une classe est une description d’un ensemble d’objets ayant une structure de
données commune et disposant des mêmes méthodes. Différentes ouvrages Java disponibles en ligne
peuvent trouvés en [1] [2] et [3] (voir bibliographie).
Premier programme
Vous pouvez écrire le programme suivant, l’enregistrer le dans un fichier (App.java) et le compiler et
l’exécuter à l’aide de votre environnement de programmation. Vous pouvez également utiliser la
commande « javac App.java » pour la compilation du fichier suivie de la commande « java –cp .\ App
» pour son exécution.
class App {
public static void main(String args[])
{ System.out.println("Hello World"); }
}
Remarque : le « .\ » est optionnel selon la configuration de l’exécutable java sur votre système.
Remarque : Des informations détaillées sur l’utilisation de javac et java sont fournies par la
documentation de la plate-forme SDK : j2sdkx.x.x/docs/index.html
App correspond ici à votre classe, et main la fonction d’exécution principale de cette classe. L’appel de
la fonction System.out.println correspond au printf en C et cout en C++. La déclaration static et public
sont des obligations indispensables pour l’appel de la fonction main. Cette déclaration vous oblige
également de déclarer votre classe App contenant le main dans un fichier de même nom (App.java). On
admettra dans cette première partie ces différentes notions, elles seront abordées plus en détails dans la
suite du TP. Dans votre répertoire source, le compilateur a créé un fichier (App.class). Ce fichier
correspond à votre exécutable Java, c’est le « binaire » (ou byte code) utilisé par la machine virtuelle
Java pour exécuter votre programme.
Premières notions .O.O
Vous pouvez reprendre le programme précédent de la façon suivante :
/** HelloWorld */
class HelloWorld {
//hello member
String hello = "Hello World";
/** sayHello */
void sayHello()
{ System.out.println(hello); }
}
/** App class */
class App {
/ ** main function */
public static void main(String args[]) {
HelloWorld my = new HelloWorld();
my.sayHello();
}
}
Vous avez défini ici votre première classe HelloWorld, et sa méthode sayHello(). my correspond à
votre premier objet instance de la classe HelloWorld, alloué suite à l’appel de l’opérateur new. La
notion d’opérateur est abordée plus tard dans ce TP. La méthode sayHello() est appelé via l’opérateur
point ., tel que my.sayHello(). Vous avez également défini votre première donnée membre hello de
votre classe HelloWorld de type String. Sur cet exemple, des commentaires ont été rajoutés de type
ligne // et bloc /** */.
A travers ce court exemple, vous avez vu les principes de base de la P.O.O, la classe HelloWorld, sa
méthode sayHello et sa donnée membre hello, et l’objet my instance de la classe HelloWorld alloué
suite à l’appel de l’opérateur new.
Remarque : La classe HelloWorld a été définie de façon Majuscule-Majuscule, et la méthode sayHello
de façon minuscule-Majuscule. C’est une convention de programmation implicite en Java.
Remarque : Prenez l’habitude de programmer en « anglais », et de commenter vos programmes à la
manière de cet exemple. En effet, le code et les commentaires formatés ainsi peuvent être traités par la
suite par l’outil de documentation automatique de code javadoc.
API specification
Avant d’aborder plus en détails la suite de ce TP, il nécessaire d’introduire l’API specification de la
plate forme Java 2 SDK. Ouvrir avec votre explorateur le fichier j2sdk1.x.x.x\docs\api\index.html, et
placer ce fichier en raccourci sur votre système (vous aurez à l’utiliser de nombreuses fois).

Cette documentation html correspond à la documentation de toutes les classes standards distribuées
avec la plate forme Java 2 SDK. Ces classes sont regroupées par package. Le package correspond à un
ensemble de classes (ou une librairie de classes spécifiques). La notion de package sera abordée plus en
détails dans la suite de ce TP.
Si vous faîtes défiler la barre de déroulement de la fenêtre bas gauche, vous avez un aperçu du nombre
de classe à disposition. Ajoutez à ça le volume « important » de projet Java à disposition sur Internet,
nous venons d’illustrer que la puissance du langage Java ne réside pas seulement dans le langage en lui
même, mais aussi par sa popularité.
Remarque : La documentation API specification est obtenu par utilisation de l’outil javadoc à partir du
code source Java des packages standrards Java, en respectant les règles de commentaire présentées
précédemment.
3. Types primitifs de données, opérateurs et instructions de contrôle
Introduction
Comme « tout » langage de programmation, Java est basé sur l’utilisation de types primitifs de
données, d’opérateurs, et d’instructions de contrôle. Le tableau suivant résume ces différents éléments.
Types primitifs
Entier
Flottant
Texte
Booléen
Pas de type
byte, short, int, long
float, double
char
bool
void
Opérateurs
Arithmétiques
Relationnels
Logiques
Affectation
Cast
(in,de)crémentation
Conditionnel
Allocation
Point
+, -, *, /, %
<, <=, >, >=, ==, !=
!, &, ^, |, &&, ||
=
(type)
++, --
?:
new
.
Instructions de contrôles
if, else, elseif
switch case
do while
for
break, continue
Ces diffèrents éléments sont similaires entre les langages de programmation, on les retrouve dans les
langages C et C++ par exemple. Nous détaillons ici quelques points particuliers.
Question : Commentez les 12 exemples suivants, vous pourrez implémenter ceux que vous ne
comprenez pas. Pour cela, vous pouvez créer une nouvelle classe Test1 comme le montre l’exemple
suivant. Dans cette classe, implémenter de nouvelles méthodes test() pour chacun de vos tests. Mettre
en œuvre cette classe depuis votre classe principale App.
class Test1 {
void testa() {…}
void testb() {…}
}
class App {
public static void main(String args[]) {
Test1 t = new Test();
t.testa();
}
}
Types primitifs de données
1. Déclaration
int a = 1;
{int b=2;}
int b=3;
System.out.println(a+b);
Opérateurs
2. L’opérateur modulo
int a = 11%4;
System.out.println(a);
3. Opérateurs d’affectation élargie
int a=2,b=2;
System.out.println(a = a+3);
System.out.println(b += 3);
4. Priorités entre opérateurs
int i=0;
System.out.println((i++) == 0);
int j=0;
System.out.println((j+=1) == 0);
5. Opérateurs de court-circuit
int i=0;
if(false && (i++==0)){}
System.out.println(i);
int j=0;
if(false & (j++==0)){}

System.out.println(j);
6. Opérateur de Cast
System.out.println(1.2/0.7);
System.out.println((int)(1.2/0.7));
7. Opérateur conditionnel
int a=1,b=2,m1,m2;
if(a>b) m1=a;
else m1=b;
System.out.println(m1);
m2 = a>b ? a : b;
System.out.println(m2);
8. Opérateur new
int a=0;
HelloWorld my1 = null;
HelloWorld my2 = new HelloWorld();
System.out.println(a+" "+" "+my1+" "+my2);
my2 = new HelloWorld();
System.out.println(a+" "+" "+my1+" "+my2);
Remarque : L’opérateur delete n’existe pas en Java, en effet la désallocation des objets est assurée par
le garbage collector « ramasse-miettes ».
9. Opérateur point
HelloWorld my = new HelloWorld();
my.sayHello();
System.out.println(my.hello);
Instruction de contrôle
10. Conditions imbriquées
int b;
for(int a=0;a<10;a++)
{
if(a<5) b=1;
else if((a>=5)&(a<8)) b=2;
else if((a>=8)&(a<9)) b=3;
else b=4;
System.out.println(b);
}
11. Instruction for (1)
int i=0;
for(i=0;i<5;i++)
System.out.println(i);
i=0;
for(;i<5;i++)
System.out.println(i);
i=0;
for(;(i+=1)<5;)
System.out.println(i);
12. Instruction for (2)
for(int i=0, j=10;j>i;i++,j--)
System.out.println(i+";"+j);
for(int i=0, j=10; ;i++,j--) {
System.out.println(i+";"+j);
if(j<i) break;
}
4. Tableaux
Introduction
Comme « tout » langage de programmation, Java permet la manipulation de tableaux. Cependant, Java
fait preuve d’originalité sur ce point en considérant les tableaux comme des objets, et en permettant la
composition de tableaux multi-dimensionnels à partir de tableaux de dimensions inférieures. Nous
illustrons ici l’utilisation des tableaux en Java à travers quelques exemples.
Manipulation
Nous illustrons ici l’utilisation des tableaux en Java à travers quelques exemples.
Question : Commenter les 5 exemples suivants. Vous pourrez implémenter ceux que vous ne
comprenez pas. Pour cela vous pourrez créer une nouvelle classe Test2 :
1. Déclaration, allocation, initialisation, et accès
int [] t1 = new int[3];
int t2[] = {1,2,3};
for(int i=0;i<3;i++)
System.out.println(t1[i] + ";" + t2[i]);
2. Taille et affectation
int [] t1 = new int[3];

int t2[] = {1,2,3};
for(int i=0;i<t1.length;i++)
{
t1[i] = t2[i];
System.out.println(t1[i] + ";" + t2[i]);
}
3. Affectation et passage par argument
void update(int t[]) {
if(t.length>=2)
t[1] = 5;
}
void test() {
int t1[], t2[] = {1,2,3};
t1 = t2; t1[0] = 4;
System.out.println(t2[0]+";"+t1[0]);
update(t2);
System.out.println(t2[1]+";"+t1[1]);
}
4. Tableaux à plusieurs dimensions (1)
int t1[][] = new int[2][3];
int [][]t2 = {{1,2,3},{4,5,6}};
for(int i=0;i<t1.length;i++)
for(int j=0;j<t1[i].length;j++) {
System.out.println(t1[i][j]);
System.out.println(t2[i][j]);
}
5. Tableaux à plusieurs dimensions (2)
int t[][] = new int[2][];
int t1[] = {1,2,3}, t2[] = {4,5,6,7,8};
t[0] = t1;t[1] = t2;
t1[1] = 0; t2[2] = 0;
for(int i=0;i<t.length;i++)
for(int j=0;j<t[i].length;j++)
System.out.println(t[i][j]);
5. Chaînes de caractères
Introduction
Java permet la manipulation de chaînes de caractères. Ces chaînes de caractères sont en fait des objets,
instance de la classe standard Java String. Leur utilisation est assez proche des tableaux. Java fait
preuve d’originalité sur la gestion des chaînes de caractères, en imposant que les objets de type String
ne soient pas modifiables. Ils restent cependant utilisables pour la création de nouveaux objets.
Manipulation
Nous illustrons ici l’utilisation des chaînes de caractères en Java à travers quelques exemples.
Question : Commentez les 6 exemples suivants, vous pourrez implémenter ceux que vous ne
comprenez pas. Pour cela, vous pouvez créer une nouvelle classe Test3
1. Déclaration, allocation, et initialisation
String s1 = new String("hello");
String s2 = "hello";
String s3 = new String(s1);
System.out.println(s1 + " " + s2 + " " + s3);
2. Affectation
String s1 = "hello1", s2 = s1;
System.out.println(Integer.toHexString(s1.hashCode()));
s1 = "hello2";
System.out.println(s1 + " " + s2);
System.out.println(Integer.toHexString(s1.hashCode()));
On admettra ici l’écriture de Integer.toHexString(o.hashCode()) pour la récupération sous forme de
chaîne de caractères de la référence de l’objet o. Elle sera abordée dans la suite de ce TP.
3. Opérateurs arithmétiques, d’affectation, et d’affectation élargie
String s1 = "Java", s2 = "2";
String s = s1 + s2;
System.out.println(s);
s1 += s2;
System.out.println(s1);
4. Opérateurs relationnels
String s1 = "Java", s2 = "Java";
System.out.println(s1 == s2);
System.out.println(s1 != s2);
System.out.println(s1 == s1);
5. Longueur, accès aux caractères, recherche, et sous chaînes

String s = "JavaTM 2 Platform"; char c;
for(int i=0;i<s.length();i++)
{c = s.charAt(i);System.out.println(c);}
int b = s.indexOf('T');
int e = s.indexOf('a',b);
String r = s.substring(b+1,e);
System.out.println(r);
6. Comparaison, modification, et conversion
String s1 = "Java"; String s2 = "Jovo";
System.out.println(s1.equals(s2));
s2 = s2.replace('o','a');
System.out.println(s1.equals(s2));
String cvt = new String();
for(int i=1;i<=2;i++)
{System.out.println(s2+cvt.valueOf(i));}
6. Objets
Dans cette partie nous vous proposons d’aborder l’utilisation des objets en Java. On rappelle que les
objets sont composés de données membres et de méthodes, et sont des instances de classes. La classe
correspond à la généralisation de type, c’est une description d’un ensemble d’objets ayant une structure
de données commune et disposant des mêmes méthodes.
Déclaration de classes et encapsulation de données membres
Considérons l’exemple suivant
class Point {
private int x,y;char l;
private void check()
{if(x<0) x=0; if(y<0) y=0;}
void move(int dx, int dy)
{x+=dx; y+=dy; check();}
void set(int xi,int yi)
{x = xi; y= yi; check();}
int getX() {return x;}
int getY() {return y;}
void print()
{System.out.println(x+";"+y+":"+l);}
}
Et sa mise en oeuvre :
Point pt = new Point();
pt.print();
pt.l = 'o';
pt.set(5,2);
pt.print();
pt.move(-6,4);
pt.print();
Il illustre les principes de base de la programmation objet avec : la classe Point, ses différentes
méthodes, ses données membres x y et l (un label), et l’objet pt instance de la classe Point, alloué suite
à l’appel de l’opérateur new. Les méthodes et données membres des objets sont accessibles par
l’utilisation de l’opérateur point ., comme par exemple pt.print() et pt.l. Cet exemple met en œuvre un
principe important de la P.O.O. : l’encapsulation des données membres. En effet, les données membres
x et y ont été déclarées à l’aide du mot clé private. Ceci signifie qu’elles sont accessibles uniquement
par les méthodes de classe Point. Il en est de même pour la méthode check(). La donnée membre l est
par contre accessible de l’extérieur, comme le montre l’appel pt.l.
Remarque : Il existe en fait quatre déclarations de droit d’accès : private, pas de déclaration,
protected, et public. Les différences entre ces déclarations seront abordées dans la suite de ce TP.
Constructeurs
Au cours de l’exemple précédent, vous avez eu recours à l’opérateur new et le constructeur Point()
pour allouer l’objet pt instance de la classe Point. Vous avez utilisé ici le constructeur par défaut. Si
vous rajoutez ce bloc de code à la définition de votre classe Point :
Point() {}
Vous redéfinissez alors le constructeur par défaut de la classe Point. En l’absence de constructeur
défini dans la classe Point, ce constructeur est en fait déclaré implicitement. Considérons l’exemple
suivant :
Point pt;
pt = new Point();
pt.print();
System.out.println(new Point());
new Point().print();
A travers ce court exemple vous avez vu la mise en œuvre du constructeur Point() via l’utilisation de
l’opérateur new. La commande new Point() alloue un objet de type Point et retourne sa référence. Cette
référence peut être ensuite stockée dans une variable de type Point (ici pt). Le stockage de cette
référence peut également être ignorée, et l’objet utilisé « à usage unique » à un instant donné du
programme comme le montre l’exemple de code : new Point().print();
Question : Expliquer l’erreur de compilation générée par le code suivant. Que concluez-vous sur
l’utilisation du constructeur par défaut ?