Programmation Java Version.1.10

Introduction

Introduction à Java Généralités

• Java est un véritable langage de programmation !

  • Syntaxe proche de C++, orienté objet, d’une utilisation simple, implémentant un maximum de
    sécurité, il permet d’exécuter des programmes au
    travers
    d’une machine
    virtuelle.
    • Il est fourni avec un ensemble de “packages” : les
    classes de base du JDK (Java Developper’s Toolkit)
  • Sans ces classes de base, Java n’est rien. Elles
    fournissent les fonctionnalités de base (entrées/
    sorties, réseau, etc…). Le langage lui-même se
    trouve dans le package (ensemble de classes) java.lang
    !
    • Java et l’internet
  • Du fait de son fonctionnement au travers d’une machine virtuelle, Java est un langage “qui
    voyage”.

Introduction à Java Caractéristiques de base

• Java est un langage

  1. simple,
  2. orienté objet,
  3. distribué,
  4. interprété,
  5. robuste,
  6. sûr,
  7. indépendant de l’architecture (portable),
  8. mobile,
  9. performant (pas pour toutes les applications,
    mais ça va venir…)
  10. multithreadé,
  11. dynamique,
  12. exécuté non pas au travers d’un interpréteur,
    mais au travers de l’émulation d’une machine virtuelle, ou d’un puce
    JavaOS
  13. possédant une riche API : le JDK
  14. véritable explosion depuis son lancement : nombreux produits commerciaux : IDEs, APIs
    spécialisées,
    etc…

Introduction à Java
Simplicité (apparente ?)

• Basé sur C/C++, mais…

  • pas de pointeurs,
  • pas de structures ni de macros (struct, typedef et

#defines),

pas de gestion de la mémoire laissée au programmeur
(malloc() et free() sont morts, paix à
leurs âmes…)
Java offre toute la fonctionnalité d’un langage de programmation puissant, mais débarrassé des
caractéristiques prêtant à
confusion.
Sa syntaxe est proche de celle de C/C++ mais
(fort
heureusement !) a été adaptée pour en permettre
une
approche plus rapide et surtout en gommer
certains
aspects critiqués ou provocant de nombreuses
erreurs
de
programmation.
L’expérience prouve que Java est un langage simple
à
prendre en main, mais en aucun cas limité. La
révision
1.1 propose même des technologies objets très
avancées comme les RMIs (Remote Method
Invocations).
En revanche, comme tous les langages objets, il
faut
une certaine expérience avant de tirer parti au
mieux
de ses possibilités, et surtout de son API très
riche.

• N’a-t-on rien perdu par rapport au C/C++ ?
Non, les suppressions évoqués précédemment réduisent de moitié les erreurs les plus fréquentes du C
et
du
C++.
En outre, la suppression des macros, si elle peut
sembler une hérésie, augmente de beaucoup la
lisibilité
des programmes.
L’héritage multiple au sens courant a disparu, mais
existe sous une forme différente grâce au concept
d’”interfaces”.
• Java est-t-il un beau langage ?
La notion de “beau” est subjective, mais oui, Java est
un langage extrêmement agréable à programmer et
permet dans certains cas de développer des applications beaucoup plus rapidement qu’avec d’autres
langages.
• Java est peu gourmand en mémoire

  • La machine virtuelle n’a besoin que de 215k pour
    s’exécuter.
  • Java dans une montre à quartz ? Oui, c’est possi-
    ble !

Introduction à Java Orienté objet, distribué

• Orienté objet
Java reprend la technologie objet du C++ et y ajoute
quelques améliorations. Il y enlève aussi un gros morceau (l’héritage multiple, la généricité et d’autres
encore…) mais sans vraiment y perdre. Nous y
reviendrons…
Contrairement à C++, Java est complètement objet,
ne demeurent que quelques types primitifs (int, char)
hérités du C possèdant des “wrapper
classes”.!
• Distribué au travers des classes du JDK
Java lui-même n’est pas distribué. En revanche, il est
fourni avec un ensemble de classes qui intègrent une
gestion plus ou moins transparente du réseau.
Par exemple, il est possible, en quelques lignes de code, de récupérer un fichier au travers du
protocole
HTTP ou FTP, de programmer un serveur de
socket
pouvant accepter des connexions en parallèle,
etc…
Ce genre de programmation est aujourd’hui un
des
gros attraits de
Java.

Introduction à Java Robuste

• Nombreuses vérifications à la compilation et à
l’exécution
Lors de la phase de compilation, Java s’assure qu’il n’y
a aucun problème, que toutes les erreurs pouvant empêcher l’exécution du programme ont bien été
traitées
(ouverture d’un fichier inexistant ou accès mémoire
en
dehors des bornes d’un tableau par
exemple).
Cette vérification permet d’éviter qu’un problème grave ne corrompe la machine virtuelle ou le système
qui
l’exécute. N’oubliez pas que les programmes
Java
“voyagent” d’une machine à l’autre ! Vous ne
voudriez
pas qu’un programme arrive dans votre
navigateur
Web et plante votre machine
!
• Java fournit au travers de la machine virtuelle et du
langage

  • vérification de pointeur nul,
  • vérification des bornes des tableaux,
  • traitement très puissant des exceptions,
  • vérification du byte code (pas de virus, très difficile
    de “cracker” des programmes compilés, etc…).
  • hmmm… mais désassemblage assez facile avec la
    release 1.0 du JDK !

Introduction à Java Indépendant de l’architecture

• Indépendance au niveau des sources (JDK) et du
Byte Code (machine virtuelle)
Le compilateur Java du JDK ne fournit pas directement
du code machine exécutable, il produit un code portable, du byte-code, interprétable par la machine
virtuelle.
Ce byte-code est indépendant de l’architecture. Chaque machine possédant une machine virtuelle
peut
l’exécuter. Actuellement Java peut être exécuté
sous
presque tous les Unix du marché, sous Windows
3.1/
95/NT, sous MacOS, dans des Net Computers
(NC)
ou des systèmes embarqués possédant une puce
JavaOS (téléphones portables, télévisions,
etc…).
• Compilation directe possible (traduction C++ puis
compilation aujourd’hui), mais adieu la transportabilité du code
!
• Performances quand même excellentes depuis
l’arrivée des JITs (Just In Time compilers…)

  • Compilation lors de la phase d’interprétation, compilation “au

vol”.

On approche la vitesse du C/C++ optimisé, mais on y est pas encore.

Introduction à Java Sûr : le vérificateur de byte-code

• Contrôle de tout code chargé avant instanciation
pour exécution
Le code Java est testé plusieurs fois avant d’être exécuté sur votre
machine.
Le code passe par un vérificateur de byte-code. Celuici teste le format des fragments de code et applique
un
algorithme qui détermine leur légalité. Un code légal
ne modifie pas les pointeurs, ne viole pas les droits
d’accès aux objets et ne tente pas d’altérer les objets
ou les classes.
Une application indépendante peut se permettre plus
de choses qu’une application s’exécutant dans un navigateur Web (applet). Le class loader et le
security
manager sont différents dans les deux
cas.
• Vérificateur de byte-code

  • Le code ne cause aucun dépassement de capacité
    positif ou négatif de la pile opérande,
  • les types de paramètres de tous les codes opération sont

corrects,

aucune conversion illégale de données (entiers en
pointeurs, etc…),

  • les accès aux objets sont légaux (publics, privés,
    protégés… nous y reviendrons !)

Introduction à Java Sûr : le Class Loader

• Les classes sont chargées dans un NameSpace indépendant et identifié en fonction de l’origine du code chargé
Les classes sont, comme nous le verrons plus tard, le
code de base servant à la construction par instanciation des objets utilisés par une application.
Elles peuvent être chargées par le réseau (applets et
classes développées par l’utilisateur) ou encore locales, liées à la machine virtuelle en cours
d’utilisation.
Le Class Loader participe donc à la sécurisation de
Java en séparant les espaces-noms pour les classes
locales et les classes provenant du réseau. Cela limite
les possibilités de voir un virus ou une application
“cheval de troie” envahir votre machine sans prévenir!
Lorsqu’on a besoin d’une classe donnée, la recherche
est effectuée en priorité parmi les classes locales. De
cette manière, aucune classe importée ne peut se faire
passer pour une classe système, même si elle en
usurpe le nom.
Quoique…

Introduction à Java Le code Java est mobile

• Java intègre, au travers de son JDK, une interface
commune permettant une compatibilité source totale entre les
architectures
De par son indépendance vis-à-vis de l’architecture,
Java est par essence mobile. Il intègre cependant
d’autres standards de mobilité afin de faciliter le développement d’applications
portables.
Par exemple, la longueur des types de base est toujours identique quelle que soit l’architecture
utilisée,
les codes des caractères sont partout les mêmes,
le
codage des mots de 16 ou 32 bits est le même
(adieux
big et little endian !),
etc…
De même, la librairie graphique, l’AWT (Abstract Window Toolkit) permet de développer des interfaces
graphiques sans se préoccuper du système
d’exploitation
qui sera
utilisé.

Introduction à Java Java est interprété

• La compilation produit du byte-code non lié à une
plate-forme
• Celui-ci est interprété par une machine virtuelle
• Pas de phase d’édition de liens avec des librairies
existantes, c’est un garant de la portabilité du langage.
• Excellentes performances depuis peu

  • Attention, le JDK proposé gratuitement par Sun est
    le plus lent du marché! Tout est écrit en Java (compilateur, machine virtuelle,

etc…).

Des produits infiniment plus performants, mais

commerciaux sont disponibles chez différents développeurs.

Par exemple : compilation de 2 millions de lignes/
seconde sur Pentium 133 avec Symantec Café.

  • L’interpréteur est remplacé par un Just In Time
    Compiler (Solaris, nombreuses versions sous Windows 95/NT par Symantec, Microsoft,
    Borland,
    Netscape). 300.000 appels de
    méthodes/procédu-
    res par seconde sur un Sun Sparc 10 avec le JIT
    de Sun. Presque identique à du C/C++ natif équivalent.

Introduction à Java Java est multithreadé

• Un Thread est une partie de code, un “flot d’instructions” s’exécutant en concurrence
avec
d’autres Threads dans un même
processus
L’utilisation du multithreading permet à un seul programme d’effectuer plusieurs activités
simultanément.
Les threads, parfois appelés “processus légers” per-
mettent de développer des programmes multitâches
de manière plus simple et performante qu’avec la programmation système classique (fork() et
exec()…),
dont le code est par ailleurs difficilement
portable.
Les Threads faisant partie intégrante du langage Java
(jusque dans certains de ses mots-clé), ils sont plus faciles à utiliser que leurs équivalents
C/C++.
Les avantages principaux du multithread sont des performances plus élevées en matière d’interactivité et
un
meilleur comportement en temps réel, bien que ce
dernier soit en général dépendant du
système.
Java intègre les Threads de manière transparente
(garbage collector, horloge, chargement des images
ou des sons), mais permet également au programmeur de développer ses propres Threads de
façon
très
simple.
Des outils de gestion de ressources critiques (sémaphores, moniteurs temps réels) et de
synchronisation
sont également disponibles, et leur utilisation est
d’une
grande
simplicité.

Introduction à Java Java est multithreadé

• Sous Java les Threads

  • ne sont pas toujours natifs,
  • sont intégrés par la machine virtuelle : garbage collector,

horloge…,

sont mis à la disposition de l’utilisateur au travers
de classes et d’interfaces du JDK : Thread, Frame,
Runnable, etc…

Introduction à Java Java est dynamique

• Un programme est constitué de plusieurs classes
• Lorsqu’une classe inconnue dans le programme
est requise, on la recherche :

  1. localement (dans le JDK local au navigateur web
    ou à la machine virtuelle) et ensuite si elle n’est
    pas trouvée…
  2. à l’endroit d’où le programme a été chargé
    Java tire au maximum parti de la technologie objet, la
    machine virtuelle n’essaie pas de connecter tous les
    modules composant une application avant l’exécution
    (pas d’éditions de liens).
    Les classes de définition des objets sont chargées simultanément mais indépendamment, en fonction
    de
    leur besoin dans l’application. Si une application
    nécessite une classe non présente sur la machine
    qui
    l’exécute, Java ira la chercher à l’endroit d’où
    l’application
    provient.

Applications indépendante et applets Objectifs de ce chapitre

• Connaître les différences entre applet et application
indépendante
• Savoir compiler du code Java et l’exécuter
• Apprendre à configurer un environnement de développement
Java

Applications indépendante et applets application indépendante

• Comme n’importe quel autre langage, un code
Java dispose pour son exécution d’un point d’entrée.
• A la différence d’autres langages ce point d’entrée
possède deux composantes :

  1. La machine virtuelle
  2. Une méthode :
    public static void main(String argv[])
    … c’est le cas des applications indépendantes. C’est
    en codant cette méthode que l’on a la possibilité d’indiquer le point de départ de toute application
    Java.
    C’est le “programme principal” pour reprendre une
    ancienne terminologie plus tellement
    adaptée…
  3. Remarque : en fait chaque classe peut avoir une
    méthode main(), mais celle qui sera exécutée sera
    celle de la classe passée en paramètre à la machine
    virtuelle (la classe maître). Très utile pour debugger
    les classes indépendamment : le main contient une série de tests de validation de la
    classe.

Applications indépendante et applets Applets

• Les applets ne sont pas des applications indépendantes, elles ne possèdent pas forcément de
méthode
main().
• Les applets doivent être exécutées au travers d’un
browser (Netscape, Internet Explorer…).
• Il y a plusieurs points d’entrée d’exécution dans
une applet, et la méthode main() n’en fait pas partie
!
• En réalité, le browser contient en interne :

  1. la machine virtuelle,
  2. sa propre méthode
    public static void main(String argv[])
    Une applet est une application Java très particulière
    car elle s’exécute dans un browser. Ce dernier doit
    donc pouvoir comprendre Java mais aussi effectuer un
    certain nombre de contrôles sur le code qu’il va exécuter. Ce dernier point justifie (entre autre) le besoin
    de
    ne pas mettre en contact direct la machine
    virtuelle
    avec un code qui la contrôlerait. Le Browser fait
    donc
    tourner une application indépendante qui se
    charge
    d’exécuter des applets après avoir fait les
    vérifications
    nécessaires.

Applications indépendante et applets Applets

• Mais alors, où commence l’exécution de mon applet
?
Il a été défini une liste de méthodes qui sont utilisées
comme différents points d’entrées, en fonction du cycle de vie de l’applet
:
init(), start(), stop(),
destroy()…
• Pourquoi plusieurs points d’entrée ? Qu’est-ce
que le cycle de vie d’une Applet ?
Une Applet est un programme qui s’exécute dans un
browser, son utilisation dépend du bon vouloir de l’utilisateur du browser. Ce dernier peut revenir sur
une
page et masquer momentanément la page
contenant
l’applet. Dans ce cas, il faut arrêter les threads qui
tournent, stopper les animations, le son, etc… Si
l’utilisateur revient dans la page, il faut relancer les threads
arrêtés, d’où les
méthodes
stop() et start().
Nous verrons le détail de ces méthodes et du cycle de
vie des applets dans le chapitre qui leur est consacré.

Applications indépendante et applets Résumé

• Une application indépendante Java

  • …possède un point d’entrée unique, la méthode
    main(), de prototype :
    public static void main(String argv[])
  • …est exécutée directement par la machine virtuelle
    Java.
    • Une applet Java
  • …est exécutée par un browser,
  • …ne dispose pas de point d’entrée main(),
  • … dispose de points d’entrée appelés sous le contrôle de l’application indépendante embarquée
    par
    le
    browser.

Créer une application Java Les bases à connaître

• L’entité de base de tout code Java est la classe
• Tout fichier source doit contenir une seule classe
publique
• Tout fichier source doit porter le nom de la classe
publique qu’il contient, suivi du suffixe .java
• Une classe peut contenir uniquement des données
(attributs) et/ou des méthodes
• Une méthode peut contenir uniquement des données et/ou du
code.
public class HelloWorld {
// déclaration de données globales
int donneeGlobale;
// méthodes
public static void main(String argv[]) {
int donnee_locale;
System.out.println(“Hello world”);
}
}
Fichier HelloWorld.java

Créer une application Java Les bases à connaître

En Java, tout se trouve dans une classe. Il ne peut y
avoir de déclarations ou de code en dehors du corps
d’une classe.
La classe elle-même ne contient pas directement du
code. Une classe contient des déclarations de variables globales, que l’on appelle des “attributs”, et
des
méthodes (équivalents des
fonctions).
Les “attributs” sont visibles par toutes les méthodes de
la classe qui peuvent les utiliser. Ces attributs seront
“possédés” par chaque objet instance de la classe.
Le code se trouve exclusivement dans le corps des
méthodes, mais ces dernières peuvent aussi contenir
des déclarations de variables locales (visibles uniquement dans le corps de la
méthode).
Pour que votre code soit réutilisable, pour augmenter
sa lisibilité et sa localisation et pour faciliter la compilation et le chargement “au vol” des classes, il ne peut
y
avoir qu’une seule classe publique par fichier
source.
En effet, une application étant composée d’un ensemble de classes, nous avons vu que ces dernières
sont
chargées par la machine virtuelle lorsqu’on en a
besoin. Pour pouvoir retrouver rapidement les classes
à
charger, il est indispensable de retrouver le nom du
fichier à partir du nom de la
classe.

L’environnement de développement Java Variables d’environnement

• Trois variables d’environnement sont très importantes

  1. CLASSPATH : chemin de recherche des classes
    de base.
  2. JAVA_HOME : répertoire de base de l’installation
    du JDK
  3. PATH : doit contenir le répertoire contenant le
    compilateur java (javac), la machine virtuelle (java), le debugger (jdb), etc… En
    général
    $JAVA_HOME/bin
    • Ces variables sont souvent positionnées automatiquement lors de l’installation d’une IDE
    (symantec
    café, etc…), qui inclue le
    JDK.
    • Sous Unix, les positionner !
    • Les browsers incluant leur propre machine virtuelle
    et leurs propres classes repositionnent le CLASSPATH. Si l’installation est bien réalisée, ceci est
    fait
    de manière
    transparente.

L’environnement de développement Java Compilation

• Compilation à l’aide du JDK. Attention, avec une
IDE, se référer à la documentation spécifique, la
procédure est certainement différente.

  • Dans une fenêtre de commande (shell Unix ou fenêtre MS/DOS)
    :
    javac HelloWorld.java
    Si la compilation s’est bien passée, on devrait obtenir un
    fichier :
    HelloWorld.class
    • Sinon… erreurs de compilation !
    Le compilateur indique précisément la ligne à laquelle
    l’erreur s’est produite. Le message est en général explicite
    :
    HelloWorld.java:9 Method printl(java.lang.String) not found
    in class java.io.PrintStream.
    System.out.printl(“Hello World”);
    Nous avons ici les informations suivantes :
  1. Erreur à la ligne 9,
  2. L’erreur a eu lieu dans l’appel de System.out.printl(…)
    3.
    Visiblement, la méthode printl() n’existe pas.
    En effet la bonne méthode s’appelle println().

L’environnement de développement Java Compilation

• Exécution du code avec le JDK (IDEs voir la documentation
spécifique)

  • Dans une fenêtre de commande (shell Unix ou fenêtre MS/DOS)
    :
    java HelloWorld
    • Attention au CLASSPATH si l’erreur est du style :
    Can’t find class HelloWorld
    ou bien…
    Can’t find class HelloWorld.class
    Cette erreur signifie que la machine virtuelle n’a pas pu
    trouver la classe HelloWorld.class dont elle avait
    besoin pour exécuter l’application.
    L’erreur classique est que la variable CLASSPATH n’inclut pas le répertoire courant dans le chemin de
    recherche des
    classes.
    Une autre possibilité est que vous avez essayé
    d’exécuter un code qui n’a pu être compilé correctement
    (aucun
    fichier .class
    généré)

L’environnement de développement Java Premier exercice

• Créez l’application HelloWorld !

  1. Editez le fichier source HelloWorld.java à
    l’aide d’un éditeur de texte,
  2. Créez une classe publique HelloWorld contenant une
    méthode
    main() affichant le texte “Hello
    world!”,
  3. Compilez le fichier source. En cas de problème vérifiez que votre environnement est bien
    initialisé,
    4.
    Exécutez l’application,
  4. Modifiez légèrement l’application en introduisant
    par exemple des erreurs, et recommencez les étapes 1 à
    4,
    6.
    Bon, il est temps d’apprendre les différents éléments de base du langage Java, sa syntaxe,
    etc…
    de manière à développer des application plus
    évoluées
    !

Eléments traditionnels du langage Objectifs de ce chapitre

• Connaître l’architecture élémentaire d’un programme Java
• Assimiler la structure lexicale du langage
• Savoir utiliser les types offerts par Java
• Lister les instructions du langage

Eléments traditionnels du langage Introduction

• Java est orienté objet
Java a toutes les caractéristiques d’un langage objet;
il permet de définir des classes comportant des descriptions d’attributs (variables) et d’opérations
(méthodes) utilisables sur des
objets.
Les objets communiquent entre eux et réagissent
aux
événements issus de leur environnement par le biais
de messages.
Le langage est enrichi par un ensemble de classes
fournies en standard avec le JDK. Elles fournissent en
particulier les fonctionnalités réseau, temps réel, entrées/sorties, mathématiques, etc… Ainsi que les
éléments d’interface
graphique.
• Java est fortement typé
Toute donnée manipulée par Java doit être typée. Le
type peut être soit un type de base (int, float, char, boolean…) soit un nom de classe du JDK ou créée par
l’utilisateur.
• Java est déclaratif
Tout objet ou variable doit être déclaré avant d’être
manipulé. La déclaration comporte de manière classique un type et l’identificateur de
donnée.
int nb =
10;

• Java est structuré

  • Structuré en packages (ensembles de classes),
    classes et méthodes.
  • Lors de l’exécution, les instructions de contrôle de
    flot (branchements, boucles…) sont elles mêmes
    structurées (emboîtement possible).
    for (i=0; i < 10; i++) {
    if (i == 5) {
    System.out.println(“milieu!”);
    }
    }
    • Java est… beau !
    Après avoir programmé en C, en C++ ou en bien
    d’autres langages, passer à Java n’est pas très difficile. En revanche le contraire est souvent pénible
    car
    Java est très agréable et permet de développer vite
    et
    simplement des applications
    complexes.

Eléments traditionnels du langage Architecture d’un programme Java

• Programme Java = ensemble de classes pouvant
être regroupées en packages
Java est un langage orienté objet. Le composant de
base d’un programme Java est donc la classe, qui agit
comme modèle permettant de “fabriquer” des objets.
Les classes peuvent être regroupées en modules appelés packages. Les fonctionnalités
spécifiquement
objet de Java seront étudiées dans un autre chapitre.
• Classe = attributs + méthodes
Un classe comporte un ensemble de définitions d’attributs et un ensemble de méthodes que l’on pourra
utiliser sur tous les objets de cette
classe.
• Méthode = unique unité de code
Le code source d’un programme Java doit se situer
uniquement à l’intérieur du corps des méthodes (à l’exception de certains codes statiques, comme nous
le
verrons plus
tard).
• Une classe publique par fichier. Le fichier porte le
nom de la classe suivi du suffixe “.java”
Chaque classe publique, c’est-à-dire destinée à pouvoir être utilisée par les objets d’une autre classe
quelconque, doit être définie dans un fichier .java qui
porte
son
nom.

Eléments traditionnels du langage Architecture d’un programme Java

• Exemple : fichier Point.java
public class Point {
// Les attributs
private int x;
private int y;
// Les méthodes
public void setXY(int px, int py) {
x = px;
y = py;
}
public int getX() {
return x;
}
public int getY() {
return y;
}
}

• Rappels :

  • Une application indépendante Java possède un
    point d’entrée : la méthode main()
    public class MonApplication {

    public static void main(String argv[]) {
    // code de départ de l’application

    }
    }
  • La méthode main() d’une applet java est incluse
    dans le browser, les applets ne possèdent pas de
    point d’entrée main().

Eléments traditionnels du langage Structures lexicales

• Jeu de caractère ASCII classique
Le jeu de caractères utilisé lors de l’écriture d’un source Java est le code ASCII
habituel.
• Identificateurs
int variable;
int autreVariable = 10;
double variableReelle;
short petitEntier;
float le_$prix;
Un identificateur désigne tout objet que le programmeur souhaite manipuler. Il peut s’agir d’une
classe,
d’un objet, d’une variable ou d’une
méthode.
Un identificateur Java commence par une lettre et peut
ensuite contenir d’autres lettres, des chiffres, un caractère souligné (_), ou encore un dollar
($)
• Terminateur d’instructions
int x = 1;
int y = 10;
int somme;
somme = x + y;
Il s’agit du caractère point-virgule, déjà utilisé par le C,
le C++, Modula 2, etc…

• Commentaires d’une seule ligne
// Ceci est un commentaire d’une ligne
int x = 10; // centre du cercle
• Commentaires sur plusieurs lignes
/* Ceci est un long commentaire qui
s’étale sur plusieurs lignes… / Les commentaires s’emploient de la même manière qu’en C++, soit avec // en début de ligne, soit en encadrant le commentaire entre / et
/ Les commentaires peuvent être placés à n’importe quel endroit du source. • Documentation automatique par javadoc /* Cette méthode permet de faire le

  • …traitement suivant … blah blah..
    *…
    */
    Javadoc est un utilitaire très pratique permettant de
    générer automatiquement une documentation au format HTML à partir des commentaires définis
    comme
    ci-dessus.
    Il existe de nombreux mots-clé que l’on peut insérer
    dans le commentaire, pour spécifier l’auteur, le rôle de
    la méthode, etc… on peut insérer du HTML…

Eléments traditionnels du langage Types élémentaires

Table 1: Types élémentaires de Java


Les types Java sont indépendants du compilateur et
de la plate-forme d’exécution. Ils sont intégrés aux
spécifications du langage, ce qui garantit une parfaite
portabilité du byte-code.
Les valeurs numériques entières sont représentées
pas byte, short, int et long, les réelles par float et double.
Un boolean n’est pas considéré comme une valeur numérique. Ses seules valeurs possibles sont true et
false.
Les caractères ne sont plus représentés sur 8 bits
mais sur 16 par l’intermédiaire du code unicode. Ceci
permet de représenter potentiellement tous les alphabets de la planète, en particulier nos alphabets
accentués.

Eléments traditionnels du langage Chaînes de caractères

• En C

  • Calcul des longueurs de chaînes,
  • gestion de la fin de chaîne (caractère de code ASCII

zéro),

pas de vérification de débordements.
• En C++

  • Utilisation de bibliothèques pas toujours portables
    ni standards (bien qu’il existe un simili standard).
    • En Java
  • String et StringBuffer sont deux classes
    fournies avec le JDK permettant un traitement très
    riche des chaînes de caractères.
    String nom = “toto”;
    Pas de marqueur de fin de chaîne, pas de calcul de la
    longueur lors de la création, vérification des débordements, puissants mécanismes de conversion des
    types.
    String permet de représenter des chaînes
    constantes,
    StringBuffer de taille variables.
    Etudiées en détail dans la suite du cours.

Eléments traditionnels du langage Variables et attributs

• Déclaration
int x;
float f;
char a;
• Déclaration avec initialisation
int x = 123; // initialisation
float f = 0.0;
String toto = “toto”;
Tous les objets doivent être déclarés avant d’être utilisés. Syntaxe
:
[ = expression];
L’expression optionnelle permet d’affecter une valeur
lors de l’initialisation.
Table 1: Valeurs par défaut des types de base, pour les attributs d’une classe

Eléments traditionnels du langage Variables

• Initialisation : contrôle du compilateur
int i;
while(i < 10) {
System.out.println(“i vaut “ + i);
i++;
}
La compilation produit le message d’erreur suivant
test.java:6 Variable i may not have
been initialized.
while(i < 10) {
1 error
Le compilateur javac effectue de nombreuses vérifications quant à la qualité du code qu’il
compile.
Il est en particulier capable d’avertir le
programmeur
d’une incohérence
éventuelle.
Ici, une donnée n’est pas initialisée avant son
utilisation. Cette donnée
est
une variable locale à une mé-
thode. Dans ce cas, elle n’est pas initialisée avec des
valeurs par défaut.
Le seul cas d’initialisation automatique avec une valeur par défaut est celui
des
attributs d’une classe (ou
variable de classe).
Dans l’exemple, il aurait fallu mettre :
int i = 0;

• Transmission des variables par valeur

  • Tous les attributs et variables possédant un type
    de base (int, char…) sont transmis par valeur.
  • Dans ce cas, un paramètre de méthode contient directement la valeur qu’on lui assigne. On
    effectue
    une copie de la valeur de la variable transmise.
    On
    ne modifie donc pas
    l’original.
    int valeur =
    10;
    Point p = new
    Point();
    p.move(valeur); // valeur
    non
    //
    modifiable
    • Transmission des variables par référence
  • Toutes les instances d’objets Java sont transmises
    par référence (par adresse).
  • Dans ce cas, la variable représente seulement le
    moyen d’accéder à l’objet et non pas l’objet directement. Elle contient donc l’adresse mémoire
    de
    l’objet. La particularité d’une référence par
    rapport
    à un pointeur est de ne permettre d’accéder qu’à
    la
    donnée qu’elle

pointe.

Ce mode de gestion permet un partage aisé d’ob-
jets au sein d’une application ainsi que l’assurance
d’avoir des performances optimales lors du passage de gros objets en
paramètres.

• Transmission des variables par référence (suite)

  • Java ne permet pas de choisir le mode de passage
    en paramètre des objets, comme en C++ par
    exemple. Mais en imposant une solution unique
    simple et efficace, les concepteurs de Java prétendent garantir l’homogénéité de la
    programmation
    et faciliter la maintenance d’une application. Ca
    se

discute…

Pour résumer, en Java on distingue deux sortes
d’objets

  1. Les objets primitifs (int, char, etc…)
  2. Les objets référencés (tous les autres, attention, ceux de la classe String en font partie
    !)
    • Possibilité de forcer les paramètres en
    constantes : les rendre non modifiables
    public class myClass {
    public methode1(final int x) {
    int y = x + 2;
    x = x + 3;
    }
    }
    Interdit !
    Autorisé

• Blocs et visibilité : structuration
// début du premier bloc
{
int i = 10;

// début du second bloc
{
int i = 0;
int j = 20;

}
// Fin du second bloc
// j n’est plus visible
}
// fin du premier bloc
Produit à la compilation
bloc.java: 7: Variable ‘i’ is already defined in this method
int i = 0;
1 error
• Java n’autorise pas la redéfinition au sein d’un bloc
d’une variable déjà visible. Le compilateur produit
donc une erreur.

  • Amélioration de la lisibilité et diminution des erreurs.
    Pas d’ambiguïté lors de l’utilisation d’une variable.

Eléments traditionnels du langage Tableaux

• En Java les tableaux sont des objets référencés.
Le type tableau est assimilable à une classe

  • Ils gèrent leur taille, on peut y accéder au travers
    de l’attribut length
    int[] t = new int[10];

    int longueur = t.length;
    // longueur vaut maintenant 10
  • Contrôle dynamique des débordements. Un dépassement de capacité produit une
    exception.
    • Déclaration d’un tableau
    int tableau1[];
    int[] tableau2;
    int matrice[][];
    int[] x, y[]; // équivalent à :
    int x[], y[][];
  • En java il n’est pas possible de définir des tableaux
    de taille statique à la déclaration.
  • Un tableau doit être alloué dynamiquement, com-
    me tout objet Java (à l’aide de l’opérateur new)
    int tab[10]; // ne compile pas

• Point controversé
int tab[10]; // ne compile pas
• Pourquoi ne peut-on pas avoir ?
int tab[10];

  • Ce serait bien que ça compile, non ?
    • Ou bien
    int tab[] = new int(10);
    • Les tableaux et la présence de types primitifs tels
    que int, char etc… est un gros point de controverse.
    • Rappel : on ne peut pas faire
    int x = new int(3);
    • Mais on peut faire
    int x = Integer.parseInt(“12”);

• Allocation et initialisation
int tab1[] = new int[10];
int mat[][] = new int[4][5];
int tab2[] = {1,2,3,4}

  • Un tableau n’est pas un type élémentaire. Une variable de type tableau est donc une référence
    sur
    un tableau. pour créer ce tableau nous
    utilisons
    l’opérateur new. C’est une allocation

dynamique.

il faut fournir la taille de la première des dimensions
d’un tableau alloué par new.
int tab[][] = new int[4][];

  • Il est également possible de créer le contenu d’un
    tableau lors de la déclaration en fournissant la liste
    complète de ses éléments.
  • Depuis le JDK1.1, on peut créer le contenu d’un tableau lors de toute affectation (tableaux
    anonymes)
    String voitures = new
    String[]
    {”Renault”,
    ”peugeot”};

• Utilisation
int tab1[] = new int[10];

// utilisations correctes
tab1[0] = 100;
tab1[1] = 200;
// mais ceci n’est pas correct
tab1[10] = 1000;
La compilation produit le message suivant :
java.lang.ArrayIndexOutOfBoundsException: 10 at TabTest.main(TabTest.java:6)

  • En Java les tableaux sont toujours indexés par des
    int et le premier élément commence à l’indice 0.
  • tab[tab.length – 1] est le dernier élément du tableau
  • Si le tableau est alloué avec une taille inférieure à
    zéro ou si on tente d’accéder un élément ne se
    trouvant pas entre le premier et le dernier élément
    compris, une exception est générée.
  • N.B : tab.length est manipulé comme une variable
    • Les chaînes de caractères ne peuvent être manipulées comme des tableaux de caractères (oubliez
    le
    C et le C++
    !)

Eléments traditionnels du langage Expressions

• Opérandes : représentés par des variables ou des
littéraux
int i = 2;
int resultat = 3 * i;
• Opérateurs

  • Java impose une parfaite identité de types des opérandes d’un opérateur binaire. Contrairement à C
    et
    à C++, il n’y
    a
    presque aucune conversion implicite
    de type.
    int x, y=6;
    float z=3.14f;

    x = z/y;
    …génère le message suivant à la compilation :
    TstCast.java:7: Incompatible type for =. Explicit
    cast needed to convert float to int.
    x = z/y;
    1 error
    Il faudrait écrire :
    x = (int)z /y; // division entière
    ou :
    x = (int) (z /(float) y); // division
    // réelle

Telecharger pour lire le cours complet:

Telecharger PDF