L’Histoire de Java.
Java est deux choses :
o un langage de programmation informatique orienté objet o un environnement d'exécution informatique portable
« Portable » veut dire qu’il peut tourner sur plusieurs systèmes d’exploitations différents ; Windows, Linux …
Java est présenté au public pour la première fois en 1995 .
Java c’est d’abord cassé les dents sur la télévision pour des raisons commerciales.
Java c’est lancé ensuite sur le Net, ce qui a été sa chance .
Origines :
Le langage reprend en grande partie la syntaxe du langage C++, très utilisé par les informaticiens.
Il s’agit en fait en gros du langage « C++ » mais avec :
o en moins : les sophistications extrêmes du C ++ (l’héritage multiple ,…) . o en plus :
o un renforcement de l’orientation « objet » .
o une meilleure gestion de la mémoire (via le « ramasse miette ») . o une portabilité totale quel que soit le système d’exploitation . o plus de sécurité (via la Machine Virtuelle Java) .
Application Java :
Java permet de développer des applications autonomes mais aussi, et surtout, des applications client-serveur.
Côté client, les applets sont à l'origine de la notoriété du langage.
Côté serveur, Java s'est imposé dans le milieu de l'entreprise grâce à 2 choses : les servlets, le pendant serveur des applets,
les JSP (JavaServer Pages) qui peuvent se substituer à PHP,….
Les applications Java peuvent être exécutées sur tous les systèmes d'exploitation pour lesquels a été développée une plateforme Java, dont le nom technique est JRE (Java Runtime
Environment), lequel est constitué de deux choses :
o La JVM (Java Virtual Machine ), le programme qui interprète le code Java et le convertit en code natif.
o Un ensemble de « bibliothèques » Java
Le nom « Java »
Le nom Java fut inventé dans un petit bar fréquenté par quelques membres de l'équipe.
A partir de ce point, les versions varient : soit c’est un acronyme du nom des inventeurs .
soit c’est en souvenir des cafés pris dans ce bar (Java = café en argot US) .
soit parce que ce langage devait pouvoir tourner sur d’autres supports que des pc et en particulier la petite électronique des cafetières .
Où utilise-t-on du Java ?
Sur les navigateurs Web . Dans les sites Web.
Sur les serveurs (JSP : Java serveur page) . Dans la petite électronique (machine à laver ….).
Etc ………….
Historique des versions :
Le langage Java a connu plusieurs évolutions depuis le JDK (Java Development Kit) 1.0 A partir de la version Java 1.2 on parle de Java 2 avec 2 grandes inovations :
o l'API graphique Swing est intégrée.
o la machine virtuelle Java de Sun inclut un compilateur "Juste à temps" (Just in Time).
Java et les autres …
Le Java classique est un Java fait en Java et qui grâce à sa machine virtuelle Java tourne sur toutes les plateformes .
Mais il existe d’autres possibilités :
o Java peut être compilé de telle façon qu’il puisse tourner sans son environnement . o Microsoft a développé la variante J# de Java, qui tourne sur une machine virtuelle
« microsoft » ( le CLR) .
o Java peut être créé en « adaptant la sauce » d’autres programmes « non Java », comme Python qui se traduit en java par le compilateur Jython, ou encore Groovy.
Java et la justice :
Java est « open source » ,mais ce n’est pas pour autant qu’on peut en faire ce qu’on veut ; il y a toujours une « licence » à respecter .
La licence de Sun pour Java insiste sur le fait que toutes les implémentations doivent être compatibles. Ceci a aboutit à la plainte en Justice contre Microsoft après que Sun a constaté que l'implémentation de Microsoft avait 2 problèmes :
o L’implémentation Microsoft de Java ne ne supportait pas les interfaces Java native RMI et JNI
o L’implémentation Microsoft de Java comportait des éléments spécifiques à certaines plateformes et donc incompatibles avec « toutes les plateformes ».
Sun obtint des dommages et intérêt (20 millions de dollars) et l'acte de justice renforça encore les termes de la licence de Sun.
En réponse, Microsoft arrêta le support de Java sur ses plates-formes et, sur les versions récentes de Windows, Internet Explorer ne supporte pas les applets Java (du moins pas sans devoir ajouter de plug-in, chose que « tout le monde ne fait pas).
En réponse à cette attitude de Microsoft, Sun met à disposition sur le net et gratuitement des environnements d'exécution de Java pour les différentes plates-formes Microsoft….
Langage compilés et interprétés.
Il existe deux types de langages : les langages compilés et les langages interprétés.
Pour les langages compilés,
cela se passe à 2 niveaux : chez le concepteur du code et chez l’utilisateur du code .o Chez le concepteur du code : on transforme le code source du programme directement en langage compréhensible par la machine à l' aide d'un compilateur.
Tout le code est compilé en une fois (chez le fabricant du code) ,et bien évidement enregistré tel quel (post compilation) dans le programme livré ou vendu .
o Au niveau utilisateur, le code que la machine va traiter existe donc en tant que code complet , utilisable « directement » .C’est donc « très rapide ».
Pour les langages interprétés,
cela se passe à 1 seul niveau : au niveau de l’utilisateur : le code source du programme reste toujours dans son état « natif » (cad tel que livré par le concepteur) ,et doit donc passer par l'interpréteur qui va lire chaque ligne du code source et l'exécuter.Chaque ligne est donc exécuté après avoir été interprétée chaque fo is .
L’entièreté du code « utilisable » par la machine n’existe donc pas,et n’existera « jamais » ; seule une ligne à la fois existe .
Le gros défaut des langages interprétés est donc la lenteur, bien que, avec la rapidité des processeurs cet inconvénient est devenu très relatif .
Philosophie de Java.
Lors de la création du langage Java, il avait été décidé que ce langage devait répondre à 5 objectifs :
1. utiliser une méthode orientée objet,
2. permettre à un même programme d'être exécuté sur plusieurs systèmes d'exploitation différents,
3. pouvoir utiliser de manière native les réseaux informatiques, 4. pouvoir exécuter du code distant de manière sûre,
5. être facile à utiliser et posséder les points forts de langages de programmation orientés objet déjà fortement utilisés comme le C++.
Un langage orienté objet.
Le langage orienté objet (« OO ») consiste à associer au même endroit (l’objet) les différents types de données et les différentes opérations qu'on peut effectuer sur ces données.
Ceci a plusieurs avantages :
o C’est plus simple à écrire donc plus rapide et avec moins d’erreurs . o Les sous éléments du code peuvent servir de « kit » pour un code futur ,
comme si il s’agissait d’un composant matériel « enfichable » utilisé dans l’industrie.
Ceci crée peu de contraintes : o Un code clair .
o Un code bien documenté.
o Une multitude de petits éléments bien définis plutôt qu’un « gros machin » type usine à gaz qui ne servira que dans un type bien précis d’application et rien d’autre
Comparaisons Informatiques .
Avant toutes choses, quelques comparaisons, dans le but de faire comprendre une réalité
« bien connue »,celle de la vie de tous les jours, mais « vue par un informaticien Java » . C’est « la même chose », tout en étant fort différent …
o Le jeu de Légo.
o Le feu rouge et les autos . o L’équipe de foot .
o Le colonel moutarde . o Les chambres d’hôtel .
Le jeu de Légo.
o Dans un jeu de Légo, il y a des pièces élémentaires .
o Ces pièces, elles viennent de l’usine, et il faudra faire avec .
o Mais les pièces sont tellement nombreuses que l’on sait pratiquement faire tout ce qu’on veut avec elles .
o Une fois que l’on sait ce qu’on a besoin exactement,
il est très facile de multiplier l’affaire en refaisant exactement la même chose à quelques variantes près .
o Avec les cubes on a fait la maison et le jardin .
o On peut reproduire cette maison et ce jardin à l’infini .
o Chacun des propriétaires peut changer le jardin ou la cheminée .
o Mais il ne pourra pas mettre « sa cheminée à lui » ou « son jardin à lui »,il devra utiliser les éléments de jardin prévus par Légo .
Mais ceux là il pourra les agencer comme il veut .
Le feu rouge et les autos .
C’est un exemple particulièrement intéressant pour comprendre Java . Cet exemple reviendra à plusieurs sauces .
La situation :
o Un feu rouge . o Divers véhicules :
o certains vides et d’autres occupés . o des autos de divers types .
o des vélos .
o Une vitesse limite : 50 km heure .
Que va-t-il se passer quand le feu va passer « au vert » ?
o Si c’est « public » : Quand le feu passe au vert, il prend le contrôle total du véhicule, et le chauffeur ne peut rien faire .
Il va amener lui-même ce véhicule à 50 à l’heure .
o Si c’est « private » : Quand le feu passe au vert, il se borne à avertir le conducteur
qu’il peut commencer à conduire .
Imaginons que c’est « private » et que les voitures doivent démarrer .
o Les voitures inoccupées par exemple parquées le long du trottoir ne vont pas démarrer o Le taxi en train de décharger un passager peut partir, mais ne va pas partir .
o Toutes les voitures peuvent légalement aller à 50 /heure, mais certaines ne sauront pas le faire par exemple parce que c’est une « Smart » .
o Toutes les voitures peuvent aller à 50 à l’heure, mais certaine y seront plus vite que d’autre :
o Soit parce qu’elles ont un moteur plus puissant .
o Soit parce qu’elles sont « devant » et ne sont pas ralentis par les autres .
L’équipe de foot .
Imaginons un club de foot .
Ce Club de foot a une équipe de foot qui ne représente qu’une partie des adhérents au club . Cette équipe de foot se subdivise en 2 sous groupes « les shooter » et le « gardien » .
C’est la même équipe, mais les « shooter » et le « gardien » ce n’est pas tout à fait la même chose ,en effet le gardien :
• N’a pas tout à fait le même costume .
• Est le seul qui peut prendre le ballon à la main
• Doit théoriquement (mais rien ne l’oblige) rester dans ou près de son goal . Imaginons maintenant que « tout est perdu » et que l’entraîneur donne l’ordre à tous y compris au gardien d’attaquer :
• Les « attaquants » vont très bien attaquer .
• Les défenseurs et le gardien vont attaquer aussi ,mais ce n’est pas leur spécialité , donc ils le feront moins bien .
Les boucles for et le Colonel Moutarde .
La syntaxe ici est « approximative » , faite uniquement « pour comprendre » . Le cas qui nous occupe ici est celui des boucles imbriquées .
Ici, on joue au Cluedo .
Il y a 3 choses : des suspects, des pièces et des armes .
Comment mettre çà « en musique » pour avoir toutes les possibilités ? On commence par faire des listes :
Enum Suspect { Moutarde,Rose,Olive ….} ; Enum Pieces {Salon,cuisine,hall…..} ;
Enum Armes {couteau,revolver,chandelier…} ; Chaque liste a des « values » .
Pour chaque « value » de suspect il y a toutes les values de pièces .
Pour chaque value de suspect dans une pièce, il y a toutes les values d’armes . Ce qui donne (on utilise la boucle « for » améliorée cf infra) :
for (Suspect monsuspect : Suspect . values ( ) ) { for (Pieces mapiece : Pieces. values ( ) {
for (Arme monarme : Armes . values ( ) {
On remarque les parenthèses qui s’ouvrent derrière chaque “for” . Le programme fera donc,
Pour chacun des 6 suspects possibles Le tour des 6 pièces possibles Et pour chaque pièce possible Le tour des 6 armes possibles .
On peut en fait parcourir toutes ces données de 2 façons différentes :
o Avec « for classique » : il aurait fallut passer au préalable par une numérisation de chaque variable .
Cela aurait été par exemple : suspect 1 , dans la pièce 1, avec l’arme 1 .
o Avec « for amélioré » (depuis Java 1.5) : on y va « directement » avec les noms . Ce sera par exemple : Colonel Moutarde, dans le couloir, avec le couteau .
Indépendance vis-à-vis de la plate-forme.
L’indépendance vis-à-vis de la plate-forme, signifie que les programmes écrits en Java fonctionnent de manière parfaitement similaire sur différentes architectures matérielles.
On peut dès lors effectuer le développement sur une architecture donnée et faire tourner l'application sur toutes les autres quelles que soient les interfaces (Windows,Linux…) et les versions (Windows 95,98,Me…).
Ce résultat est obtenu par les compilateurs Java qui compilent le code source en deux fois :
• La première fois,on obtient un « bytecode Java », un langage machine spécifique à la plate-forme Java,et à aucune autre plateforme (Windows,Linux …).
• La deuxième fois ce « byteCodeJava est traduit en « réel bytecode pour l’interface considéré » ;il existe donc à ce niveau des traducteurs « byteCode » différents pour les différents systèmes Windows, Linux, etc …).
La première compilation « prend du temps ».
La deuxième compilation se fait très rapidement via un compilateur juste-à-temps (just in time, JIT).
Il y a donc 2 « bytecodes » successifs et différents . .
La portabilité universelle est cependant un objectif difficile à atteindre
Le nombre important de plateformes fait que ceci est pratiquement impossible,et donc il reste de-ci, de là, de petites erreurs qui ont abouti à un détournement du slogan de Sun "Write once, run anywhere" ("Ecrire une fois, exécuter partout") en "Write once, debug everywhere"
("Ecrire une fois, déboguer partout") !
Java et la vitesse
:Les premières implémentations du langage utilisaient une machine virtuelle interprétée pour obtenir la portabilité.
Tout le code était « interprété », tant et si bien que cela produisait des programmes qui s'exécutaient plus lentement que ceux écrits en C ou en C++, si bien que le langage souffrit d'une réputation de faibles performances.
Des implémentations plus récentes de la machine virtuelle Java (JVM) produisent des
programmes beaucoup plus rapides qu'auparavant, en utilisant différentes techniques dont en particulier la recompilation dynamique ,qui analyse le comportement du programme et ne recompile sélectivement que certaines parties.
Exécution sécurisée de code distant :
La plate-forme Java fut l'un des premiers systèmes garantissant une sérieuse mais pas totale sécurité à l'exécution du code .
En effet, un applet est destiné à fonctionner dans le navigateur Web d'un utilisateur, si du moins celui-ci l’autorise, donc si celui-ci est « confiant » en la chose .
Le principe est le suivant :
o Le code d'une applet ne fonctionne que via un « gestionnaire de sécurité. », Lequel observe ce que l’applet demande comme accès au système « hôte » :
o Type d’accès demandé (lecture – écriture ).
o Type de dossier demandé (System,…).
o En plus, et à côté du « gestionnaire de sécurité »,il existe encore les « certificats » : Un « certificat » est une garantie par « sun System » que l’applet (qui a été vérifié par les instances Java) est d’utilisation « sûre » (elle sera néanmoins toujours observée par le gestionnaire de sécurité,qui en particulier vérifiera si l’applet pourtant « certifié » n’a pas été manipulé « après sa certification ») .
Programmation en Java.
La programmation peut se faire de 3 façons : o « à la main » et avec le compilateur javac,
o avec un environnement de développement intégré (IDE) comme Eclipse o avec un outil professionnel de construction comme Scons
Le Java graphique .
La base .
La base du dessin est une « Frame » .
La Frame appartient aux classes héritées suivantes : o Objet
o Component o Container o Window
Particularités graphiques :
1. Les coordonnées à l’intérieur de la Frame dépendent toutes de l’angle supérieur gauche de la Frame qui a par définition la coordonnée x = 0 et y = 0 .
2. Y est croissant dans la fenêtre de haut en bas …
Besoins minimums :
Pour créer une interface graphique (une calculette par exemple), Il faut :
o Des objets bien précis existant dans des listes (boutons , …) .
o Un gestionnaire de disposition ,disant où et comment ces objets doivent être mis . o Un gestionnaire d’évènements disant ce qui va se passer si on agit sur tel bouton de
l’objet .
Les outils graphiques Java .
Ils sont au nombre de 2 : AWT et Swing . AWT :
o Est élémentaire par rapport à Swing (en particulier pas de possibilités « 3D »).
o Mais est plus rapide que Swing.
o Par contre dépend assez des ressources de la machine hôte . Swing :
o Est plus puissant que AWT et permet la « 3D ».
o Est légèrement plus lent .
o Est autonome par rapport au système hôte .
AWT et Swing n’existent pas de façon « native »,il faut les « importer » . Il faut les importer « avant toute autre chose » .
La syntaxe est :
Import javax.swing.* // on remarque le X de Javax
// on remarque que javax et swing sont en minuscule.
// on remarque le point entre javax et swing // le point entre swing et * Import java.awt.*
//Rem 1 : Il n’est jamais bon de travailler avec à la fois swing et AWT . // Rem 2 : java.awt.event.* n’est pas importé avec le « pac » java.awt.*
Les composants « swing » se distinguent des composants AWT par le fait que les composants
« swings » commencent tous par un J majuscule : o JButton. (remarquons le B majuscule)
o JTextField (remarquons le T et le F majuscule) . o Jlabel
o Jpanel o JFrame
Petit tour des éléments graphiques principaux :
« Objets graphiques » .
Classe Frame La page complète
Panel Un seul panneau
Label Texte non modifiable dans la fenêtre .
Button Bouton poussoir
Checkbox Cases à cocher multiples . RadioButton Cases à cocher unique . TextField Texte sur une seule ligne . TextfieldArea Texte sur plusieurs lignes . TabbedPane Onglets .
Disposition . Interface FlowLayout BorderLayout GridLayout BoxLayout CardLayout Ecouteurs . Interface MouseListener
MouseWheelListener KeyListener
ListSelectionListener ItemListener
ActionListener FocusListener
Comment créer l’interface graphique ?
1. Réfléchir à ce que l’utilisateur attend de faire .
2. Traduire çà en interface graphique et en faire le dessin . 3. Créer l’objet avec le gestionnaire de disposition .
4. Rendre l’objet opérant avec le gestionnaire d’évènements .
Faire faire quelque chose à l’interface .
Une fois que l’interface est « faite »,cad une fois que les boutons, etc sont « mis » ,comment faire correspondre une action à un bouton ?
La première chose à faire,
La première chose à faire, est d’importer de quoi faire …cad importer : Import java.awt.event.*
La deuxième chose à faire :
La deuxième chose à faire est de définir un « écouteur » qui écoute spécifiquement cet événement .
Quelques remarques :
• Un écouteur c’est un objet logique et non un composant matériel (même invisible) qu’on devrait ajouter à la fenêtre .
• L’écouteur n’est pas distinct de l’acteur ; c’est le même objet qui écoute et qui agit .
• Une action peut être surveillées par plusieurs écouteurs différents . Deux étapes :
o Déclarer qu’on va utiliser un « ActionListener » ,avec une syntaxe au premier abord
« curieuse » :….
class mapremiereframe extends Jframe implements ActionListener Remarquons qu’il n’y a pas de virgules de séparation .
Remarquons que la classe « Extend » une autre classe et « Implement » des méthodes.
o Joindre l’ActionListener au Bouton monbouton.addActionListener(This) ;
Remarque :
La plupart du temps, l’événement surveillé sera un clic de souris .
Le fait de cliquer avec la souris va créer une nouvelle classe qui n’existait pas encore jusque là : la classe MouseEvent
Cette classe n’existe pas au départ du programme ; elle naît uniquement quand un événement souris a lieu .
La classe « MouseEvent » regroupe plusieurs évènements qui peuvent se passer :
• mouseClicked
• mousePressed
• mouseReleased
• mouseEntered
• mouseExited
Si on veut utiliser un « mouseListener »,il faut définir ce qui va se passer avec toutes ces actions .
Or la plupart ne sont jamais utilisées et seule mouseCliked est couramment utilisée ; Donc le plus simple est de ne pas recourir à MouseListener ,mais bien à un autre objet : Mouseadapter.
MouseAdapter a déjà par défaut tout initialisé à « 0 »,et au lieu de mettre pour chacun des
« MouseEvent » la valeur « 0 » ,il suffit de remplir le ou les seuls évènements qui seront à suivre :
Avec MouseListener Avec MouseAdapter
Public void mouseCliked Public void mousePressed Public void mouseReleased Public void mouseEntered Public void mouseExited
Public void mouseCliked
Remarque : la souris ou l’évènement ? Il y a plusieurs façons de créer un évènement :
• cliquer sur un bouton
• cliquer sur un élément d’une liste
• changer le contenu de la zone texte ;
• etc.. .
Tous les objets ne réagissent pas nécessairement à un double click de la souris . Il faudra voir ce que l’objet déterminé peut faire .
Par exemple, le double clic sur un item d’un objet List ne fait strictement rien ….
Les évènements graphiques de « bas niveau » :
Les évènements graphiques de bas niveau ne concernent que les actions de l’utilisateur , et pas la participation active de l’interface « vive » .
On peut concevoir les différents évènements graphiques de bas niveau de la façon suivante : Type Evènement Ecouteur Méthode Ecoute Méthode Evènement
MouseClicked MousePressed MouseEvent MouseListener
MouseReleased
getComponent getSource getX getY KeyPressed
KeyReleased
KeyEvent KeyListener getComponent
getSource getKeyModified getKeyText FocusGained
FocusLost
FocusEvent FocusListener getComponent
getSource
Les évènements graphiques de « haut niveau » :
Les évènements graphiques de haut niveau impliquent la participation de l’interface « vive » : o Sélection dans un menu.
o Sélection dans une liste . o Modification dans un texte .
Les couleurs des éléments :
Couleur Hexadécimal R G B
Noir
000000 0 0 0Blanc FFFFFF 255 255 255
Rouge FF0000 255 0 0
Vert 00FF00 0 255 0
Bleu 0000FF 0 0 255
Jaune FFF000 255 240 0
Remarque :
Dès qu’il est possible, la valeur en hexadécimal « marche » .
En tous les cas sur des « color analyser » et pour les couleurs « de base » reprises supra . Exemple :
FF0000 = Rouge .
FF = Exactement le même rouge
ColorSpace cspace, float[] components, float alpha)
Creates a color in the specified ColorSpace with the color components specified in the
float array and the specified alpha.
Color(float r, float g, float b)
Creates an opaque sRGB color with the specified red, green, and blue values in the range (0.0 - 1.0).
Color(float r, float g, float b, float a)
Creates an sRGB color with the specified red, green, blue, and alpha values in the range (0.0 - 1.0).
Color(int rgb)
Creates an opaque sRGB color with the specified combined RGB value consisting of the red component in bits 16-23, the green component in bits 8-15, and the blue component in bits 0-7.
Color(int rgba, boolean hasalpha)
Creates an sRGB color with the specified combined RGBA value consisting of the alpha component in bits 24-31, the red component in bits 16-23, the green component in bits 8-15, and the blue component in bits 0-7.
Color(int r, int g, int b)
Creates an opaque sRGB color with the specified red, green, and blue values in the range (0 - 255).
Color(int r, int g, int b, int a)
Creates an sRGB color with the specified red, green, blue, and alpha values in the range (0 - 255).
La taille de l’élément .
Il est possible dans une certaine mesure de donner une taille définie à un objet .
Mais ça ne marche pas toujours, et quand ça marche, ce n’est pas nécessairement « tout le temps » …
La méthode est en général » « setPreferedSize ».
La méthode n’est pas directe ,mais passe par l’intermédiaire d’un nouvel objet : « Dimension ».
Cet objet n’est pas « quelconque » ,mais un objet prévu et repris dans les API Java ;
java.awt
Class Dimension
java.lang.Object
java.awt.geom.Dimension2D
java.awt.Dimension
The Dimension class encapsulates the width and height of a component in a single object.
The class is associated with certain properties of components.
La syntaxe est (par exemple) :
Monpremierbouton.setPreferedSize(new Dimension (100,100)) ; De ceci,
o BorderLayout ne tient aucun compte ;
o FlowLayout en tient compte dans la mesure de la taille de l’ensemble support . Mais il y a des conflits d’intérêts entre l’objet et son conteneur :
o Soit on définit l’objet avant son conteneur, et alors c’est simple, le containeur s’adapte .
o Soit on définit d’abord le containeur puis l’objet, et là il y a un « problème » : o Soit on doit ajuster le container à l’objet via la méthode « validate » . o Soit on doit ajuster l’objet au container via la méthode « revalidate » .
Pour certains objets, ça ne marche pas « ainsi » .
L’exemple classique est les lignes de texte (TextField) .
Avec TextField, ça marche via le nombre de caractères affichables et non une longueur en pixels .
java.awt
Class Graphics
java.lang.Object java.awt.Graphics
The Graphics class is the abstract base class for all graphics contexts.
A Graphics object encapsulates state information of the following properties:
• The Component object.
• A origin.
• The current color.
• The current font.
Constructor Detail
Graphics
protected Graphics() Constructs a new Graphics object.
Graphics is an abstract class
Method Detail
translate
public abstract void translate(int x, int y)
Translates the origin of the graphics context to the point (x, y
setColor
public abstract void setColor(Color c)
setFont
public abstract void setFont(Font font)
copyArea
public abstract void copyArea(int x, int y, int width, int height, int dx, int dy)
Copies an area of the component by a distance specified by dx and dy. From the point specified by x and y.
drawLine
public abstract void drawLine(int x1, int y1, int x2, int y2)
Draws a line, using the current color, between the points (x1, y1) and (x2, y2) in this graphics context's coordinate system.
.
fillRect
public abstract void fillRect(int x, int y, int width, int height)
Fills the specified rectangle.
drawRect
public void drawRect(int x, int y, int width, int height)
Draws the outline of the specified rectangle. The left and right edges of the rectangle are at x and x + width. The top and bottom edges are at y and y + height. The rectangle is drawn using the graphics context's current color.
clearRect
public abstract void clearRect(int x, int y, int width, int height)
Clears the specified rectangle by filling it with the background color of the current drawing surface. This operation does not use the current paint mode.
drawRoundRect
public abstract void drawRoundRect(int x, int y, int width, int height, int arcWidth, int arcHeight)
Draws an outlined round-cornered rectangle
arcWidth - the horizontal diameter of the arc at the four corners.
arcHeight - the vertical diameter of the arc at the four corners.
fillRoundRect
public abstract void fillRoundRect(int x, int y, int width, int height, int arcWidth, int arcHeight)
Fills the specified rounded corner rectangle with the current color.
drawOval
public abstract void drawOval(int x, int y, int width, int height)
Draws the outline of an oval. The result is a circle or ellipse Parameters:
x - the x coordinate of the upper left corner of the oval to be drawn.
y - the y coordinate of the upper left corner of the oval to be drawn.
width - the width of the oval
height - the height of the oval
fillOval
public abstract void fillOval(int x, int y, int width, int height)
Fills an oval bounded by the specified rectangle with the current color.
drawArc
public abstract void drawArc(int x, int y, int width, int height, int startAngle, int arcAngle)
Draws the outline of a circular or elliptical arc covering the specified rectangle.
The resulting arc begins at startAngle and extends for arcAngle degrees, using the current color.
Angles are interpreted such that 0 degrees is at the 3 o'clock position.
A positive value indicates a counter-clockwise rotation .
The center of the arc is the center of the rectangle whose origin is (x, y) and whose size is specified by the width and height arguments.
drawPolyline
public abstract void drawPolyline(int[] xPoints, int[] yPoints, int nPoints)
Draws a sequence of connected lines defined by arrays of x and y coordinates. Each pair of (x, y) coordinates defines a point.
The figure is not closed if the first point differs from the last point.
Parameters:
xPoints - an array of x points
yPoints - an array of y points
nPoints - the total number of points
drawPolygon
public abstract void drawPolygon(int[] xPoints, int[] yPoints, int nPoints)
Draws a closed polygon defined by arrays of x and y coordinates.
Each pair of (x, y) coordinates defines a point.
This method draws the polygon defined by nPoint line segments.
drawImage
public abstract boolean drawImage(Image img, int x, int y,
ImageObserver observer)
Parameters:
img - the specified image to be drawn. This method does nothing if img is null.
x - the x coordinate.
y - the y coordinate.
observer - object to be notified as more of the image is converted.
Returns:
false if the image pixels are still changing; true otherwise.
drawString
public abstract void drawString(String str, int x, int y)
Parameters:
str - the string to be drawn.
x - the x coordinate.
y - the y coordinate.
Exemple : drawstring (“Salut les mecs”,50,100);
toString
public String toString()
Returns a String object representing this Graphics object's value.
.
Dessins « de base » .
Quelques dessins élémentaires sont déjà prévus dans le frame :
Le point
Le point épais Le point épais c’est un
minuscule cercle . La ligne
La ligne épaisse. La ligne épaisse se sont des
lignes parallèles décalées de 1 pixel l’une de l’autre .
Le rectangle – le carré Le carré c’est un cas
particulier de rectangle avec 2 mesures identiques .
L’ovale – le cercle . Le cercle c’est un cas
particulier d’ovale avec 1 seul centre .
Le point, la ligne, le rectangle, sont des objets prévus dans les API Java …
Class Point
java.lang.Object
java.awt.geom.Point2D java.awt.Point
A point representing a location in (x, y) coordinate space, specified in integer precision.
Class Line2D
java.lang.Object
java.awt.geom.Line2D
This Line2D represents a line segment in (x, y) coordinate space.
Class Rectangle
java.lang.Object
java.awt.geom.RectangularShape java.awt.geom.Rectangle2D java.awt.Rectangle
A Rectangle specifies an area in a coordinate space that is enclosed by the Rectangle
object's top-left point (x, y), its width, and its height.
Remarquez: les Roundrectangle sont d’autres objets ,et non des variétés de rectangle .
java.awt.geom
Class RoundRectangle2D
java.lang.Object
java.awt.geom.RectangularShape java.awt.geom.RoundRectangle2D
The RoundRectangle2D class defines a rectangle with rounded corners defined by : o a location (x, y),
o a dimension (w x h),
o the width and height of an arc with which to round the corners.
This class is the abstract superclass for all objects that store a 2D rounded rectangle.
setRoundRect
public abstract void setRoundRect(double x, double y, double w, double h,
double arcWidth, double arcHeight)
Sets the location, size, and corner radii of this RoundRectangle2D to the specified
double values.
Parameters:
x, y - the coordinates to which to set the location of this RoundRectangle2D
w - the width to which to set this RoundRectangle2D
h - the height to which to set this RoundRectangle2D
arcWidth - the width to which to set the arc of this RoundRectangle2D
arcHeight - the height to which to set the arc of this RoundRectangle2D
Les affichages de texte :
La syntaxe de base est
drawstring (“texte à afficher”,position horizontale du premier caractère affiché,position verticale de ce même caractère);
Textes qui se suivent ou qui se superposent :
Le problème est que de police à police, la taille réelle peut varier sensiblement même si la
« taille du sélecteur de taille » reste la même .
En outre il y a les lettres du texte lui même, avec les « L » beaucoup plus petit que les « M » Bref,on ne sait donc pas dire via des mesures préétablies où doit se mettre le texte suivant v Il faut passer par le biais d’un objet prévu à l’API Java :
Textes qui se superposent :
Même problème,mais de définition de l’espacement de l’interligne (getLeading); tout dépend en effet comment en particulier les « T »(jambages « ascendants » :gestAscent) et les « G » (jambages « descendants » getDescent) seront écris .
Icônes .
javax.swing
Class ImageIcon
java.lang.Object
javax.swing.ImageIcon
Constructor Detail
ImageIcon
public ImageIcon(String filename)
Creates an ImageIcon from the specified file.
The image will be preloaded by using MediaTracker to monitor the loading state of the image.
Method Detail
loadImage
protected void loadImage(Image image)
Loads the image, returning only when the image is loaded.
getImage
public Image getImage()
Returns this icon's Image.
setImage
public void setImage(Image image)
Sets the image displayed by this icon.
paintIcon
public void paintIcon(Component c, Graphics g, int x, int y)
Paints the icon.
GetIconWidth Height
public int getIconWidth ou height …()
Media tracker .
java.awt
Class MediaTracker
java.lang.Object
java.awt.MediaTracker
The MediaTracker class is a utility class to track the status of a number of media objects.
Media objects could include audio clips as well as images, though currently only images are supported.
To use a media tracker, create an instance of MediaTracker and call its addImage method for each image to be tracked.
Each image can be assigned a identifier.
This identifier controls the priority order in which the images are fetched.
Constructor Detail
MediaTracker
public MediaTracker(Component comp)
Creates a media tracker to track images for a given component.
Method Detail
addImage
public void addImage(Image image, int id, int w, int h)
Adds a scaled image to the list of images being tracked by this media tracker.
Parameters:
image - the image to be tracked
id - an identifier that can be used to track this image
w - the width at which the image is rendered
h - the height at which the image is rendered
waitForAll
public void waitForAll()
This method waits until all the images being tracked have finished loading.
Les objets « Font » …
java.awt
Class Fontjava.lang.Object java.awt.Font
The Font class represents fonts,
The Java 2 platform distinguishes between two kinds of fonts: physical fonts and logical fonts.
• Physical fonts are the actual font libraries
Physical fonts may use names such as Helvetica, …
• Logical fonts are the five font families defined by the Java platform which must be supported by any Java runtime environment: Serif, SansSerif, Monospaced, Dialog, and DialogInput. These logical fonts are not actual font libraries.
java.awt
Class FontMetrics
java.lang.Object
java.awt.FontMetrics
The FontMetrics class defines a font metrics object, which encapsulates information about the rendering of a particular font on a particular screen.
java.awt
Class GraphicsEnvironment
java.lang.Object
java.awt.GraphicsEnvironment
The GraphicsEnvironment class describes the collection of GraphicsDevice objects and
Font objects available
GraphicsDevice objects can be screens, printers or image
The getAllFonts method of the GraphicsEnvironment class returns an array of all font faces available in the system.
java.awt
Class Component
java.lang.Object
java.awt.Component
A component is an object having a graphical representation that can be displayed on the screen and that can interact with the user.
Examples of components are the buttons, checkboxes, …
The Component class is the abstract superclass of the nonmenu-related Abstract Window Toolkit components.
La question des alignements :
TOP_ ALIGNMENT public static final float TOP_ALIGNMENT CENTER_ ALIGNMENT public static final float CENTER_ALIGNMENT BOTTOM_ALIGNMENT public static final float BOTTOM_ALIGNMENT LEFT_ ALIGNMENT public static final float LEFT_ALIGNMENT RIGHT_ ALIGNMENT public static final float RIGHT_ALIGNMENT
Constructor Detail
protected Component
()Constructs a new component.Class Component can be extended directly to create a lightweight component that does not utilize an opaque native window.
A lightweight component must be hosted by a native container somewhere higher up in the component tree (for example, by a Frame object).
Method Detail
SetName public void setName(String name) SetVisible public void setVisible(boolean b) SetForeground public void setForeground(Color c) SetBackground public void setBackground(Color c) SetFont public void setFont(Font f)
SetSize public void setSize(int width,int height)
Paint public void paint(Graphics g)
This method is called when the contents of the component should be painted; such as when the component is damaged and in need of repair
Repaint public void repaint()
If this component is a lightweight component, this method causes a call to this component's paint method as soon as possible.
Otherwise, this method causes a call to this component's update method as soon as possible.
Class Container .
java.awt
Class Container
java.lang.Object
java.awt.Component java.awt.Container
A generic Abstract Window Toolkit(AWT) container object is a component that can contain other AWT components.
Components added to a container are tracked in a list.
The order of the list will define the components' front-to-back stacking order within the container.
If no index is specified when adding a component to a container, it will be added to the end of the list (and hence to the bottom of the stacking order).
Constructor Detail
Container
public Container()
Method Detail
getComponentCount
public int getComponentCount()
Gets the number of components in this panel.
getComponent
public Component getComponent(int n)
Gets the nth component in this container.
add
public Component add(Component comp)
Appends the specified component to the end of this container.
add
public Component add(Component comp,int index)
Adds the specified component to this container at the given position.
remove
public void remove(int index)
Removes the component, specified by index, from this container.
remove
public void remove(Component comp)
Removes the specified component from this container.
removeAll
public void removeAll()
Removes all the components from this container.
getLayout
public LayoutManager getLayout()
Gets the layout manager for this container.
setLayout
public void setLayout(LayoutManager mgr)
Sets the layout manager for this container.
setFont
public void setFont(Font f)
Sets the font of this container.
paint
public void paint(Graphics g)
Paints the container.
paintComponents
public void paintComponents(Graphics g)
Paints each of the components in this container.
Class AccessibleContext
javax.accessibility
Class AccessibleContext
java.lang.Object
javax.accessibility.AccessibleContext
AccessibleContext represents the minimum information all accessible objects return.
This information includes:
• the accessible name, description, role, and state of the object,
• information about its parent and children.
• methods for obtaining more specific accessibility information about a component.
Constructor Summary
AccessibleContext()
Method Detail (quelques unes …).
getAccessibleName
public String getAccessibleName()
Gets the accessibleName property of this object.
The accessibleName property of an object is a localized String that designates the purpose of the object.
For example, the accessibleName property of a label might be the text of the label
setAccessibleName
public void setAccessibleName(String s)
Sets the localized accessible name of this object.
Classe Frame
Une Frame est une fenêtre qui a un titre (directement lisible) et une bordure . La Frame c’est “la page” .
Par défaut une « frame » est invisible .
Pour l’avoir visible, il faut donc ne pas oublier de faire : maframe.setVisible(true) ;
Tous les autres éléments de la frame sont « par défaut » visibles pour autant que la frame elle même soit visible (ils n’apparaissent pas « en fantômes ») en survolant une frame qui elle n’existerait pas .
Mais il est tout à fait possible d’en cacher quelques uns via la commande Monbouton1.setVisible(false) ;.
Les différents éléments graphiques peuvent se mettre dans la frame via différents Layout Manager .
Par défaut, c’est le Layout Manager BorderLayout qui est utilisé, avec comme premier et surprenant effet, que le bouton qu’on ajoute en premier va occuper toute la frame ….
Une frame est un bel exemple d’objet .
Il n’y a qu’à faire « new Frame » , et on a une page avec toutes ses fonctions . On ne s’en rend pas compte, mais il y a même dès l’origine un multithread ;
o
la frame se construit pendant le déroulement du programme ,et c’est normal .o mais elle se reconstruit aussi après un masquage partiel (déroulante qui s’ouvre puis se referme) ,ou un masquage total par une autre feuille.
Là ce n’est plus le thread « principal » (qui a agit et cessé d’agir),mais un thread permanent tant que dure la feuille .
Situation de départ créé par le thread principal .
La déroulante s’ouvre et crée un masquage partiel .
On ne voit jamais cette étape,mais elle existe pourtant : la déroulante c’est fermée,et elle laisse derrière elle un « trou » qui va se combler par le thread de raffraichissement permanent de telle sorte qu’immédiatement la page ressemble à ce qu’elle était au départ
setResizable
public void setResizable(boolean resizable)
Sets whether this frame is resizable by the user.
Parameters: resizable - true if this frame is resizable; false otherwise.
Ce qui donne : mafenetre.setResizable(false) ;
setTitle
public void setTitle(String title)
Sets the title for this frame to the specified string.
Parameters: title - the title to be displayed in the frame's border.
SetBonds
mafenetre.setBounds(1,1,260,260);
« mafenetre » sera dans l’angle supérieur gauche de l’écran (1,1) et aura 260 sur 260 .
Tout ce que l’on peut mettre dans une Frame …
Panel
Graphiquement, un Panel est une « sous fenêtre » . Un Panel n’a ni titre ni bordure .
Dans un Panel, on peut mettre d’autres Panels .
Le Panel n’entrera pas « tout seul » dans la fenêtre, il faudra l’y installer (cf infra) .
Un Panel c’est un « classe » Java ,au même titre que « point » et « frame » . Par défaut tout panel a le LayoutManager : FlowLayout .
Si on veut on peut lui donner un autre LayoutManager par exemple :GridLayout . La phrase est :
public Panel(LayoutManager layout)
Comment faire pour ajouter le panel à la frame ? .
On peut le faire de deux façons (mais la deuxième est « meilleure »):
1. soit avec « mafenetre.add monpanel» .
2. soit avec « mafenetre.setContentPane(monpanel); » Que se passe-t-il si il faut ajouter 2 panels ?
1. tout panel doit être ajouté, ça ne se fera pas tout seul .
2. si on site successivement plusieurs panels les uns en dessous des autres, seul le dernier sera en fin de course ajouté .
mafenetre.setContentPane(monpremierpanel);
mafenetre.setContentPane(mondeuxiemepanel);
En fin de course ici, seul le 2° panel sera ajouté …
Quand un panel est vide et sans dimension, il est tout petit . Dans ce cas-ci j’ai mis deux sous Panels dans un panel .
Je les ai colorié pour qu’on les repèrent l’un en bleu,et l’autre en rouge .
Contrairement à ce qu’on peut s’attendre, ils ne vont pas occuper à deux toute la place du panel dont ils dépendent .
En fait, ils n’occupent pas plus de place qu’un bouton ou autre …
Je leurs mets maintenant à chacun quelque chose « dedans » .
Barre des menus .
La « barre des menus » appartient à une frame, et non à un à un panel .
La Barre des menus : JMenuBar
Contient plusieurs menus : JMenu
Chacun des menus contient plusieurs items : JMenuItem Il faudra pour ces 3 objets différents 3 constructeurs différents .
Pour la créer effectivement, il faut deux étapes successives pour chaque sous élément : o Le créer réellement .
o Le fixer
1. à la JFrame pour le JMenuBar 2. à la JmenuBar pour le JMenu.
3. au JMenu pour le JMenuItem Syntaxe :
• Barre des menus :
JMenuBar mabarredesmenus = new JmenuBar() ; Maframe.setJMenuBar (mabarredesmenus);
• Gros Menus(1 par “gros menu”):
JMenu mongroschoixdemenus=new JMenu(“Tarés”);
Jmenu mongroschoixdemenus=new JMenu(« Enfoirés ») ; mabarredesmenus.add(tarés) // sans les guillemets.
mabarredesmenus.add(enfoirés) Sous menus .
JMenuItem unpeutaré=newJMenu(« un peu taré ») ;
JMenuItem moyenementtaré=newJMenu(« moyennement taré ») ; JMenuItem forttaré=newJMenu(« fort taré ») ;
Tarés.add(un peu taré)
Tarés.add(moyennement taré) Tarés.add(fort taré)
Barre des menus .
On distingue successivement :
o La seule « barre des menus » : JMenuBar o Les titres de choix des menus : JMenu o Les sous choix du menu : JMenuItem
Exemple : on veut choisir différentes couleurs o Frame = mapremiereframe
o JMenuBar = mapremierebarredesmenus o JMenu = monpremeirchoixdemenus
o JMenuItem = monpremieritemdemenus,mondeuxiemeitemdemenus ….
Syntaxe :
o La syntaxe de liaison de la JMenuBar à la fenêtre se fait par « set » . o La syntaxe de liaisons des autres composants se fait par « add ».
Ce qui donne :
JMenuBar mapremeirebarredesmenus = new JmenuBar ( ) ; Mapremiereframe.set.JmenuBar(mapremierebarredesmenus);
JMenu monpremierchoixdemenus = new JMenu (“couleurs’’) Mapremierebarredesmenus.add.(couleur
Label
Le Label, c’est un texte et un arrière plan , rien de plus .
Le texte est non modifiable par l’utilisateur, mais bien par le programme .
On pourrait par exemple imaginer un programme affichant tout un « Label » et un bouton qui, si on le coche donne la suite du texte en effaçant le premier « Label » et en y mettant un deuxième …
Par défaut, l’arrière plan du Label a la même couleur que le fond « normal »,mais on peut parfaitement la changer (dans notre exemple dans le seul but de marquer ses limites …) .
Syntaxe : a) Le créer :
JLabel monpremierlabel = new JLabel( « tu parles d’un Label à la con ») ; // bien vérifier les majuscules et les minuscules .
// bien vérifier que les textes dans « Eclipse » sont entourés par des guillemets supérieurs // et pas par des accolades comme dans word …
b)Le mettre dans le pannel :
lepremierpanneau.add (monpremierlabel) ;
c) modifier son arrière plan (pour voir ce que c’est….) . monpremierlabel.setbackground(Color.red);
//remarquons qu’il faut mettre “Color”
//remarquons qu’il faut mettre « .red » et pas de guillemets à red .
Utilisation « non prévue » du « Label » .
Un label avec « rien dedans » est un espace ,mais un espace vide qui a la couleur normale de l’environnement .
On peut s’en servir pour décaler des objets en remplissant une ligne « de vide »….
Exemple : Jlabel masque1 = new Jlabel ( ‘’ ‘’) ;
Autre utilisation « non prévue » :
On se sert des espaces de l’affichage pour la mise en page . Le texte visible à afficher est petit .
Mais le texte invisible (cad les espaces) peut prendre toute la ligne ….
Exemple : « Calculette »
Exemple de « label » classique: (le Label s’appelle ici « lepremierlabel » ).
Changer couleur de la police . lepremierlabel.setForeground(Color.red);
Changer couleur de l’arrière plan . lepremierlabel.setBackground(Color.cyan);
Changer de “font” Font mafont = new font («Dialog »,font.BOLD,30)
Le changement de “Font” se passe autrement : Il y a deux types de « font » :
o Les 5 « fonts » logiques ( SansSerif, Serif, Monospaced, Dialog, DialogInput) o L’infinité de « fonts » physiques.
Les 5 « Fonts »logiques ne font pas partie du « standard Word » … L’appel des 2 types de fonts est légèrement différent :
Font « logique » : Font objetconsidere = new Font (« lafontdesiree », le style, la taille) ; Font « Physique » : Font objetconsidere = new Font (« lafontdesiree ».style, Font.PLAIN, la taille) ;
Pour rappel,le « Style »,c’est : o Font.PLAIN « normal ».
o Font.BOLD « gras ».
Button
Un bouton existe sous 3 formes : neutre – armé – en train d’être utilisé .
Il y a en fait 3 images du même bouton qui sont stockées, et on utilise celle qu’il faut en fonction des « évènements » .
o setSelected(boolean) o setArmed(boolean) o setPressed(boolean)
Le fait d’appuyer sur un bouton crée un “actionevent” . L’actionEvent va envoyer deux sortes de messages:
o L’un au bouton lui même qui va changer d’aspect .
o L’autre aux différents programmes qui dépendent de cet évènement et qui sont collationnés dans un fichier ActionListener
ButtonGroup
Un button Group,ce n’est pas un ensemble de boutons repris dans un cadre pour « faire joli » comme par exemple dans une calculette où il y a un cadre « chiffres » et un autre
« opérations » .
Ici c’est un groupe de boutons dont 1 seul peut être « true » et tous les autres « false ».
Le cas usuel c’est les cases à boutons radios .
Très généralement même ,lors de l’ouverture une des cases est précochée comme « true » mais ce n’est pas obligatoire.
Checkbox .
Ce sont des boutons à cocher .
Il faut obligatoirement un libellé à côté du bouton .
Ce libellé est « obligatoire » ; ce n’est pas un « label » qu’on met « en + » … Si on ne le met pas, la syntaxe n’est pas bonne.
Tel quel,le bouton apparaît avec la possibilité tout à fait effective d’être coché . Mais sans instruction, le cochage ne sert évidement « à rien » ….
Syntaxe :
//D’abord il faut le créer :
JCheckBox moncheckbox = new JCheckBox(« cliquez ici bande de tarés ») ; //Ensuite il faudra le fixer dans le panel :
Monpremierpanneau.add(monchecbox) ;
Que peut vouloir dire une case cochée ? Deux choses :
o Soit qu’on veut quelque chose : « Je veux partir » cad une action
o Soit qu’on signale quelque chose : « J’ai mon ticket » cad un renseignement Bref un bouton coché peut soit signaler :
o Une action . o Un item .
Pour rendre le cochage utile ,il faudra lui adjoindre un « écouteur » approprié cad : o Soit un ActionListener.
o Soit un ItemListener
RadioButton
C’est du même genre que le Checkbox, mais néanmoins différent : o On peut cocher autant de Checkbox que l’on veut . o Mais on ne peut cocher qu’un seul RadioButton .
A l’état natif cependant le RadioButton se comporte exactement comme le CheckBox ;on peut en cocher autant qu’on veut .
Si on veut ne pouvoir en cocher qu’un seul du groupe, il faut définir un « ButtonGroup . Un Buttongroup est un groupe de boutons .
Ce n’est absolument pas « visible » sur l’écran . Ca ne fait pas un cadre, ou qq chose du genre .
Les boutons sont bien évidement généralement côte à côte, (puisque la plupart du temps il s’agit d’un choix qu’on demande de faire) mais rien ne l’oblige .
Tout comme le CheckBox, le RadioButton a obligatoirement un texte associé sinon ça ne marche pas .
//création :
JRadioButton monpremierradiobutton = new JRadioButton (« T’es né comme çà ?») ;
JRadioButton mondeuxièmeradiobutton = new JRadioButton (« Ou on t’as marché dessus ?) ; //installation :
monpremierpanneau.add(monpremierradiobutton) ; monpremierpanneau.add(mondeuxiemeradiobutton) ;
//Bon, maintenant il faut l’associer à un ButtonGroup (qu’il faut encore créer) … //d’abord le créer :
ButtonGroup monbuttongroup = nex ButtonGroup ( ) ; //puis y associer les 2 boutons .
monbuttongroup.add(monpremierradiobutton) ; monbuttongroup.add(mondeuxiemeradiobutton) ;
//Curieusement,il ne faut pas mettre le ButtonGroup dans le Panel .
On s’assure que ça marche bien en cliquant sur l’un puis l’autre,en aucun cas deux
« RadioButton » ne peuvent être validés en même temps .
Textfield.
C’est un « champ de texte » qui ne marche que sur une et une seule ligne .
Il faut obligatoirement indiquer sa taille maximum lors de sa création (en nombre de caractères autorisés) ; de cela dépend sa taille d’affichage minimum .
Si on dépasse le nombre de caractères autorisés, il n’apparaît pas alors une barre de
défilement ,mais tout le texte est néanmoins repris comme on peut le voir en faisant défiler via le clavier le texte horizontalement à droite .
et si on fait aller le défilement horizontal Et à la fin du texte apparaîtra le « prompt de frappe » e
Textfield apparaît « tel quel »,sans explication ,
alors que les RadioButtons et les CheckBox apparaissent obligatoirement avec un texte d’accompagnement .
Ici, si on veut un texte d’accompagnement, il faut mettre un Label « en plus » . Syntaxe :
JTextField monpremiertextfield = new JTextField(«ce qu’on veut éventuellement, cad assez rarement mettre “avant” le prompt” ; dans cet exemple : ‘’ben letextfield,c’est ici qu’il faudra le mettre …”,15 (le nombre de caractères que l’on veut qui soient visibles « d’emblée …»);
Monpremierpanneau add.(monpremiertextfield) ; Comment se servir du Champ de texte ?
La plupart du temps, appuyer sur le bouton de validation .le champ de texte fonctionne avec un bouton de validation ;
o quand le champ de texte est écrit, ça ne change « rien » .
o pour que quelque chose change (cad que l’info du champ de texte soit reconnue comme telle),il faut appuyer sur le bouton de validation .
Comment l’utilisateur peut-il modifier un « champ de texte » ? La première idée est qu’il ne peut le modifier « que » via le clavier .
C’est tout à fait faux ; il peut aussi le modifier via la souris par « copier-coller » … Les différentes opérations possibles sur un champ de texte sont :
• insertUpdate
• removeUpdate
• changedUpdate
Contenu du Champ de texte :
Ce qui est intéressant de savoir, c’est ce que l’utilisateur a mis dans le champ de texte . La méthode à employer est « monpremiertextfield.getText() ;
Et comme ce sera « une chaîne,ça va donner :
String machainereponse1 = monpremierTextField.getText ( ) ; Mais quand est ce qu’il faut savoir quel est le contenu ?
o Soit au fur et à mesure de la frappe ;
o Soit lorsqu’un évènement se produit ,et la plupart du temps, c’est quand il y a un clic sur le bouton de validation du texte .
Dans une calculette, c’est quand il y aura l’appel d’une fonction ( +,-, x, /) ou du sigle
« = » .
ListBox et ComboBox .
ListBox ComboBox
ListBox parce que ce n’est qu’une liste ComboBox, parce que c’est deux choses à la fois : un champ de texte et en plus une liste . Il n’y a pas de mode « activé » ou « non
activé » .
Il y a un mode « activé » et un mode « non activé » .
Toute la liste est apparente d’emblée, que ce soit avec ou sans ascenseur ..
De façon non activée, un seul élément de la liste est visible.
Quand elle est activée, tous les éléments deviennent visibles, avec ou sans ascenseurs . On peut sélectionner plusieurs valeurs . On ne peut sélectionner qu’une seule valeur . Pour que « ça tourne »,il faut :
ListSelectionListener
Pour que « çà tourne »,il faut : ItemListener
Dans les 2 cas, les résultats, à savoir l’item choisi revient sous forme d’objet . Or ce que nous voulons, c’est du texte .
Il faudra donc transformer l’objet en texte .
ListBox ComboBox
Object
