# Programmation Java/Machine virtuelle

* Introduction
* La notion de machine virtuelle
* Installation
** NetBeans
** Eclipse
** Visual Studio Code
* Bases du langage
** Premier programme
** Commentaires
** Types de base
** Opérateurs
** Conditions
** Bloc de portée
** Itérations
** Tableaux
* Les classes en Java
** Membres
** Modificateurs d'accès
** Héritage
** Encapsulation
** Polymorphisme
** Classes abstraites
** Interfaces
** Classes internes
** Transtypage
** Types génériques
** Instanciation et cycle de vie
** « this »
** Objets comparables et clés
** Énumérations
** Exceptions
** Packages
* Classes de base
** Collections
** Nombre de taille arbitraire
** Tags Javadoc
** Annotations
** Entrées sorties
** Threads et synchronisation
** Méthodes natives
** Réflexion
** Regex
** JUnit
* Conclusion
* Exemples en Java
** Générer un carré magique
** Générer un triangle de Sierpiński
** XML
** Swing
*** Un premier exemple
*** Formulaire avec boutons sur image
*** Calcul de somme
*** Calcul de distance
* Annexes
** Les outils de base fournis avec le Java Development Kit
** Créer une archive Java
** Paramétrer la JVM
** Liste des mots réservés
** Débogage
** Java et les autres langages
* Introduction
* La notion de machine virtuelle
* Installation
** NetBeans
** Eclipse
** Visual Studio Code
* Bases du langage
** Premier programme
** Commentaires
** Types de base
** Opérateurs
** Conditions
** Bloc de portée
** Itérations
** Tableaux
* Les classes en Java
** Membres
** Modificateurs d'accès
** Héritage
** Encapsulation
** Polymorphisme
** Classes abstraites
** Interfaces
** Classes internes
** Transtypage
** Types génériques
** Instanciation et cycle de vie
** « this »
** Objets comparables et clés
** Énumérations
** Exceptions
** Packages
* Classes de base
** Collections
** Nombre de taille arbitraire
** Tags Javadoc
** Annotations
** Entrées sorties
** Threads et synchronisation
** Méthodes natives
** Réflexion
** Regex
** JUnit
* Conclusion
* Exemples en Java
** Générer un carré magique
** Générer un triangle de Sierpiński
** XML
** Swing
*** Un premier exemple
*** Formulaire avec boutons sur image
*** Calcul de somme
*** Calcul de distance
* Annexes
** Les outils de base fournis avec le Java Development Kit
** Créer une archive Java
** Paramétrer la JVM
** Liste des mots réservés
** Débogage
** Java et les autres langages
[ Modifier le sommaire ]

## Introduction à la machine virtuelle Java

Le langage Java utilise une notion extrêmement importante en informatique : la notion de machine virtuelle. Cette machine virtuelle est composée de trois parties, et est souvent fournie avec l'OS, ou facilement installable comme un logiciel normal.
Sur les ordinateurs, la même machine virtuelle est capable de lancer :
* des applications indépendantes (standalone en anglais), lancées et fonctionnant comme toute application installée sur la machine ;
* des applets, à partir d'une page HTML (internet, réseau local ou en local sur la machine). Pour cela, il faut que le navigateur possède une extension permettant d'utiliser une machine virtuelle Java pour l'exécution de ces applets.

### Environnement d'exécution

Le langage Java est un langage orienté objet qui doit être compilé. Cependant, le compilateur Java ne produit pas directement un fichier exécutable, mais du code intermédiaire sous la forme d'un ou plusieurs fichiers dont l'extension est .class ; ce code intermédiaire est appelé bytecode. Pour exécuter le programme, il faut utiliser la machine virtuelle Java qui va interpréter le code intermédiaire en vue de l'exécution du programme.
Il ne s'agit pas d'une compilation normale, car le compilateur ne produit pas du code compréhensible directement par le microprocesseur, ni d'un langage interprété, car il y a tout de même la notion de compilation, mais une situation intermédiaire entre un langage interprété et un langage complètement compilé.
En d'autres termes, un programme Java, une fois compilé en code intermédiaire, n'est compréhensible que par la machine virtuelle, qui va traduire à la volée (interprétation) les instructions exécutées en code compréhensible par la machine physique.
Depuis Java SE 1.3, les machines virtuelles d'Oracle contiennent un interpréteur capable d'optimiser le code appelé HotSpot.
L'interpréteur effectue plusieurs tâches :
* vérification du code intermédiaire ;
* traduction en code natif (spécifique à la plateforme, au système d'exploitation) ;
* optimisation.
Outre un interpréteur, l'environnement d'exécution fournit également :
* un noyau multitâches pour les machines virtuelles fonctionnant sur des systèmes monotâches (green virtual machines) ;
* un « bac à sable » (sandbox) pour l'exécution de processus distants.

### Chargeur de classe

Le chargeur de classe charge les classes nécessaires à l'exécution, alloue l'espace mémoire nécessaire et établit les liens entre elles (linkage). Le chargeur de classe connait la structure d'un fichier .class.

### Gestionnaire de mémoire

Le gestionnaire mémoire assure les services liés à la mémoire, en particulier :
* un ramasse-miette (garbage collector) ;
* une protection mémoire même sur les machines dépourvues d'unité de gestion mémoire (MMU).

## Avantage de l'utilisation de la machine virtuelle

L'utilisation d'une machine virtuelle a l'énorme avantage de garantir une vraie portabilité. Il existe des machines virtuelles Java pour de très nombreux environnements : Windows, MacOS, Linux et autres.
Ces machines virtuelles sont capables d'exécuter exactement le même code intermédiaire (les mêmes fichiers Java en bytecode) avec une totale compatibilité. C'est là une situation unique et assez remarquable qui a fait le succès de ce langage.
La machine virtuelle Java n'est pas uniquement développée sur des ordinateurs classiques, une multitude d'appareils disposent d'une machine virtuelle Java : téléphones portables, assistants personnels (PDA)…

## Les interfaces de programmation (API) Java : des fonctionnalités énormes

La machine virtuelle Java possède un ensemble de bibliothèques extrêmement complètes : des bibliothèques graphiques, des bibliothèques systèmes, etc.
Toutes ces bibliothèques sont totalement portables d'un environnement à un autre.
La machine virtuelle Java offre donc un véritable système d'exploitation virtuel, qui fonctionne au-dessus du système d'exploitation, de la machine cible et le masque totalement aux applications.

## La lenteur de Java

Le gros point faible du concept de machine virtuelle est que le code intermédiaire (bytecode) est interprété par la machine virtuelle. Ceci entraîne une baisse importante des performances des programmes.
Toutefois, avec les machines virtuelles actuelles, cet argument n'a plus autant de poids. La technique appelée « compilation juste à temps » (JIT : Just-In-Time) est employée par la machine virtuelle quand une méthode est appelée. Cette technique consiste à compiler à la volée la méthode appelée (la première fois) en code natif directement exécutable par le processeur.
Toute méthode s'exécute ainsi aussi rapidement que du code natif.

## Autres langages

D'autres langages de programmation permettent de produire du bytecode Java exécutable avec la JVM :
* Jython compile du code source Python en bytecode Java ;
* Scala (de l'anglais Scalable language, « langage adaptable ») est un langage de programmation multi-paradigme exprimant les modèles de programmation courants dans une forme concise et élégante, compilant le code source en bytecode Java ;
Plus de détails : Développer en Java/Langages dérivés

## Processeur Java

Un processeur Java est l'implémentation matérielle d'une machine virtuelle Java. C'est à dire que les bytecodes constituent son jeu d'instruction.
Actuellement, il y a quelques processeurs Java disponibles :
* en:picoJava, première tentative de construction d'un processeur par Sun Microsystems ;
* aJ100 de aJile. Disponibles sur cartes Systronix ;
* Cjip (Imsys Technologies) ;
* Komodo : micro-controlleur Java multi-thread pour la recherche sur la planification temps-réel ;
* FemtoJava : projet de recherche ;
* ARM926EJ-S : processeur ARM pouvant exécuter du bytecode Java.