Cours programmation en Java exercices et corrigés, tutoriel & guide de travaux pratiques JAVA en pdf.

Interfaces graphiques
Fenetres

La classe JFrame
Une fen^etre est un objet de type JFrame, classe a laquelle on accede avec la commande d’importation import javax.swing.*. Nous utiliserons les methodes suivantes :
{ public void setTitle(String title), pour de nir le titre de la fen^etre. { public void setVisible(boolean b), pour a cher la fen^etre.
{ public void setSize(int width, height), pour preciser les dimensions de la fen^etre.
{ public void setDefaultCloseOperation(int operation), pour determiner le comportement de la fen^etre lors de sa fermeture.
Exemples
Voici un code de creation d’une fen^etre vide.
import j a v a x . swing . ;
public c l a s s P r e m i e r e F e n e t r e
f void main ( S t r i n g [ ] a r g s )
public s t a t i c  f
JFrame f = new JFrame ( ) ;
f . s e t V i s i b l e ( true ) ;
f . s e t T i t l e ( « My f i r s t window ! »);
f . s e t S i z e ( 2 0 0 , 2 0 0 ) ;
f . s e t D e f a u l t C l o s e O p e r a t i o n ( JFrame . EXIT ON CLOSE ) ;
La facon suivante nous sera utile pour gerer les evenements :
import j a v a x . swing . ;
public c l a s s DeuxiemeFenetre extends JFrame f
public DeuxiemeFenetre ( )
super ( ) ;
s e t T i t l e ( « My s e c o nd window !  » ) ;
s e t S i z e ( 2 0 0 , 2 0 0 ) ;
s e t D e f a u l t C l o s e O p e r a t i o n (EXIT ON CLOSE ) ;
public void a f f i c h e ( )
s e t V i s i b l e ( true ) ;
public s t a t i c void main ( S t r i n g [ ] a r g s )
DeuxiemeFenetre f = new DeuxiemeFenetre ( ) ; f . a f f i c h e ( ) ;

Un premier objet graphique

Nous allons ajouter un bouton dans notre fen^etre. Les boutons sont de type JButton, le constructeur de cette classe prend en parametre le libell du bouton. Un des attributs de la classe JFrame est un objet contenant tous les composants graphiques de la fen^etre, on accede a cet objet par la methode public Container getContentPane(). Tout Container possede une methode public Component add(Component comp) permettant d’ajouter n’importe quel composant graphique (par exemple un JButton…). On ajoute donc un Bouton de la facon suivante getContentPane().add(new JButton(« my First JButton »)) ;.
import j a v a x . swing . ;
import j a v a . awt . ;
public c l a s s P r e m i e r s J B u t t o n s extends JFrame f
public P r e m i e r s J B u t t o n s ( )
super ( ) ;
s e t T i t l e ( « My t h i r d window !  » ) ;
s e t S i z e ( 2 0 0 , 2 0 0 ) ;
s e t D e f a u l t C l o s e O p e r a t i o n (EXIT ON CLOSE ) ; getContentPane ( ) . s e t L a y o u t (new FlowLayout ( ) ) ; getContentPane ( ) . add (new JButton ( « my F i r s t JButton  » ) ) ; getContentPane ( ) . add (new JButton ( « my Second JButton  » ) ) ; getContentPane ( ) . add (new JButton ( « my Third JButton  » ) ) ; s e t V i s i b l e ( true ) ;
public s t a t i c void main ( S t r i n g [ ] a r g s )
new P r e m i e r s J B u t t o n s ( ) ;
L’instruction getContentPane().setLayout(new FlowLayout()) ; sert a preciser de quelle facon vous souhaitez que les composants soient disposes dans la fen^etre. Nous reviendrons dessus.

Ecouteurs d’evenements

Un ecouteur d’evenement est un objet associe a un composant graphique. Cet objet doit implementer l’in-terface ActionListener et de ce fait contenir une methode public void actionPerformed(ActionEvent e). Cette methode est appelee a chaque fois qu’un evenement se produit sur le composant. L’objet ActionEvent contient des informations sur l’evenement en question.

Premier exemple

Dans ce premier exemple, nous allons de nir une classe public class PremierEcouteur extends JFrame implements ActionListener. Elle servira donc a la fois de fen^etre et d’ecouteur d’evenements. L’objet de type ActionEvent passe en parametre contient une methode public Object getSource() retournant l’objet ayant declench l’evenement.
import j a v a x . swing . ;
import j a v a . awt . e v e n t . ;
import j a v a . awt . ;
public c l a s s PremierEcouteur extends JFrame implements A c t i o n L i s t e n e r f
JButton [ ] j B u t t o n s ;
public void a c t i o n P e r f o r m e d ( ActionEvent e )
int k = 0 ;
while ( j B u t t o n s [ k++] != e . g e t S o u r c e ( ) ) ;
System . out . p r i n t l n (  » c l i c k on JButton  » + k ) ;
public PremierEcouteur ( )
super ( ) ;
j B u t t o n s = new JButton [ 3 ] ;
s e t T i t l e ( « My f o u r t h window !  » ) ;
s e t S i z e ( 2 0 0 , 2 0 0 ) ;
s e t D e f a u l t C l o s e O p e r a t i o n (EXIT ON CLOSE ) ;
getContentPane ( ) . s e t L a y o u t (new FlowLayout ( ) ) ;
j B u t t o n s [ 0 ] = new JButton ( « my F i r s t JButton  » ) ;
j B u t t o n s [ 1 ] = new JButton ( « my Second JButton  » ) ;
j B u t t o n s [ 2 ] = new JButton ( « my Third JButton  » ) ;
for ( int i = 0 ; i < 3 ; i ++)
getContentPane ( ) . add ( j B u t t o n s [ i ] ) ;
j B u t t o n s [ i ] . a d d A c t i o n L i s t e n e r ( this ) ;
s e t V i s i b l e ( true ) ;
public s t a t i c void main ( S t r i n g [ ] a r g s )
new PremierEcouteur ( ) ;

Classes anonymes

Les classes anonymes sont des classes que l’on peut creer « a la volee », c’est-a-dire au moment de leur ins-tanciation.. On s’en sert generalement pour implementer une interface, en l’occurrence ActionListener. Voici une autre implementation faisant intervenir des classes anonymes.
import j a v a x . swing . ;
import j a v a . awt . e v e n t . ;
import j a v a . awt . ;
public c l a s s EcouteurAnonyme extends JFrame f
public EcouteurAnonyme ( )
super ( ) ;
JButton [ ] j B u t t o n s = new JButton [ 3 ] ;
s e t T i t l e ( « My f o u r t h window !  » ) ;
s e t S i z e ( 2 0 0 , 2 0 0 ) ;
s e t D e f a u l t C l o s e O p e r a t i o n (EXIT ON CLOSE ) ; getContentPane ( ) . s e t L a y o u t (new FlowLayout ( ) ) ;
j B u t t o n s [ 0 ] = new JButton ( « my F i r s t JButton  » ) ; j B u t t o n s [ 1 ] = new JButton ( « my Second JButton  » ) ;
j B u t t o n s [ 2 ] = new JButton ( « my Third JButton  » ) ;
for ( int i = 0 ; i < 3 ; i ++)
getContentPane ( ) . add ( j B u t t o n s [ i ] ) ;
j B u t t o n s [ 0 ] . a d d A c t i o n L i s t e n e r (new A c t i o n L i s t e n e r ( )
f public void a c t i o n P e r f o r m e d ( ActionEvent e )
System . out . p r i n t l n (  » c l i c k on F i r s t JButton  » ) ;
) ;
j B u t t o n s [ 1 ] . a d d A c t i o n L i s t e n e r (new A c t i o n L i s t e n e r ( )
f public void a c t i o n P e r f o r m e d ( ActionEvent e )
System . out . p r i n t l n (  » c l i c k on Second JButton  » ) ;
) ;
j B u t t o n s [ 2 ] . a d d A c t i o n L i s t e n e r (new A c t i o n L i s t e n e r ( )
f public void a c t i o n P e r f o r m e d ( ActionEvent e )
System . out . p r i n t l n (  » c l i c k on Third JButton  » ) ;
) ;
s e t V i s i b l e ( true ) ;
public s t a t i c void main ( S t r i n g [ ] a r g s )
new EcouteurAnonyme ( ) ;

Gestionnaires de mise en forme

Un gestionnaire de mise en forme (Layout manager) est un objet permettant de disposer les composants et les conteneurs dans la fen^etre. Nous avons utilise un gestionnaire de type FlowLayout, qui dispose les composants les uns a cote des autres (ou au dessus des autres si ce n’est pas possible) dans leur ordre d’ajout. Le gestionnaire GridLayout represente le conteneur comme une grille
import j a v a x . swing . ;
import j a v a . awt . e v e n t . ;
import j a v a . awt . ;
public c l a s s TestGridLayout extends JFrame implements A c t i o n L i s t e n e r f
JButton [ ] j B u t t o n s ;
public void a c t i o n P e r f o r m e d ( ActionEvent e )
int k = 0 ;
while ( j B u t t o n s [ k++] != e . g e t S o u r c e ( ) ) ;
System . out . p r i n t l n (  » c l i c k on JButton  » + k ) ;
public TestGridLayout ( )
super ( ) ;
j B u t t o n s = new JButton [ 4 ] ;
s e t T i t l e ( « One More Window ! »);
s e t S i z e ( 2 0 0 , 2 0 0 ) ;
s e t D e f a u l t C l o s e O p e r a t i o n (EXIT ON CLOSE ) ;
getContentPane ( ) . s e t L a y o u t (new GridLayout ( 2 , 2 ) ) ;
j B u t t o n s [ 0 ] = new JButton ( « my F i r s t JButton  » ) ;
j B u t t o n s [ 1 ] = new JButton ( « my Second JButton  » ) ;
j B u t t o n s [ 2 ] = new JButton ( « my Third JButton  » ) ;
j B u t t o n s [ 3 ] = new JButton ( « my Fourth JButton  » ) ;
for ( int i = 0 ; i < 4 ; i ++)
getContentPane ( ) . add ( j B u t t o n s [ i ] ) ;
j B u t t o n s [ i ] . a d d A c t i o n L i s t e n e r ( this ) ;
s e t V i s i b l e ( true ) ;
public s t a t i c void main ( S t r i n g [ ] a r g s )
new TestGridLayout ( ) ;

Un exemple complet : Calcul d’un carre

import j a v a x . swing . ;
import j a v a . awt . e v e n t . ;
import j a v a . awt . ;
public c l a s s Carre extends JFrame implements K e y L i s t e n e r f
J T e x t F i e l d o p e r a n d T e x t F i e l d ;
JLabel r e s u l t T e x t F i e l d ;
public void k e y P r e s s e d ( KeyEvent e )fg
public void k e y R e l e a s e d ( KeyEvent e )
try
f k = I n t e g e r . p a r s e I n t ( o p e r a n d T e x t F i e l d . getText ( ) ) ;
int
k = k ;
r e s u l t T e x t F i e l d . s e t T e x t ( I n t e g e r . t o S t r i n g ( k ) ) ; g
catch ( E x c e p t i o n ex )
i f ( r e s u l t T e x t F i e l d != null )
r e s u l t T e x t F i e l d . s e t T e x t ( «  » ) ;
public void keyTyped ( KeyEvent e )fg
public Carre ( )
super ( ) ;
s e t S i z e ( 2 0 0 , 2 0 0 ) ;
s e t T i t l e (  » Square computer !  » ) ;
s e t D e f a u l t C l o s e O p e r a t i o n (EXIT ON CLOSE ) ; getContentPane ( ) . s e t L a y o u t (new GridLayout ( 2 , 2 ) ) ; getContentPane ( ) . add (new JLabel ( « x =  » ) ) ; o p e r a n d T e x t F i e l d = new J T e x t F i e l d ( ) ;
o p e r a n d T e x t F i e l d . a d d K e y L i s t e n e r ( this ) ; getContentPane ( ) . add ( o p e r a n d T e x t F i e l d ) ; getContentPane ( ) . add (new JLabel ( « x ^2 =  » ) ) ; r e s u l t T e x t F i e l d = new JLabel ( ) ; getContentPane ( ) . add ( r e s u l t T e x t F i e l d ) ; s e t V i s i b l e ( true ) ;
public s t a t i c void main ( S t r i n g [ ] a r g s )
new Carre ( ) ;

Collections

Packages
L’instruction import que vous utilisez depuis le debut sert a localiser une classe parmi les packages standard de Java. Si par exemple vous importez import java.awt.event.*, cela signi e que vous allez utiliser les classes se trouvant dans le package qui se trouve dans le package event qui se trouve dans le package awt qui se trouve dans le package java (qui est la bibliotheque standard).
Creer ses propres packages
Il possible pour un programmeur de creer ses propres packages, deux choses sont necessaires :
{ Utilisez la m^eme arborescence dans le systeme de chier que celle des packages { Ajouter au debut de chaque source sa position dans l’arborescence.
Par exemple,
package c o l l e c t i o n s ;
public c l a s s ExemplePackage
f s t a t i c void p r e s e n t e T o i ( )
public
System . out . p r i n t l n (  » Je s u i s c o l l e c t i o n s . ExemplePackage  » ) ;
public s t a t i c void main ( S t r i n g [ ] a r g s )
p r e s e n t e T o i ( ) ;
On execute et compile ce chier en se placant non pas dans le repertoire ou se trouve les source, mais dans le repertoire ou se trouve le package. Par consequent, l’execution en ligne de commande se fait avec javac collections.ExemplePackage
Utiliser ses propres packages
Vos packages s’utilisent comme les packages de la bibliotheque standard. Si le main se trouve en dehors de votre package, la variable d’environnement CLASSPATH sera utilisee pour localiser votre package.
Visibilite
En l’absence de mots-cles public (tout le monde), private (seulement la classe) et protected (classe + classes derivees), une visibilite par defaut est appliquee. Par defaut, la visibilite des elements est limitee au package.

Types parametres

L’utilisation du type Object pour faire de la genericit en Java se paye avec des instruction de ce type m a C o l l e c t i o n . add (new C l a s s e F i l l e ( ) ) ;
C l a s s e F i l l e f = ( C l a s s e F i l l e ) m a C o l l e c t i o n . g e t ( 0 ) ;
Il est necessaire d’e ectuer un cast particulierement laid pour passer la compilation. On prend par consequent le risque qu’une exception soit levee a l’execution s’il s’avere que l’objet recuper n’est pas de type ClassFille. Les types parametres fournissent un moyen elegant de resoudre ce probleme.

Java Vs C++

Le mecanisme des classes parametrees en Java en bien plus n que les templates utilisees en C++. Les templates ne sont que de vulgaires rechercher/remplacer, alors qu’en Java, le code compile est le m^eme que si les types ne sont pas parametres. Les types parametres de java ne sont donc qu’un moyen pour le compilateur de s’assurer que vous faites les choses proprement en vous obligeant a declarer les types que vous placez dans les collections.

La syntaxe

La syntaxe est par contre la m^eme qu’en C++ : il su t d’utiliser des chevrons pour placer le parametre. Par exemple,
public c l a s s ExempleClasseParametree<T>
T data ;
public ExempleClasseParametree (T data )
this . data = data ;
public T g e t ( )
return data ;
On est amen naturellement a se demander si ExempleClasseParametree<String> herite de ExempleClasseParametre Un exercice traite cette question.
Contraintes sur le parametre
Il est souvent necessaire que le type servant de parametre veri e certaines proprietes. Si vous souhaitez par exemple que l’objet herite de Comparable, vous avez la possibilite de poser cette contrainte avec le parametre <T extends Comparable>. La de nition ci-avant est incomplete, le soin vous est laisse de la completer…

Collections standard

La distribution o cielle de Java est fournie avec plusieurs milliers de classes. Les Collections sont des structures de donnees permettant d’optimiser des operations comme le tri, la recherche de plus petit element, etc. Les collections sont donc des regroupements d’objets.
Classi cation des collections
L’interface Collection<T> decrit ce que doit faire chaque collection. Elle plusieurs sous-interfaces, parmi lesquelles on trouve :
{ List<T> conserve l’ordre des elements dans l’ordre dans lequel le programmeur souhaite qu’ils soient.
{ Set<T> ne tient pas compte de l’ordre des elements.
{ Queue<T> est optimise pour recuperer rapidement le plus petit element.
Ces interfaces sont implementees dans diverses classes ou divisees avec des sous-interfaces permettent d’obtenir des fonctionnalites plus precises.

1 Notes de cours
1.1 Introduction
1.2 Le Java procedural
1.3 Objets
1.4 Tableaux
1.5 Encapsulation
1.6 Heritage
1.7 Exceptions
1.8 Interfaces graphiques
1.9 Collections
1.10 Threads
2 Exercices
2.1 Le Java procedural
2.2 Objets
2.3 Tableaux
2.4 Encapsulation
2.5 Heritage
2.6 Exceptions
2.7 Interfaces graphiques
2.8 Collections
2.9 Threads
3 Corriges
3.1 Java Procédural
3.2 Objets
3.3 Tableaux
3.4 Encapsulation
3.5 Héritage
3.6 Exceptions
3.7 Interfaces graphiques
3.8 Collections
3.9 Threads

……….