Cour JAVA.doc

Ennoncés des exercices ..... ne sera pas redéfinie, le compilateur peut optimiser les accès en limitant la liaison dynamique. ...... Ecrire une classe Matrice (en vous inspirant de l'exercice 4), qui implémente les deux interfaces Alg et Treillis.


un extrait du document



Liaison dynamique     HYPERLINK "http://www.dil.univ-mrs.fr/~gispert/enseignement/Java/2bases.html" \l "typesPrim" Types primitifs     HYPERLINK "http://www.dil.univ-mrs.fr/~gispert/enseignement/Java/2bases.html" \l "reference" Objets, références et ramasse-miettes     HYPERLINK "http://www.dil.univ-mrs.fr/~gispert/enseignement/Java/2bases.html" \l "constructeur" Constructeurs    HYPERLINK "http://www.dil.univ-mrs.fr/~gispert/enseignement/Java/2bases.html" \l "thisSuper" This et super     HYPERLINK "http://www.dil.univ-mrs.fr/~gispert/enseignement/Java/2bases.html" \l "protection" Protection des accès     HYPERLINK "http://www.dil.univ-mrs.fr/~gispert/enseignement/Java/2bases.html" \l "protection" Variable de classe    HYPERLINK "http://www.dil.univ-mrs.fr/~gispert/enseignement/Java/2bases.html" \l "final" Le modifieur final    HYPERLINK "http://www.dil.univ-mrs.fr/~gispert/enseignement/Java/2bases.html" \l "classesAbst" Classes abstraites     HYPERLINK "http://www.dil.univ-mrs.fr/~gispert/enseignement/Java/2bases.html" \l "natives" Méthodes natives     HYPERLINK "http://www.dil.univ-mrs.fr/~gispert/enseignement/Java/2bases.html" \l "tableau" Tableaux  
Les instructions
   HYPERLINK "http://www.dil.univ-mrs.fr/~gispert/enseignement/coursJava/3instructions.html" Affectation    HYPERLINK "http://www.dil.univ-mrs.fr/~gispert/enseignement/coursJava/3instructions.html" \l "expressions" Les expressions et la liste des opérateurs    HYPERLINK "http://www.dil.univ-mrs.fr/~gispert/enseignement/coursJava/3instructions.html" \l "conversions" Les conversions     HYPERLINK "http://www.dil.univ-mrs.fr/~gispert/enseignement/coursJava/3instructions.html" \l "parametres" Passage de paramètres     HYPERLINK "http://www.dil.univ-mrs.fr/~gispert/enseignement/coursJava/3instructions.html" \l "instructions" Les autres instructions     HYPERLINK "http://www.dil.univ-mrs.fr/~gispert/enseignement/coursJava/3instructions.html" \l "classesAbstr" Les classes abstraites     HYPERLINK "http://www.dil.univ-mrs.fr/~gispert/enseignement/coursJava/3instructions.html" \l "genericite" Un aperçu de la généricité 


 Exceptions
   HYPERLINK "http://www.dil.univ-mrs.fr/~gispert/enseignement/Java/3javaExceptions.html" Définition    HYPERLINK "http://www.dil.univ-mrs.fr/~gispert/enseignement/Java/3javaExceptions.html" \l "exemple" Exemple : analyse syntaxique     HYPERLINK "http://www.dil.univ-mrs.fr/~gispert/enseignement/Java/3javaExceptions.html" \l "mecanisme" Mécanisme    HYPERLINK "http://www.dil.univ-mrs.fr/~gispert/enseignement/Java/3javaExceptions.html" \l "exceptionsJava" Exceptions java     HYPERLINK "http://www.dil.univ-mrs.fr/~gispert/enseignement/Java/3javaExceptions.html" \l "creation" Création d'exceptions     HYPERLINK "http://www.dil.univ-mrs.fr/~gispert/enseignement/Java/3javaExceptions.html" \l "plusieurs" Récupération de plusieurs exceptions     HYPERLINK "http://www.dil.univ-mrs.fr/~gispert/enseignement/Java/3javaExceptions.html" \l "ordre" Ordre de récupération     HYPERLINK "http://www.dil.univ-mrs.fr/~gispert/enseignement/Java/3javaExceptions.html" \l "hierarchie" Hiérarchie prédéfinie 
 Les interfaces
   HYPERLINK "http://www.dil.univ-mrs.fr/~gispert/enseignement/coursJava/5interfaces.html" Définition et héritage multiple    HYPERLINK "http://www.dil.univ-mrs.fr/~gispert/enseignement/coursJava/5interfaces.html" \l "typeInter" Type interface    HYPERLINK "http://www.dil.univ-mrs.fr/~gispert/enseignement/coursJava/5interfaces.html" \l "contenu" Contenu    HYPERLINK "http://www.dil.univ-mrs.fr/~gispert/enseignement/coursJava/5interfaces.html" \l "exemple" Exemple
 Les paquetages
   HYPERLINK "http://www.dil.univ-mrs.fr/~gispert/enseignement/coursJava/6paquetage.html" Découpage d'un programme     HYPERLINK "http://www.dil.univ-mrs.fr/~gispert/enseignement/coursJava/6paquetage.html" \l "utilite" Utilité et nommage     HYPERLINK "http://www.dil.univ-mrs.fr/~gispert/enseignement/coursJava/6paquetage.html" \l "stockage" Stockage sur disque     HYPERLINK "http://www.dil.univ-mrs.fr/~gispert/enseignement/coursJava/6paquetage.html" \l "exemple" Exemple complet 
 Les Entrées/Sorties
   HYPERLINK "http://www.dil.univ-mrs.fr/~gispert/enseignement/coursJava/7javaES.html" Problèmes à résoudre     HYPERLINK "http://www.dil.univ-mrs.fr/~gispert/enseignement/coursJava/7javaES.html" \l "hierarchie" Hierarchie des classes    HYPERLINK "http://www.dil.univ-mrs.fr/~gispert/enseignement/coursJava/7javaES.html" \l "independance" Indépendance de la plate-forme     HYPERLINK "http://www.dil.univ-mrs.fr/~gispert/enseignement/coursJava/7javaES.html" \l "ESTamponnees" ES tamponnées  HYPERLINK "http://www.dil.univ-mrs.fr/~gispert/enseignement/coursJava/7javaES.html" \l "independance"     HYPERLINK "http://www.dil.univ-mrs.fr/~gispert/enseignement/coursJava/7javaES.html" \l "sources" Sources de données     HYPERLINK "http://www.dil.univ-mrs.fr/~gispert/enseignement/coursJava/7javaES.html" \l "formattage" Formattage des données     HYPERLINK "http://www.dil.univ-mrs.fr/~gispert/enseignement/coursJava/7javaES.html" \l "directs" Fichiers directs     HYPERLINK "http://www.dil.univ-mrs.fr/~gispert/enseignement/coursJava/7javaES.html" \l "streamtokenizer" Classe StreamTokenizer     HYPERLINK "http://www.dil.univ-mrs.fr/~gispert/enseignement/coursJava/7javaES.html" \l "clavier" Lecture au clavier     HYPERLINK "http://www.dil.univ-mrs.fr/~gispert/enseignement/coursJava/7javaES.html" \l "lectFormat" Lecture formattée     HYPERLINK "http://www.dil.univ-mrs.fr/~gispert/enseignement/coursJava/7javaES.html" \l "exemple" Exemple    HYPERLINK "http://www.dil.univ-mrs.fr/~gispert/enseignement/coursJava/7javaES.html" \l "java11" Java 1.1 
Interfaçage : AWT
   HYPERLINK "http://www.dil.univ-mrs.fr/~gispert/enseignement/coursJava/8awt.html" Fenêtrage et interfaçage     HYPERLINK "http://www.dil.univ-mrs.fr/~gispert/enseignement/coursJava/8awt.html" \l "exemple" Exemple
 Interfaçage : Swing
   HYPERLINK "http://www.dil.univ-mrs.fr/~gispert/enseignement/coursJava/9swing.html" Présentation    HYPERLINK "http://www.dil.univ-mrs.fr/~gispert/enseignement/coursJava/9swing.html" \l "LAF" Apparence    HYPERLINK "http://www.dil.univ-mrs.fr/~gispert/enseignement/coursJava/9swing.html" \l "fenetre" Fenêtre    HYPERLINK "http://www.dil.univ-mrs.fr/~gispert/enseignement/coursJava/9swing.html" \l "animation" Animation, classe Timer     HYPERLINK "http://www.dil.univ-mrs.fr/~gispert/enseignement/coursJava/9swing.html" \l "utilTimer" Utilisation d'un Timer     HYPERLINK "http://www.dil.univ-mrs.fr/~gispert/enseignement/coursJava/9swing.html" \l "exemple" Exemple    HYPERLINK "http://www.dil.univ-mrs.fr/~gispert/enseignement/coursJava/9swing.html" \l "ficAnim" Fichier Animation.java    HYPERLINK "http://www.dil.univ-mrs.fr/~gispert/enseignement/coursJava/9swing.html" \l "ficUrsa" Fichier UrsaMajor.java    HYPERLINK "http://www.dil.univ-mrs.fr/~gispert/enseignement/coursJava/9swing.html" \l "paquetages" Les paquetages Swing
  Le réseau
   HYPERLINK "http://www.dil.univ-mrs.fr/~gispert/enseignement/coursJava/10reseau.html" Utilisation indirecte : Applet     HYPERLINK "http://www.dil.univ-mrs.fr/~gispert/enseignement/coursJava/10reseau.html" \l "adressage" Adressage    HYPERLINK "http://www.dil.univ-mrs.fr/~gispert/enseignement/coursJava/10reseau.html" \l "images" Utilisation indirecte : images     HYPERLINK "http://www.dil.univ-mrs.fr/~gispert/enseignement/coursJava/10reseau.html" \l "mediaTracker" classe MediaTracker    HYPERLINK "http://www.dil.univ-mrs.fr/~gispert/enseignement/coursJava/10reseau.html" \l "usageDirect" Usage direct : exemple 
  La machine virtuelle
  HYPERLINK "http://www.dil.univ-mrs.fr/~gispert/enseignement/coursJava/11machineVirtuelle.html"  Une colle     HYPERLINK "http://www.dil.univ-mrs.fr/~gispert/enseignement/coursJava/11machineVirtuelle.html" \l "classLoader" ClassLoader    HYPERLINK "http://www.dil.univ-mrs.fr/~gispert/enseignement/coursJava/11machineVirtuelle.html" \l "classeClass" Classe Class     HYPERLINK "http://www.dil.univ-mrs.fr/~gispert/enseignement/coursJava/11machineVirtuelle.html" \l "elements" Eléments de la classe     HYPERLINK "http://www.dil.univ-mrs.fr/~gispert/enseignement/coursJava/11machineVirtuelle.html" \l "formatClass" Fichier .class     HYPERLINK "http://www.dil.univ-mrs.fr/~gispert/enseignement/coursJava/11machineVirtuelle.html" \l "prog" Ecriture d'un ClassLoader 

 Les Travaux dirigés
   HYPERLINK "http://www.dil.univ-mrs.fr/~gispert/enseignement/coursJava/TD.html" Ennoncés des exercices 
Historique et principes
 
Historique
L'origine du langage se situe en 1991, alors que Mosaic et le World Wide Web n'étaient que d'intéressants concepts.
JAVA a été conçu par James Gosling, chez SUN.
 
Le but principal était de développer une plate-forme à bas prix, avec un logiciel indépendant du matériel.
Partant de C++, et de ses défauts, James Gosling a développé le langage Oak, en supprimant les concepts dangereux : héritage multiple, conversion automatique de types, pointeurs, gestion mémoire par le programmeur.
En 1994, le Web a été créé ; Oak a été renommé JAVA.
JAVA a été alors utilisé pour la programmation du Web ;
il a permis d'écrire WebRunner, un programme de navigation.
Une version alpha de JAVA a été diffusée sur le Web au début 1995.
Depuis le 23 janvier 1996, la version 1.0 est officiellement disponible. Netscape 2.0 supporte JAVA.
 
Spécifications essentielles de JAVA
JAVA est un langage :
généraliste, bien que souvent associé à Internet ;
orienté objet ;
indépendant de la plate-forme ;
sûr ;
gérant le parallélisme ;
autorisant un développement rapide ;
 
Java a été défini pour un usage sur Internet, d'où de nombreuses propriétés :
environnement d'accès au réseau :  
toutes les primitives nécessaires pour la communication par Internet sont prévues dans le langage ; mais on verra plus loin qu'elles sont incluses sous une forme évolutive ;
des fragments de code (Applets) peuvent transiter par le Web pour exécution à distance.

indépendance de la plate-forme
on doit pouvoir écrire des programmes et les expédier à travers le réseau pour les faire exécuter sur la machine cible, quelle qu'elle soit ;
l'implémentation des types de base est spécifiée par le langage ;
d'où la définition d'un environnement graphique associé au langage, et des procédures qui le manipulent, identiques sur toute plate-forme ;
les programmes Java sont compilés pour une machine virtuelle ; il suffit d'implémenter cette machine virtuelle sur une machine hôte pour pouvoir y exécuter un programme Java compilé sur n'importe quelle autre machine

sûreté
C/C++ est très souple, donc très vulnérable ; JAVA est défensif !
quand on charge un programme à travers le réseau (Applet), on doit se prémunir contre la malveillance (cheval de Troie) ; toute applet est contrôlée avant d'être exécutée (accès aux fichiers...) ;
de plus, on souhaite que les programmes soient exempts de fautes (au maximum) ; pour cela, le compilateur est plus contraignant encore que celui de Pascal !
JAVA ne suppose jamais que vous savez ce que vous faites ; il s'assure que vous le savez !
JAVA contrôle le déroulement du programme à l'exécution ; il détecte ainsi de nombreuses erreurs sémantiques, non détectées par d'autres langages.
JAVA sépare les programmes locaux et les programmes venant du réseau, empêchant de remplacer le code local par un moins sûr !

Langage généraliste, syntaxe inspirée de celle de C/C++, mais...
débarrassée de ses éléments redondants, complexes, dangereux ;
plus simple, plus sûre, et plus facile d'emploi
une seule façon de définir des données (classe, pas de struct) ;
pas de conversions automatiques ;
pas de pointeurs, et surtout pas d'arithmétique sur des adresses... ;
le langage est fortement typé 
contrôles de type, de débordement... ;
gestion mémoire simplifiée : allocation, mais pas de libération, donc pas d'accès à un bloc qui a été libéré...
libération automatique par ramasse-miettes ;
traitement des exceptions bien conçu, rendu obligatoire ;
JAVA (ou un langage ayant les mêmes spécifications) a de grandes chances de devenir un langage très utilisé dans le développement d'applications distribuées. Avec le Web, celles-ci seront demain le cas général.
API : Application Programming Interface Langage JAVA
 
Système java
 INCLUDEPICTURE "http://www.dil.univ-mrs.fr/~gispert/enseignement/Java/coursJava_img/img1.gif" \* MERGEFORMATINET 
Le langage proprement dit est complété par :
certaines primitives contenues dans des librairies (E/S en particulier) ;
la toolbox pour les événements, interfaces...
Java contient à la fois le langage et une toolbox abstraite, capable de tourner sur toute machine.
 
Bases du langage
 
 
Programmation orientée objets
Pascal, C : programmation procédurale
Dans les années 60, analyse de ses défauts : les variables locales disparaissent à la fin de la procédure
on attache des procédures aux données au lieu d' attacher des données aux procéduresOn pensait procédure, et on attachait des variables aux procédures ; On pense données, et on attache des traitements à ces données.
Les données sont essentielles, les procédures accessoires
Appellant et appelé ont même durée de vie ; symétrie totale
Avantage pour l'écriture de coroutines (entrées/sorties)
Langages
Le langage Simula 67 a été créé en 1967, dans le but d'écrire des programmes de simulation (gestion d'un port par exemple). Le port offre des ressources, et des acteurs (bateaux) doivent les partager. Bien que ce ne soit pas un langage orienté objets à proprement parler, les données décrivant les bateaux (services nécessaires, heure d'arrivée au port...) sont associées aux actions que ceux-ci peuvent entreprendre. La notion d'objet est sous-jacente. Les acteurs sont indépendants, sauf pour la possession des ressources.
Le langage Smalltalk (1972) est le véritable ancêtre des langages orientés objets. Il présente des interfaces graphiques (Xerox) menus, souris, qui sont représentés par des classes.
Les langages de programmation classiques ont été étendus pour utiliser le nouveau paradigme. Objective C, Object Pascal, Loops (Bobrow), ... en sont des exemples. Mais les contraintes de compatibilité avec l'existant sont trop fortes pour donner une description très claire des langages.
 
Classes
Données et procédures sont réunies dans une classe. Une classe est une construction syntaxique. Elle représente un modèle sur lequel on pourra construire autant d'objets semblables qu'on pourra le souhaiter.
Un objet est une instance d'une classe. Tous les objets d'une même classe seront semblables, mais différents. Les différences entre eux proviendront des données qui leurs sont associées.
procédures nommées Méthodes
 INCLUDEPICTURE "http://www.dil.univ-mrs.fr/~gispert/enseignement/Java/coursJava_img/img2.gif" \* MERGEFORMATINET Une méthode s'applique à un objet de sa classe (en première approximation)Hiérarchisation
exemple : un point sur l'écran
x et y : coordonnées du point toString() : méthode présentant l'objet sous forme de chaîne INCLUDEPICTURE "http://www.dil.univ-mrs.fr/~gispert/enseignement/Java/coursJava_img/img3.gif" \* MERGEFORMATINET  INCLUDEPICTURE "http://www.dil.univ-mrs.fr/~gispert/enseignement/Java/coursJava_img/img4.gif" \* MERGEFORMATINET ajout des informations de couleur :
définition d'une sous-classe nommée Pixel
Pixel :
hérite des champs x et y ;
ajoute r, v et b.
toString() traduit un pixel en caractères ; elle appelle toString() de Point, et ajoute le traitement de r, v et b ; 
Si p est de type Point, p.toString() appelle la méthode toString() de Point :
Point p = new Point();
p.toString(); // écrit les valeurs de x et y
Si p est de type Pixel, p.toString() appelle la méthode toString() de Pixel :
Pixel p = new Pixel();
p.toString(); // écrit x, y, r, v et b
Le programmeur définit un seul nom pour toutes les méthodes qui font le même travail, quel que soit l'objet auquel elles s'appliquent ; par exemple, laver une voiture et laver du linge utilise en français le même verbe, et utilisera en java le même identificateur.
Comparez avec un autre langage, dans lequel vous devez inventer des noms différents pour indiquer une même fonction appliquée à des types différents.
Remarquez toutefois que ceci ne s'applique pas aux types primitifs.
En résumé, le programmeur ne s'adapte plus aux exigences du compilateur c'est le compilateur qui s'adapte.
La classe Point peut servir à d'autres usages :
Définition d'un rectangle par deux coins (haut-gauche, et bas-droit):
 INCLUDEPICTURE "http://www.dil.univ-mrs.fr/~gispert/enseignement/Java/coursJava_img/img5.gif" \* MERGEFORMATINET 
D'où découle une organisation naturelle en arbre des diverses classes.
Des classes définies par des personnes indépendantes devraient être compatibles entre elles au sens de la hiérarchie, donc faire partie d'un même arbre. Pour cela, il faut que la racine de l'arbre soit commune, ce doit être une classe ancêtre de toutes les autres. En Java elle s'appelle Object.
La hiérarchie complète de l'exemple est donc :
 INCLUDEPICTURE "http://www.dil.univ-mrs.fr/~gispert/enseignement/Java/coursJava_img/img6.gif" \* MERGEFORMATINET 
Tout ce qui est défini dans la classe Object sera donc utilisable dans tous les objets que nous créerons, puisqu'ils en hériteront tous.
Encapsulation
Habillage des données dans l'objet :
données locales invisibles de l'extérieur (choix du programmeur)
impossible de les modifier par erreur
Toute variable cachée est manipulée par des méthodes soigneusement mises au point, donc fiables.
Liens entre les variables maintenus par ces méthodes.
Exemple :
Soit une classe qui représente les comptes clients d'un banque (isolée des autres banques) ;
variable cachée : un tableau indiquant l'avoir de chaque client.
seule opération : débiter un client ; créditer un autre du même montant
le total des comptes reste constant.
En cachant le tableau à l'intérieur de la classe, on assure que seules les méthodes de celle-ci peuvent le manipuler.
Polymorphisme
On veut déplacer un point :
on donne 1 entier :x = x + delta;y = y + deltaon donne 2 entiers :x = x + deltaX ;y = y + deltaY 
EnPascal ou C, il faut définir 2 procédures portant des noms différents.
En Java, on peut redéfinir la même méthode (portant le même nom) mais avec une liste de paramètres différente :
deplacer(int delta);deplacer(int deltaX, int deltaY);Nous sommes capables de les distinguer, donc le compilateur aussi.
Remarque : deplacer(5) peut se traduire par deplacer(5, 5).
Autrement dit : on définira la forme la plus générale (à deux paramètres) ; la définition de l'autre se contentera d'appeller la forme générale en redoublant le paramètre.
L'abstraction, l'encapsulation, l'héritage et le polymorphisme sont les caractéristiques partagées par tous les langages à objets.
 
Liaison dynamique
La liaison est l'opération qui consiste à associer une entité du code en mémoire, à un identificateur dans le programme source. Dans les langages tels que Pascal ou C, la liaison est statique, c'est à dire que l'association est faite par le compilateur au moment de la génération du code. En java, cette liaison est normalement rejetée à l'exécution du programme, ce qui donne une puissance expressive bien supérieure, mais en contre-partie une moindre efficacité.
Les objets java en mémoire contiennent implicitement une information correspondant à leur type. Ceci permet le contrôle dynamique. La liaison dynamique s'applique aux méthodes.
 
Exemple :
Point p = new Pixel();
La variable p et l'objet créé ne sont pas de même type !
Mais un Pixel n'est qu'un cas particulier de Point, donc c'est un Point... et l'affectation est possible.
A quoi ça sert ? Soit :
Point p1 = new Point();
p1.toString(); appelle la méthode toString() définie dans Point
p.toString(); appelle la méthode toString() définie dans Pixel.
Soit le programme suivant :
Point p;
if (a == 1)
p = new Point();
else p = new Pixel;
String s = p.toString();
Au moment de la compilation, la valeur de a est inconnue. Le compilateur ne sait donc pas quel sera le type de l'objet désigné par p dans la dernière instruction. Il ne peut pas générer complètement l'appel de la méthode toString().
L'objet désigné par p contenant son type réel, il sera possible au moment de l'exécution de lancer la méthode associée.
Dans l'exemple ci-dessus, si a vaut 1, ce sera la méthode toString() de Point qui sera appellée, et dans le cas contraire celle de Pixel.
Ceci s'applique aux tableaux :
soit tab un tableau de Point ; tab[2] peut être un objet de type Point, ou de type Pixel.
On peut appeller une méthode sur un élément de tableau sans connaître son type précis.
Ce procédé permet de traiter des objets, sans connaître le détail du traitement !
Donc d'étendre des programmes déjà définis sans les recompiler.
 
Soit :
 INCLUDEPICTURE "http://www.dil.univ-mrs.fr/~gispert/enseignement/Java/coursJava_img/img7.gif" \* MERGEFORMATINET ecrire() utilise toString() pour écrire sous forme de texte tous les éléments du tableau.
Elle connait Point et Pixel définies avant elle. 
Définissons APRES la classe Pixel3D qui intégrera la troisième dimension :
 INCLUDEPICTURE "http://www.dil.univ-mrs.fr/~gispert/enseignement/Java/coursJava_img/img8.gif" \* MERGEFORMATINET ecrire() va écrire correctement tous les éléments ;
elle utilise toString() de Point ; la liaison dynamique accède à toString() de Pixel3D.
ecrire() fait ce qu'on attend, alors qu'elle a été écrite avant que l'existence d'un Pixel3D ait été envisagée ! 


Types primitifs
byteentier signé sur 8 bits ;shortentier signé sur 16 bits ;intentier signé sur 32 bits ;longentier signé sur 64 bits ;floatnombre flottant codé sur 32 bits (Norme IEEE 754-1985) ;doublenombre flottant codé sur 64 bits (Norme IEEE 754-1985) ;booleantrue ou false ;charcaractère codé sur 16 bits, dans le nouveau code UNICODE ;On remarquera que les formats des types primitifs sont fixés par des normes IEEE. Ceci signifie qu'un int aura toujours le même codage en machine, dans toutes les implémentations de java (toutes les machines virtuelles). Egalement, toute expression arithmétique, avec les mêmes paramètres, aura une valeur partout identique.
Classes enveloppes
A chaque type primitif correspond une classe qui contient des méthodes adaptées à ce type. Les classes se nomment :
typeclasseconstructeursbyte, short, intIntegerpublic Integer(int value);
public Integer(String s);longLongpublic Long(long value);
public Long(String s);floatFloatpublic Float(double value);
public Float(float value);
public Float(String s);doubleDoublepublic Double(double value);
public Double(String s);booleanBooleanpublic Boolean(boolean value);
public Boolean(String s);charCharacterpublic Character(char value);La méthode toString() est redéfinie dans toutes ces classes, de maniè