Formation programmation orientée objets en JAVA, tutoriel & guide de travaux pratiques en pdf.

1 Introduction
1.1 Vocation de ce document
1.2 De la programmation structurée à la programmation orientée objets
2 Des objets et des classes
2.1 Introduction
2.2 Les classes
2.2.1 Nature des classes
2.2.2 Éléments de syntaxe
2.2.3 Conventions de notation
2.2.4 Un exemple commenté
2.3 Les attributs
2.4 Les méthodes
2.4.1 Signature et surcharge
2.4.2 Des fonctions aux méthodes
2.5 Les membres statiques
2.5.1 Les attributs statiques
2.5.2 Les méthodes statiques
3 Cycle de vie des objets
3.1 Introduction
3.2 Allocation mémoire et construction des objets
3.2.1 Constructeur par défaut
3.2.2 this
3.2.3 Constructeurs de copie
3.2.4 Les clones
3.2.5 Passage de paramètres
3.3 Initialisation
3.4 Recyclage de la mémoire
4 L’encapsulation
4.1 Introduction
4.2 Le contrôle d’accès
4.2.1 Contrôle d’accès aux classes au sein d’un package
4.2.2 Contrôle d’accès aux attributs et méthodes
4.3 Les accesseurs
4.4 Les packages
4.4.1 Intérêt des packages
4.4.2 Usage des packages
4.4.3 classpath
5 L’héritage
5.1 Introduction
5.1.1 L’instruction super()
5.1.2 Le mot-clé super
5.2 L’abstraction
5.2.1 Les méthodes abstraites
5.2.2 La redéfinition
5.2.3 Les classes abstraites
5.3 La classe Object
5.3.1 Les méthodes de la classe Object
5.4 Le polymorphisme
5.4.1 Conversion de type de base
5.4.2 Conversion de type entre classes
5.5 Les aléas du polymorphisme
5.5.1 Attention aux signatures
5.5.2 Attention au type de retour
5.6 Le mot clé final
5.7 L’héritage multiple
5.8 Les interfaces
5.9 Héritage et composition
6 Les exceptions
6.1 Introduction
6.2 Les classes d’exception
6.3 Usage des exceptions
7 Les interfaces graphiques
7.1 Le modèle MVC
7.2 La gestion des événements
7.3 Démarrer avec Swing
8 Les Threads
8.1 La classe Thread
8.1.1 Méthodes de la classe Thread
8.2 Création et Exécution
8.3 Relations entre threads
8.4 Synchronisation
8.4.1 Relation d’exclusion mutuelle : moniteurs
8.4.2 Communication à l’intérieur d’un bloc de synchronisation
9 JAVADOC
10 La réflexivité
11 Quelques exemples de code utile
11.1 Écriture dans un fichier
11.2 Sérialisation
11.3 Lecture du contenu d’une URL sur internet
A L’infra-structure de JAVA (Th. Bommart)
A.1 La machine virtuelle JAVA
A.1.1 Définition et rôle
A.1.2 Les bytecodes JAVA
A.1.3 Les pièces virtuelles
A.1.4 Les peu, mais preux et valeureux registres
A.1.5 La zone des méthodes et le compteur de programme
A.1.6 La pile JAVA et les registres associés
A.1.7 La zone du « tas », « garbage collectée »
A.2 Le « style de vie » fichier .class
A.2.1 Né pour voyager
A.2.2 Qu’y a-t-il dans un fichier .class ?
A.2.3 Nombre magique et numéros de versions
A.2.4 La zone des constantes
A.2.5 Drapeaux d’accès
A.2.6 La partie « this_class »
A.2.7 La partie « super_class »
A.2.8 Interfaces
A.2.9 Les attributs
A.2.10 Les méthodes
A.2.11 Les propriétés
A.3 La zone du tas recyclable (garbage-collected heap) de la machine virtuelle JAVA
A.3.1 Introduction
A.3.2 Pourquoi recycler la mémoire ?
A.4 Algorithmes de recyclage
A.4.1 Recycleurs basés sur le comptage des références
A.4.2 Recycleurs basés sur le traçage des objets
A.4.3 Recycleurs compacteurs
A.4.4 Recycleurs copieurs
B Liens

Introduction

Vocation de ce document
L’objectif principal de ce cours est la présentation des concepts essentiels de la programmation orientée objets. Dans ce cadre, le langage JAVA ne constitue qu’un support illustratif spécifique, que nous avons choisi en fonction de notre objectif pédagogique plutôt qu’en fonction de considérations industrielles, qui nous auraient plutôt poussées vers C++. En conséquence, nous avons mis l’accent sur la programmation orientée objets plutôt que sur le langage JAVA lui-même.
Par ailleurs, nous sommes partis du principe que vous connaissez déjà le langage C. Nous ne présenterons pas les aspects de JAVA qui sont hérités du C : les types de base, la syntaxe fonctionnelle, les instructions générales (branchements, boucles, …), la notion de bloc, etc.
Pour présenter un langage informatique et, en particulier, un langage orienté objets, la principale difficulté tient au fait que de nombreux aspects sont interdépendants, si bien qu’il est difficile de présenter certaines notions sans faire appel à d’autre notions qui n’ont pas encore été présentées. Le néophyte se trouve alors contraint d’accepter que soient différées certaines explications qui seraient pourtant nécessaires à la com-préhension de ce qui lui est présenté.

De la programmation structurée à la programmation orientée objets

D’une façon très générale, programmer consiste à écrire une séquence d’instructions de telle façon qu’un ordinateur produise une sortie appropriée pour une certaine entrée.
Même si, en pratique, le programme qu’exécute un ordinateur se ramène toujours à une longue séquence d’instructions, cette longue séquence n’est pas la représentation la plus appropriée pour concevoir, écrire et comprendre un programme dès lors qu’il devient complexe.
Pour remédier à cet état de fait, dés les balbutiements de l’informatique, les informaticiens ont intégré dans leurs langages des variables, des boucles et des tests qui permettent de structurer les programmes qu’ils écrivent.

Des objets et des classes

Introduction
Lorsqu’on écrit un programme informatique, c’est pour résoudre un certain problème. Le programme s’exprime sous la forme d’un certain nombre de procédures à appliquer à des données, tandis que le problème s’exprime sous la forme d’un ensemble de traitements à appliquer à des objets.
Selon cette perspective, concevoir un programme dans un langage procédural classique, c’est effectuer la conception dans la langage de la solution, tandis que la programmation orientée objets permet de l’effectuer dans le langage du problème.
Tous les informaticiens expérimentés s’accordent à dire que la programmation dans un langage procédural est plus simple et s’apprend plus vite que la programmation orientée objets.

Les classes

Nature des classes
Les programmes écrits dans un langage orienté objets manipulent explicitement des objets. Chaque objet manipulé est le représentant d’une classe. Une classe désigne donc un type générique dont les objets sont des instances.
Le fait que des objets soient des instances d’une même classe signifie donc qu’ils ont quelque chose en commun. Ils partagent en général une certaine structure et des traitements qu’on peut leur appliquer, ce qui n’empêche pas qu’ils soient tous différents les uns des autres.
Par exemple, toutes les voitures sont des objets qui ont quatre roues, un volant, un moteur et une carrosserie. Toutes les voitures peuvent être mises en marche, stoppées, conduites, lavées, repeintes, etc.

Éléments de syntaxe
La syntaxe de JAVA est héritée de celle du C++, qui repose elle-même sur celle du C. Donc l’ensemble des notations qui ne sont pas spécifiques des classes, attributs et méthodes sont les mêmes qu’en C.
En ce qui concerne les classes, elles sont repérées par le mot-clé class suivi d’un nom de classe, puis d’un bloc entouré d’une accolade ouvrante et d’une accolade fermante. Au contraire du C++, ce bloc n’est pas suivi d’un po intvirgule final. À titre d’exemple, voici le squelette de la classe Voiture que nous avons décrit plus haut.

Conventions de notation
Comme en programmation procédurale classique, il est important en programmation orientée objets d’employer des noms significatifs. Cela est vrai aussi bien pour les classes, les attributs et les méthodes que pour les variables.
La programmation orientée objets faisant souvent appel à des classes et des méthodes qui ont un sens concret, le nom est généralement suffisant pour comprendre ce que fait une méthode, sans aller voir le détail du code.
Les noms de classes commencent généralement par une majuscule, ceux des attributs, des variables et des méthodes par une minuscule.

Un exemple commenté
Le code suivant représente un exemple de classe CompteEnBanque. Les mots-clés package, import, public et protected ainsi que l’usage des commen-taires seront présentés plus loin.
La classe CompteEnBanque est dotée d’un constructeur qui met le solde à 0 et des accesseurs pour lire et modifier le solde. On voit dans le constructeur un exemple d’appel de méthode au sein d’une autre méthode.

Les attributs
Les attributs servent à représenter diverses relations.
• Ils peuvent représenter des caractéristiques ou qualités d ’un objet. Dans le cas d’un objet concret comme une voiture, sa couleur, sa masse, sa cylindrée sont représentées par des attributs.
• Ils peuvent aussi représenter des composants d’un objet complexe. Le moteur, les roues, la boîte de vitesse d’une voiture sont aussi représentés par des attributs.
• Ils peuvent enfin représenter d’autres objets qui sont en relation externe avec..

Les méthodes
Signature et surcharge
Les traitements associés à une classe sont appelées ses méthodes. Dans la mesure du possible, il faut s’efforcer d’associer à une classe des méthodes qui correspondent à des traitements qui sont naturels pour les objets de cette classe. Cela permet de réutiliser la classe dans un autre contexte que le programme pour lequel elle a été développée.
Il existe un certain nombre de méthodes particulières, que nous présenterons dans la suite.

Des fonctions aux méthodes
Alors qu’en surface on pourrait confondre les fonctions et les méthodes, le mode d’usage d’une méthode est sensiblement différent de celui d’une fonction.
Une fonction est un traitement rattaché à l’arborescence du programme auquel on passe en paramètres les structures auquel il s’applique. Une méthode, au contraire, est attachée à une classe et s’applique à un objet de cette classe sans qu’il soit nécessaire de passer celui-ci en paramètres. L’objet auquel une méthode s’applique est une sorte de contexte implicite qui n’est signalé que par le fait que l’on agit directement sur les attributs de cet objet particulier.

Les membres statiques
Les attributs statiques
Il existe une copie de chaque attribut dans chaque instance d’une classe donnée, c’est-à-dire chaque objet engendré à partir de cette  classe. Ainsi, l’attribut peut avoir une valeur différente pour chacun des objets de la classe.
Dans le cas des attributs statiques, au contraire, il n’existe qu’une seule copie de l’attribut pour tous les objets de la classe : l’attribut est rattaché à la classe elle-même et non à ses instances. Par conséquent, tous les objets partagent la même valeur pour l’attribut et si un seul objet modifie cette valeur, elle sera modifiée pour tous.
Un usage classique est donné par les constantes.

……