1. Surveillance des événements
Code de test 1:
package cn.javastudy.summary; import java.awt. *; import java.awt.event. *; public class TestTextField {public static void main (String args []) {new MyFrameTextField (); }} class MyFrameTextField étend la trame {MyFrameTextField () {TextField tf = new TextField (); ajouter (tf); tf.addactionListener (new monitor3 ()); tf.setEchochar ('*'); / * * Cette méthode setEchochar () consiste à définir les caractères affichés lors de la saisie dans la zone de texte. Ici, il est défini sur *, afin que tout contenu d'entrée soit affiché comme *, mais vous pouvez toujours voir le contenu d'entrée lors de l'impression * / setVisible (true); paquet(); }} classe moniteur3 implémente ActionListener {/ * * Toutes les méthodes de l'interface sont publiques (publiques) * Donc, lors de la copie de void ActionPerformed (ActionEvent E) à partir du document API, vous devez ajouter public devant le void * / public void ActionPerformed (ActionEvent e) {/ * Les informations pertinentes de l'événement sont encapsulées dans l'objet e. Les informations pertinentes de l'événement peuvent être obtenues via les méthodes pertinentes de l'objet e * / TextField tf = (TextField) e.getsource (); / * * getource () est d'obtenir la source d'événement. Remarque: Lorsque vous obtenez cette source d'événement, * Traitez-le comme la classe parent de TextField. La définition de la méthode getSource () est: "public objet getSource ()" La valeur de retour est un objet d'objet, * vous devez donc le lancer dans un objet de type textField * Si vous souhaitez accéder à l'objet source d'événement d'une autre classe dans une classe, vous pouvez utiliser la méthode getSource () * / System.out.println (tf.getText ()); // tf.gettext () tf.seTText (""); // efface le contenu dans la zone de texte}} Code de test 2:
package cn.javastudy.summary; import java.awt. *; import java.awt.event. *; public class testActionEvent2 {public static void main (String args []) {frame f = new frame ("testActionEvent"); Bouton btn1 = nouveau bouton ("start"); Bouton btn2 = nouveau bouton ("stop"); Monitor2 m2 = new monitor2 (); // créer l'objet d'écoute btn1.addactionListener (M2); / * Un objet d'écoute écoute les actions de deux boutons en même temps * / btn2.addactionListener (M2); BTN2.SetActionCommand ("Gameover"); // Définissez les informations de retour après l'exécution de la commande Click de BTN2 F.ADD (BTN1, BorderLayout.North); F.ADD (BTN2, BorderLayout.Center); f.pack (); f.setVisible (true); }} class Monitor2 implémente ActionListener {public void ActionPerformed (ActionEvent e) {System.out.println ("Un bouton a été appuyé sur," + "Les informations relatives sont: / n" + e.getActionCommand ()); / * Utilisez l'objet d'écoute renvoyé E pour appeler la méthode getActionCommand () pour obtenir les informations de retour après que les deux boutons exécutent la commande click. Selon les différentes informations de retour, quel bouton est l'opération actuelle. BTN1 n'utilise pas la méthode setActionCommand () à définir, donc les informations renvoyées par BTN1 sont le texte affiché sur le bouton * /}}2. Surveillance des événements TextField
Code de test:
package cn.javastudy.summary; import java.awt. *; import java.awt.event. *; public class TestTextField {public static void main (String args []) {new MyFrameTextField (); }} class MyFrameTextField étend la trame {MyFrameTextField () {TextField tf = new TextField (); ajouter (tf); tf.addactionListener (new monitor3 ()); tf.setEchochar ('*'); / * * Cette méthode setEchochar () consiste à définir les caractères affichés lors de la saisie dans la zone de texte. Ici, il est défini sur *, afin que tout contenu d'entrée soit affiché comme *, mais vous pouvez toujours voir le contenu d'entrée lors de l'impression * / setVisible (true); paquet(); }} classe moniteur3 implémente ActionListener {/ * * Toutes les méthodes de l'interface sont publiques (publiques) * Donc, lors de la copie de void ActionPerformed (ActionEvent E) à partir du document API, vous devez ajouter public devant le void * / public void ActionPerformed (ActionEvent e) {/ * Les informations pertinentes de l'événement sont encapsulées dans l'objet e. Les informations pertinentes de l'événement peuvent être obtenues via les méthodes pertinentes de l'objet e * / TextField tf = (TextField) e.getsource (); / * * getource () est d'obtenir la source d'événement. Remarque: Lorsque vous obtenez cette source d'événement, * Traitez-le comme la classe parent de TextField. La définition de la méthode getSource () est: "public objet getSource ()" La valeur de retour est un objet d'objet, * vous devez donc le lancer dans un objet de type textField * Si vous souhaitez accéder à l'objet source d'événement d'une autre classe dans une classe, vous pouvez utiliser la méthode getSource () * / System.out.println (tf.getText ()); // tf.gettext () tf.seTText (""); // efface le contenu dans la zone de texte}} Implémentation d'une calculatrice simple à l'aide de la classe TextField
package cn.javastudy.summary; import java.awt. *; import java.awt.event. *; public class testmath {public static void main (String args []) {new tfframe (); }} / * Voici principalement pour compléter la disposition des éléments de la calculatrice * / class Tfframe étend le trame {tfframe () {/ * * Créer 3 zones de texte et spécifier leurs tailles initiales à 10 caractères et 15 caractères respectivement. Voici une autre méthode de construction de la classe TextField Public TextField (int colonnes) * / TextField num1 = new TextField (10); TextField num2 = new TextField (10); TextField num3 = new TextField (15); / * Créez un bouton de signe égal * / bouton btnequal = new Button ("="); btnequal.addactionListener (new myMonitor (num1, num2, num3)); / * Ajoutez un écouteur au bouton Sign Egal Sign afin qu'un événement de réponse se produise après avoir cliqué sur le bouton * / Label LblPlus = new Label ("+"); / * "+" est un texte statique, alors utilisez la classe d'étiquette pour créer un objet texte statique * / setLayout (new FlowLayout ()); / * Modifiez la mise en page de trame de BorderLayout par défaut sur la mise en page FlowLayout * / Add (num1); ajouter (lblPlus); ajouter (num2); ajouter (btnequal); ajouter (num3); paquet(); setVisible (true); }} classe MyMonitor implémente ActionListener {TextField num1, num2, num3; / * * Afin de permettre à l'écoute des boutons de fonctionner sur des zones de texte, * Par conséquent, trois objets TextField dans la classe personnalisée MyMonitor sont définis dans num1, num2, num3, * Il définit également une méthode de constructeur de la classe MyMonitor. Cette méthode de constructeur a trois paramètres de type TextField *, est utilisé pour recevoir trois paramètres de type TextField passés de la classe Tfframe * puis attribuez les trois paramètres reçus du type de champ textuel aux trois paramètres du type TextField déclaré dans cette classe. Puis procédé à Num1, num2, num3 dans la méthode ActionPerformed () * / public myMonitor (TextField num1, textfield num2, textfield num3) {this.num1 = num1; this.num2 = num2; this.num3 = num3; } public void ActionPerformed (ActionEvent e) {/ * Les informations pertinentes de l'événement sont encapsulées dans l'objet e. Les informations pertinentes de l'événement peuvent être obtenues via les méthodes pertinentes de l'objet E * / int n1 = Integer.ParseInt (num1.getText ()); / * Num1 Object appelle la méthode getText () pour obtenir la chaîne de texte affichée par lui-même * / int n2 = Integer.parseint (num2.getTex (n1 + n2)); / * l'objet Num3 appelle la méthode setText () pour définir son propre texte d'affichage * / num1.setText (""); / * Une fois le calcul terminé, effacez le contenu des boîtes de texte NUM1 et NUM2 * / num2.setText (""); // num3.setText (string.valueof ((n1 + n2))); / * Lorsque les chaînes sont connectées à tout type de données en utilisant "+", la chaîne doit être une chaîne. * Voici une chaîne vide et un numéro de type int, de sorte que le numéro de type int obtenu par (n1 + n2) peut être directement converti en chaîne. * Il s'agit d'une petite astuce pour convertir d'autres types de données de base en chaînes. * Vous pouvez également utiliser "string.valueof ((n1 + n2))" pour convertir la somme de (n1 + n2) en une chaîne * /}} Utilisation classique dans Java: tenir des références à une autre classe dans une classe
package cn.javastudy.summary; import java.awt. *; import java.awt.event. *; public class testmath1 {public static void main (string args []) {new ttmyframe (). launchFrame (); / * Créez l'objet TTMyFrame et appelez la méthode lauchframe () pour afficher le formulaire de calculatrice * /}} / * Faites de l'interface de forme de la calculatrice * / class TtMyFrame étend la trame {/ * encapsuler le code concevant le formulaire de calculatrice en une méthode * / textfield num1, num2, num3; public void LaunchFrame () {num1 = new TextField (10); num2 = new TextField (15); num3 = new TextField (15); Label lblPlus = new Label ("+"); Bouton btnequal = nouveau bouton ("="); btnequal.addactionListener (new myMonitorBtnequal (this)); setLayout (new FlowLayout ()); ajouter (num1); ajouter (lblPlus); ajouter (num2); ajouter (btnequal); ajouter (num3); paquet(); setVisible (true); }} / * * Ici, en obtenant une référence à la classe TTMYFRAME, puis en utilisant cette référence pour accéder aux variables membres dans la classe TTMyFrame * Cette approche est bien meilleure que la méthode précédente pour accéder directement aux variables des membres dans la classe TTMYFRAME, * Vous avez maintenant besoin d'accéder aux variables membres dans la classe TTMyframe, et vous pouvez directement accéder aux variables des membres dans la classe TTMyframe. * Cet objet de classe TTMYFRAME est comme une grande femme de ménage, et j'ai dit à la grande femme de ménage que je voulais accéder aux variables des membres de la classe TTMYFRAME, * La référence de la grande femme de ménage m'aidera à le trouver, et je n'ai plus besoin de le trouver moi-même. * Cette utilisation des références de maintien à une autre classe dans une classe est une utilisation très typique * Utilisez la référence obtenue pour accéder à tous les membres d'une autre classe dans une classe * / classe MyMonitorBtNequal implémente ActionListener {TTMyFrame ttmf = null; public myMonitorBtnequal (ttMyFrame ttmf) {this.ttmf = ttmf; } public void ActionPerformed (ActionEvent e) {int n1 = Integer.ParseInt (ttmf.num1.getText ()); int n2 = Integer.ParseInt (ttmf.num2.getText ()); ttmf.num3.setText ("" + (n1 + n2)); ttmf.num1.setText (""); ttmf.num2.setText (""); }}Les résultats de l'opération sont les suivants:
Iii. Classe interne
Exemples de classes internes:
package cn.javastudy.summary; import java.awt. *; import java.awt.event. *; public class testmath3 {public static void main (String args []) {new myMathFrame (). LaunchFrame (); }} class MyMathFrame étend le trame {TextField num1, num2, num3; public void LaunchFrame () {num1 = new TextField (10); num2 = new TextField (15); num3 = new TextField (15); Label lblPlus = new Label ("+"); Bouton btnequal = nouveau bouton ("="); btnequal.addactionListener (new myMonitor ()); setLayout (new FlowLayout ()); ajouter (num1); ajouter (lblPlus); ajouter (num2); ajouter (btnequal); ajouter (num3); paquet(); setVisible (true); } / * * Cette classe MyMonitor est une classe intérieure, qui définit la classe MyFrame dans la classe MyFrame appelée la classe de wrapper * / / * * Les avantages de l'utilisation de classes intérieures: * Le premier avantage énorme est qu'il peut accéder à toutes les variables et méthodes de membre de la classe externe (c'est-à-dire, la classe de wrapper de la classe intérie (classe externe), * Vous pouvez y accéder directement dans MyMonitor (classe intérieure) * Ceci est équivalent à l'objet de classe interne ayant une référence à l'objet de classe externe par défaut lors de la création d'un objet de classe externe * / classe privée MyMonitor implémente ActionListener (public void ActionPerformed (Actionevent e) {int n1 = Integer.parentInt (num1.getText (Actionevent e); int n2 = Integer.ParseInt (num2.getText ()); num3.setText ("" + (n1 + n2)); num1.setText (""); num2.setText (""); }}}Les énormes avantages des classes internes sont:
4. Graphiques
Code de test:
package cn.javastudy.summary; import java.awt. *; public class testpaint {public static void main (String args []) {new mypaint (). launchFrame (); / * La méthode de la peinture (graphiques G) n'est pas affichée dans la méthode principale (), mais après avoir créé le formulaire de trame, vous pouvez voir que les cercles et les rectangles sont dessinés sur le formulaire de trame. En effet, la méthode peinture () est une méthode spéciale. Il appellera automatiquement implicitement lors de la création du formulaire de trame. Lorsque nous minimions le formulaire de trame et l'ouvrons à nouveau, nous appellerons à nouveau la méthode peinture () et dessinerons les cercles et les rectangles sur le formulaire de trame. Autrement dit, chaque fois que nous devons repeindre le formulaire de trame, la méthode peinture () sera automatiquement appelée * /}} class MyPaint étend le trame {public void launchFrame () {setBounds (200,200,640,480); setVisible (true); } public void peinture (graphiques g) {/ * peinture (graphiques g) a un paramètre de type graphique g Nous pouvons traiter ce g comme un peintre, le peintre tient un pinceau dans sa main, et nous dessions les différentes images que nous voulons en réglant la couleur et la forme du pinceau * / * définir la couleur du pinceau * / g.setColor (couleur.red); G.Filloval (100,100,100,100); / * dessiner une ellipse solide * / g.setColor (Color.Green); G.Fillrect (150 200,200); / * dessiner un rectangle solide * // * Les deux lignes de code ci-dessous sont écrites pour de bonnes habitudes de programmation dans les programmes d'écriture. Vous devez maintenant restaurer la couleur initiale du pinceau, ce qui équivaut au nettoyage de la couleur sur le pinceau une fois que le peintre a utilisé le pinceau * / couleur c = g.getColor (); g.setColor (c); }}Résultats en cours:
5. Adaptateur d'événements de souris
Code de test:
package cn.galc.test; import java.awt. *; import java.awt.event. *; import java.util. *; public class myMousEadapter {public static void main (string args []) {new MyFrame ("drawing ..."); }} class MyFrame étend le trame {ArrayList Points = NULL; MyFrame (String S) {super (s); points = new ArrayList (); setLayout (null); Setbounds (300 300 400 300); this.setbackground (nouvelle couleur (204 204 255)); setVisible (true); this.AddMouseListener (new Monitor ()); } public void peinture (graphiques g) {iterator i = point.Itator (); while (i.hasnext ()) {point p = (point) i.next (); g.setColor (Color.Blue); G.Filloval (PX, PY, 10,10); }} public void addPoint (point p) {Point.Add (p); }} Le moniteur de classe étend Mouseadapter {public void Mousdressress (MouseEvent e) {myFrame f = (myFrame) e.getsource (); f.addpoint (nouveau point (e.getx (), e.gety ())); f.repaint (); }}6. Événement Windows
Code de test:
package cn.galc.test; import java.awt. *; import java.awt.event. *; public class TestWindowClose {public static void main (String args []) {new WindowFrame ("close windowframe"); }} class WindowFrame étend le trame {public windowFrame (String s) {super (s); Setbounds (200 200 400,300); setLayout (null); Setbackground (nouvelle couleur (204 204 255)); setVisible (true); this.addWindowListener(new WindowMonitor());/* Listen to the actions of this form, encapsulate all the action information into an object and pass it into the listening class*/ this.addWindowListener( /*Define a class in a method, this class is called a local class, also called anonymous internal class. The code here is very similar to the body of a class, but this class has no name, so it is called anonymous class here to use this Classe anonyme en tant que classe WindowAdapter. System.exit (-1);}}); } / * La classe d'écoute est également définie comme une classe interne * / class WindowMonitor étend la classe WindowAdapter {/ * WindowAdapter (Adaptateur de fenêtre) implémente l'interface d'écoute WindowListener. Réécrit toutes les méthodes de l'interface WindowListener. Si vous utilisez directement la classe WindowMonitor personnalisée pour implémenter directement l'interface WindowListener, vous devez réécrire toutes les méthodes de l'interface WindowListener. Mais maintenant, il vous suffit d'utiliser l'une de ces méthodes. Par conséquent, vous pouvez hériter d'une sous-classe de l'interface d'écoute WindowListener et réécrire la méthode que vous devez utiliser dans cette sous-classe. Cette méthode est beaucoup plus simple et plus pratique que d'implémenter directement l'interface d'écoute WindowListener. * / * Réécriture la méthode WindowClosing (WindowEvent E) qui doit être utilisée * // * public void windowClosing (WindowEvent e) {setVisible (false); / * définir le formulaire pour ne pas afficher, et le formulaire est fermé * / System.exit (0); / * Exit normalement * /}}}7. Événement de réponse au clavier - KeyEvent
Code de test:
package cn.galc.test; import java.awt. *; import java.awt.event. *; public class testKevent {public static void main (String args []) {new Keyframe ("Event de réponse au clavier"); }} class Keyframe étend le trame {public keyframe (String s) {super (s); Setbounds (200 200 400,300); setLayout (null); setVisible (true); addKeyListener (new KeyMonitor ()); } / * Définissez la classe d'écoute du clavier personnalisé comme une classe interne. Cette classe d'écoute hérite de la classe KeyAdapter de l'adaptateur de clavier. Hérite de la classe KeyAdapter. Pour être concis et pratique, il vous suffit de réécrire les méthodes que vous devez utiliser. Cette méthode est plus simple et plus pratique que d'implémenter directement l'interface KeyListener. Si vous implémentez directement l'interface KeyListener, vous devez réécrire toutes les méthodes de l'interface KeyListener, mais une seule méthode est vraiment utilisée. De cette façon, la réécriture d'autres méthodes mais ne pas les utiliser fera inévitablement un travail inutile * / class KeyMonitor étend KeyAdapter {public void keyPressed (keyEvent e) {int keyCode = e.getKeyCode (); / * Utilisez la méthode getkeycode () pour obtenir le code virtuel de la touche * / / * Si le code virtuel de la touche obtenue est égal au code virtuel de la touche UP, cela signifie que la touche actuellement appuyée est la touche de touche UP. Chaque clé du clavier correspond à un code virtuel. Ces codes virtuels sont définis comme des constantes statiques dans la classe KeyEvent. Par conséquent, vous pouvez utiliser la forme de "Class Name.Static Nom Constante" pour accéder à ces constantes statiques * / if (keycode == keyEvent.vk_up) {System.out.println ("vous appuyez sur la touche UP"); }}}} / * Le clavier gère les événements comme ceci: chaque clé correspond à un code virtuel. Lorsqu'une certaine touche est appuyée, le système trouvera le code virtuel correspondant à cette touche pour déterminer quelle touche est actuellement enfoncée * /Grâce à cet article, j'ai appris avec vous la programmation de GUI. J'espère que vous aurez une compréhension plus complète de la programmation GUI. Il y a plus que cela à propos de la programmation GUI, et vous devez continuer à apprendre.