Support de cours langage Java programmation graphique

Facebook Tweet Pin Email

I Java: Le langage
1 Des procédures aux objets
2 C’est quoi Java?
3 Eléments de base
4 Opérations et expressions
5 Les structures de contrôle
6 Classes et Objets
7 Héritage
8 Les interfaces
9 Packages
10 Exceptions
11 Tableaux et chaînes de caractères
12 Conversions et promotions
13 Classes imbriquées
14 La hiérarchie des classes
15 Entrées-Sorties
16 Serialization
17 Compression des données
18 Le package java.util
19 Les types
20 Programmation système
21 Programmation dynamique
22 Threads
II Java: Programmation graphique
23 Applets et applications autonomes
24 Découvrir la programmation graphique
25 Gestion des évènements
26 Les widgets
27 Ranger les widgets
28 Dessiner sur une fenêtre graphique
29 Couleurs et Fontes
30 Images
31 Le son
III Java: JFC
32 JavaFoundation Class
33 Les composants Swing
34 Gestion des évènements swing
35 Transfert de données
36 Java2D
37 Java3D
38 Quelques classes Swing
IV Java: Programmation avancée
39 Programmation réseau
40 Appel de méthodes distantes (RMI)
41 Introduction aux bases de données
42 Introduction à JDBC
43 Code natif (JNI)
44 Corba
V Java: Beans
45 Introduction à Java Beans
VI Java: Annexes
46 javadoc
47 Le langage SQL
48 Fromat jar et zip
VII Java: Travauxdirigés
VIII Java: Corrigés
IX Java: Travauxpratiques
X Java: Corrigésdestravauxpratiques

Des procédures aux objets

La programmation procédurale
La programmation procédurale est celle que vous connaissez. Dans ce style de programmation, l’accent est mis sur l’exécution du programme. Les facilités de base oertes par les langages qui supportent ce style de programmation sont les fonctions qui admettent des arguments et qui renvoient des valeurs. Comme exemple, considérons la fonction qui calcule lepgcd de deux entiers positifs
long pgcd(long x, long y) {
unsigned long r ;
if(x<y){r=x;x=y;y=x;}
do {
r=x%y // r est le reste de la division entière de x et y
x=y;
y=r
} // réitérer ce processus en échangeant (x, y) par (y, r)
while (r != 0) ; // tant que le reste de la division entière x et y est non nul
return x ; // retourne le pgcd
}
Une fois cette fonction donnée, il est possible à présent d’utiliser cette fonction dans toute autre fonction.
void une_fonction(void) {
…
x = pgcd(4356, y) ;
…
}

Programmation modulaire
Avec l’augmentation de la taille des programmes, la programmation procédurale atteint ses limites ; la programmation modulaire voit alors le jour. Ce style de programmation utilise les principes d’encapsulation des données. L’ensemble des procédures ou fonctions dépendantes et les données qu’elles manipulent sont regroupés dans un module. Un programme est alors constitué de plusieurs modules et la communication inter-modules se fait à travers une interface ; les détails d’implantation de chaque module sont cachés aux autres modules. Imaginons qu’il faille réaliser un programme dans lequel on utilise des piles. Un des modules de ce programme se charge de l’implantation d’une pile et les détails de cette implantation devant être ignorés par les autres modules. L’interface que fournit ce module est constituée d’un chier (par exemple » pile.h « )
// Interface du module PILE de caractères (pile.h)
void empiler(char) ;
char depiler(void) ;
// Fin de l’interface
Les utilisateurs de ce module ignorent parfaitement les détails d’implantation de cette pile. En particulier, s’agit-il d’un tableau ou d’une liste chaînée ? Seul le programmeur de ce module le sait. L’utilisation de ce module par d’autres se fait alors de la manière suivante :
// Module XXX utilisant une pile de caractère
#include « pile.h »
void une_fonction() {
short c1, c2 ;
…
empiler(‘a’) ;
empiler(‘b’) ;
…
c1 = depiler() ;
if (c1 == ERREUR) erreur( » la pile est vide « ) ;
c2 = depiler() ;
if (c2 == ERREUR) erreur( » la pile est vide « ) ;
…
}
// Fin du module XXX

Flexibilité
Une fois un type de donnée abstrait déni, il interfère très peu avec le reste de programme; pourtant toute modification ou enrichissement de ce type de donnée entraîne une refonte complète du programme. Imaginons que l’on définit un type de donnée forme.
enum type {cercle, triangle, carree} ;
typedef struct forme {
point centre ;
type t ;
} forme ;
Le programmeur devra connaître toutes les formes manipulées pour implanter la fonction dessiner :
void dessiner(forme f) {
switch(t.type) {
case cercle :
…
break ;
case triangle :
…
break ;
case carree :
…
break ;
}
}

Abstraction de données
Le support pour la programmation par abstraction de données consiste à fournir des facilités pour définir des opérations pour un type déni par l’utilisateur. Contrairement aux types prédéfinis, aucun système ne peut définir, par défaut, les fonctions d’initialisation et de destruction des types définis par le programmeur ; il lui appartient donc de fournir ces fonctions.
Considérons un type nouvellement défini (que l’on appellera tableau) qui est constitué de sa taille et d’un pointeur vers les éléments du tableau. La création d’un objet de type tableau se fait en définissant une variable de la classe tableau. Que doit-on créer à l’initialisation ? Faut-il allouer la place nécessaire pour coder le tableau ? etc. Les réponses à ces questions ne peuvent être fournies que par l’utilisateur ayant défini le type tableau.
Une première solution consiste à se définir une fonctioninitque l’utilisateur se forcera à appeler avant toute utilisation d’un objet d’un type utilisateur.
class tableau { private int [] t ; public void init(int taille) ;
…
};
void une_fonction() {
tableau t ;
…
t.init(2) ; // n’utiliser t qu’après son initialisation
}

Les concepts de la programmation par objets
Les concepts clés de la programmation orientée objets sont :les objets qui sont des collections d’attributs et méthodes associées. les messages qui servent de moyen de communication entre objets les classes qui servent à définir des modèles d’objets. l’héritage qui fournit un mécanisme puissant et naturel pour organiser et structurer les programmes.

Qu’est-ce qu’un objet ?
Comme leur nom l’indique, les objets sont au c.ur de la programmation par objet. Dans la vie courante, le monde réel qui nous entoure est constitué d’objets. Ces objets possèdent deux caractéristiques : ils sont dans un certain état et possède un comportement.
Les objets dont nous allons étudier sont similaires aux objets du monde réel qui nous entoure en ce sens, qu’eux également, sont dans un certain état et possèdent un certain nombre de comportements. L’état d’un objet est représenté par des attributs et les comportements sont définis par des méthodes.
Un objet est une collection d’attributs munis de méthodes On peut représenter les objets du monde réel par des objets informatiques comme c’est le cas dans un programme d’animation. On peut également représenter des concepts abstraits ; une manipulation graphique est un objet dans un environnement graphique. Un objet qui modélise un objet du monde réel (un vélo, par exemple) possède des attributs qui indiquent l’état de celui-ci (la vitesse, la cadence de pédalage etc.). Le comportement de cet objet est constitué par des méthodes (accélération, freinage, changement de vitesse, etc.). Les seules actions possibles sur les objets sont celles définies par les méthodes. Les changements d’état (modification des variables d’attributs) ne sont permis qu’à travers les méthodes. Cette manière de protéger les attributs par des méthodes s’appelle encapsulation.

….