1. Monitoreo de eventos
Código de prueba 1:
paquete cn.javastudy.summary; import java.awt.*; import java.awt.event.*; public class testTextField {public static void main (string args []) {new MyFrameTextField (); }} clase MyFramEtextField extiende el marco {myFramEtextField () {TextField tf = new TextField (); agregar (tf); tf.addactionListener (nuevo monitor3 ()); tf.setecharchar ('*'); / * * Este método setecar () es establecer los caracteres que se muestran al ingresar en el cuadro de texto. Aquí está configurado en *, para que cualquier contenido de entrada se muestre como *, pero aún puede ver el contenido de entrada al imprimir */ setVisible (true); embalar(); }} class Monitor3 implementa ActionListener { / * * Todos los métodos en la interfaz son públicos (públicos) * Entonces, al copiar Void ActionPerformed (ActionEvent E) Del documento API, debe agregar público frente a void * /public void Actionperformed (ActionEvent E) { / * La información relevante del evento se resume en el objeto E. La información relevante del evento se puede obtener a través de los métodos relevantes de objeto e*/ textfield tf = (textfield) e.getSource (); / * * El método getSource () es obtener la fuente del evento. Nota: Cuando obtienes esta fuente de evento, * trátelo como la clase principal de Textfield. The definition of the getSource() method is: "public Object getSource()" return value is an Object object, * So you must cast it to an object of type TextField* If you want to access the event source object of another class in one class, you can use the getSource() method */ System.out.println(tf.getText());// tf.getText() is to get the content in the text box tf.setText (""); // Borrar el contenido en el cuadro de texto}} Código de prueba 2:
paquete cn.javastudy.summary; import java.awt.*; import java.awt.event.*; public class testActionEvent2 {public static void main (string args []) {frame f = new Frame ("testActionEvent"); Botón btn1 = botón nuevo ("inicio"); Botón btn2 = botón nuevo ("parar"); Monitor2 m2 = new Monitor2 (); // Cree el objeto de escucha BTN1.AddactionListener (M2); /*Un objeto de escucha escucha las acciones de dos botones al mismo tiempo*/ btn2.AddactionListener (M2); btn2.SetActionCommand ("GameOver"); // Establezca la información de retorno después de ejecutar el comando Click de BTN2 F.Add (BTN1, BorderLayout.north); F.Add (BTN2, BorderLayout.Center); F.Pack (); F.SetVisible (verdadero); }} class Monitor2 implementa ActionListener {public void ActionPerformed (ActionEvent E) {System.out.println ("Se ha presionado un botón,"+"La información relativa es:/n"+e.getActionCommand ()); /* Use el objeto de escucha devuelto E para llamar al método getActionCommand () para obtener la información de retorno después de que los dos botones ejecuten el comando de clic. De acuerdo con la información de diferentes devoluciones, qué botón es la operación actual. BTN1 no utiliza el método setActionCommand () para establecer, por lo que la información devuelta por BTN1 es el texto que se muestra en el botón*/}}2. Monitoreo de eventos de Textfield
Código de prueba:
paquete cn.javastudy.summary; import java.awt.*; import java.awt.event.*; public class testTextField {public static void main (string args []) {new MyFrameTextField (); }} clase MyFramEtextField extiende el marco {myFramEtextField () {TextField tf = new TextField (); agregar (tf); tf.addactionListener (nuevo monitor3 ()); tf.setecharchar ('*'); / * * Este método setecar () es establecer los caracteres que se muestran al ingresar en el cuadro de texto. Aquí está configurado en *, para que cualquier contenido de entrada se muestre como *, pero aún puede ver el contenido de entrada al imprimir */ setVisible (true); embalar(); }} class Monitor3 implementa ActionListener { / * * Todos los métodos en la interfaz son públicos (públicos) * Entonces, al copiar Void ActionPerformed (ActionEvent E) Del documento API, debe agregar público frente a void * /public void Actionperformed (ActionEvent E) { / * La información relevante del evento se resume en el objeto E. La información relevante del evento se puede obtener a través de los métodos relevantes de objeto e*/ textfield tf = (textfield) e.getSource (); / * * El método getSource () es obtener la fuente del evento. Nota: Cuando obtienes esta fuente de evento, * trátelo como la clase principal de Textfield. The definition of the getSource() method is: "public Object getSource()" return value is an Object object, * So you must cast it to an object of type TextField* If you want to access the event source object of another class in one class, you can use the getSource() method */ System.out.println(tf.getText());// tf.getText() is to get the content in the text box tf.setText (""); // Borrar el contenido en el cuadro de texto}} Implementación de una calculadora simple usando la clase TextField
paquete cn.javastudy.summary; import java.awt.*; import java.awt.event.*; public class testMath {public static void main (string args []) {new tffRame (); }}/* Aquí está principalmente para completar el diseño de los elementos de la calculadora*/class tfframe extiende el marco {tfframe () {/** Crear 3 cuadros de texto y especificar que sus tamaños iniciales son 10 caracteres y 15 caracteres respectivamente. Aquí hay otro método de construcción de TextField Class Public Textfield (int columnas) */ TextField num1 = new TextField (10); TextField num2 = new TextField (10); TextField num3 = new TextField (15); /* Crear un botón de signo igual*/ botón btNequal = nuevo botón ("="); btnequal.addactionListener (nuevo mymonitor (num1, num2, num3)); /* Agregue un oyente al botón de signo igual para que ocurra un evento de respuesta después de hacer clic en el botón*/ etiqueta lblplus = nueva etiqueta ("+"); /* "+" es un texto estático, así que use la clase de etiqueta para crear un objeto de texto estático*/ setLayout (new FlowLayout ()); /* Cambie el diseño predeterminado de frame borderLayout al diseño de FlowLayout*/ add (num1); agregar (lblplus); agregar (num2); agregar (btNequal); agregar (num3); embalar(); setVisible (verdadero); }} clase MyMonitor implementa ActionListener {Textfield num1, num2, num3; / * * Para habilitar la escucha de botones para funcionar en cuadros de texto, * por lo tanto, tres objetos de campo de texto en la clase personalizada MyMonitor se definen en Num1, Num2, Num3, * También define un método de constructor de la clase MyMonitor. Este método de constructor tiene tres parámetros de tipo TextField, * se usa para recibir tres parámetros de tipo TextField pasados de la clase TFFRAME * y luego asigna los tres parámetros recibidos del tipo TextField a los tres parámetros del tipo de TextField declarados en esta clase. Luego procese num1, num2, num3 en el método ActionPerformed () */ public MyMonitor (TextField Num1, TextField Num2, TextField Num3) {this.num1 = num1; this.num2 = num2; this.num3 = num3; } public void ActionPerformed (ActionEvent E) { /* La información relevante del evento se encapsula en el objeto e. La información relevante del evento se puede obtener a través de los métodos relevantes de objeto e*/ int n1 = integer.parseInt (num1.gettext ());/*num1 Object llama al método getText () para obtener la cadena de texto mostrada por sí mismo*/ int n2 = Integer.ParseInt (num2.getText ());/*num2 Object llama el método getText () al método de texto a la cadena de texto* num3.settext ("" + (n1 + n2));/* num3 objeto llama al método settext () para establecer su propio texto de pantalla*/ num1.settext (""); / * Después de completar el cálculo, borre el contenido de los cuadros de texto num1 y num2 */ num2.setText (""); // num3.setText (string.ValueOf ((n1+n2))); /* Cuando las cadenas están conectadas con cualquier tipo de datos usando "+", la cadena debe ser una cadena. * Aquí hay una cadena vacía y un número de tipo int, de modo que el número de tipo int obtenido por (N1+N2) se puede convertir directamente en una cadena. * Este es un pequeño truco para convertir otros tipos de datos básicos en cadenas. * También puede usar "String.ValueOf ((N1+N2))" para convertir la suma de (N1+N2) en una cadena */}} Uso clásico en Java: celebrando referencias a otra clase en una clase
paquete cn.javastudy.summary; import java.awt.*; import java.awt.event.*; public class testMath1 {public static void main (string args []) {new ttmyframe (). LaunchFrame (); /* Crear el objeto ttmyFrame y llamar al método LauchFrame () para mostrar el formulario de calculadora*/}}/* Convierta la interfaz de formulario de la calculadora*/class ttmyFrame extiende la marco {/* encapsula el código que diseña el formulario de calculadora en un método*/textield num1, num2, num3; public void Launchframe () {num1 = new TextField (10); num2 = nuevo TextField (15); num3 = nuevo TextField (15); Etiqueta lblplus = nueva etiqueta ("+"); Botón btNequal = botón nuevo ("="); btnequal.addactionListener (new MyMonitorBtNequal (this)); setLayout (new FlowLayout ()); agregar (num1); agregar (lblplus); agregar (num2); agregar (btNequal); agregar (num3); embalar(); setVisible (verdadero); }}/ * * Aquí, obteniendo una referencia a la clase TTMYFrame, y luego utilizando esta referencia para acceder a las variables de miembro en la clase TTMYFrame * Este enfoque es mucho mejor que el método anterior para acceder directamente a las variables de miembro en la clase TTMYFRame, * Ahora necesita acceder a las variables de la Casosa de miembro del miembro. * Este objeto de clase TtmyFrame es como un gran ama de llaves, y le dije al gran ama de llaves que quiero acceder a las variables de los miembros en la clase TtmyFrame, * La referencia del gran ama de llaves me ayudará a encontrarla, y ya no necesito encontrarlo yo mismo. * Este uso de referencias de retención a otra clase en una clase es un uso muy típico* Use la referencia obtenida para acceder a todos los miembros de otra clase en una clase*/clase myMonitorBtNequal implementa 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 (""); }}Los resultados de la operación son los siguientes:
Iii. Clase interna
Ejemplos de clases internas:
paquete cn.javastudy.summary; import java.awt.*; import java.awt.event.*; public class testMath3 {public static void main (string args []) {new MyMathFrame (). LaunchFrame (); }} clase myMathFrame extiende el marco {TextField num1, num2, num3; public void Launchframe () {num1 = new TextField (10); num2 = nuevo TextField (15); num3 = nuevo TextField (15); Etiqueta lblplus = nueva etiqueta ("+"); Botón btNequal = botón nuevo ("="); btnequal.addactionListener (new MyMonitor ()); setLayout (new FlowLayout ()); agregar (num1); agregar (lblplus); agregar (num2); agregar (btNequal); agregar (num3); embalar(); setVisible (verdadero); } /** Esta clase de MyMonitor es una clase interna, que define la clase MyFrame en la clase MyFrame llamada la clase WRAPPER* / /** Los beneficios de usar clases internas:* El primer gran beneficio es que puede acceder a todas (clase externa),* puede acceder directamente a él en MyMonitor (clase interna)* Esto es equivalente al objeto de clase interna que tiene una referencia al objeto de clase externa de forma predeterminada cuando se crea un objeto de clase externa*/ clase privada MyMonitor implementa ActionListener {public void ActionPerformed (ActionEvent e) {int n1 = integer.parseint (num1.gettExt ()); int n2 = integer.parseInt (num2.gettext ()); num3.settext ("" + (n1 + n2)); num1.settext (""); num2.settext (""); }}}Los enormes beneficios de las clases internas son:
4. Gráficos
Código de prueba:
paquete cn.javastudy.summary; import java.awt.*; public class testPaint {public static void main (string args []) {new myPaint (). LaunchFrame (); /*El método Paint (Graphics g) no se muestra en el método Main (), pero después de crear la forma de marco, puede ver que los círculos y los rectángulos se dibujan en el formulario de cuadro. Esto se debe a que el método Paint () es un método especial. Automáticamente llamará implícitamente al crear el formulario de cuadro. Cuando minimicemos la forma del marco y la abra, volveremos a llamar al método Paint () y dibujaremos los círculos y rectángulos en la forma del marco. Es decir, cada vez que necesitamos volver a pintar el formulario de cuadro, el método Paint () se llamará automáticamente*/}} clase myPaint extiende el marco {public void Launchframe () {SetBounds (200,200,640,480); setVisible (verdadero); } public void Paint (Graphics g) { / *Paint (Graphics G) El método tiene un parámetro de tipo gráfico G. Podemos tratar este g como pintor, el pintor sostiene un cepillo en su mano, y dibujamos las diversas imágenes que queremos establecer el color y la forma del pincel * / / *establecer el color del pincel * / g.setcolor (color.red); G.Filloval (100,100,100,100);/*dibuja una elipse sólida*/ g.setColor (color.green); G.Fillrect (150,200,200);/*Dibuja un rectángulo sólido*//*Las dos líneas de código a continuación están escritas para buenos hábitos de programación en los programas de escritura. Ahora debe restaurar el color inicial del pincel, que es equivalente a limpiar el color en el cepillo después de que el pintor haya usado el cepillo*/ color c = g.getColor (); G.SetColor (C); }}Resultados de ejecución:
5. Adaptador de evento del mouse
Código de prueba:
paquete cn.galc.test; import java.awt.*; import java.awt.event.*; import java.util.*; clase pública myMouseadapter {public static void main (string args []) {new myFrame ("dibujo ..."); }} clase myFrame extiende marco {arrayList Points = null; Myframe (cadena s) {super (s); puntos = new ArrayList (); setLayout (nulo); SetBounds (300,300,400,300); this.setBackground (nuevo color (204,204,255)); setVisible (verdadero); this.addMousElistener (nuevo monitor ()); } public void Paint (Graphics G) {Iterator i = Points.Iterator (); while (i.hasnext ()) {punto p = (punto) I.Next (); G.SetColor (color.blue); G.Filloval (PX, PY, 10,10); }} public void addPoint (punto p) {puntos.add (p); }} El monitor de clase extiende Mouseadapter {public void mousePressed (mouseEvent e) {myFrame f = (myframe) e.getSource (); F.AddPoint (nuevo punto (e.getx (), e.gety ())); F.Repaint (); }}6. Evento de Windows
Código de prueba:
paquete cn.galc.test; import java.awt.*; import java.awt.event.*; public class testWindowClose {public static void main (string args []) {new Windowframe ("Cerrar Windowframe"); }} clase WindowFrame extiende marco {public Windowframe (String S) {super (s); SetBounds (200,200,400,300); setLayout (nulo); Sackbackground (nuevo color (204,204,255)); setVisible (verdadero); esto La clase como WindowAdapter Class. System.exit (-1); } /*La clase de escucha también se define como una clase interna* /class WindowMonitor extiende WindowAdapter { /*WindowAdapter (adaptador de ventana) implementa la interfaz de escucha WindowListener. Reescribe todos los métodos en la interfaz WindowListener. Si usa directamente la clase personalizada WindowMonitor para implementar directamente la interfaz WindowListener, debe reescribir todos los métodos en la interfaz WindowListener. Pero ahora solo necesita usar uno de estos métodos. Por lo tanto, puede heredar una subclase de la interfaz de escucha de WindowListener y reescribir el método que necesita usar en esta subclase. Este método es mucho más simple y más conveniente que implementar directamente la interfaz de escucha de WindowListener. */*Reescribe el método WindowClosing (WindowsEvent E) que debe usarse*//*public void WindowClosing (WindowsEvent e) {setVisible (false);/*Establezca el formulario en no mostrar, y el formulario está cerrado*/system.exit (0);/*Salir normalmente*/}}}7. Evento de respuesta del teclado - Keyvent
Código de prueba:
paquete cn.galc.test; import java.awt.*; import java.awt.event.*; public class testKeyEvent {public static void main (string args []) {new Keyframe ("Evento de respuesta de teclado"); }} Class Keyframe extiende el marco {public Keyframe (String S) {super (s); SetBounds (200,200,400,300); setLayout (nulo); setVisible (verdadero); addkeylistener (new KeyMonitor ()); } /*Defina la clase de escucha del teclado personalizado como una clase interna. Esta clase de escucha hereda de la clase de KeyAdapter del adaptador del teclado. Hereda de la clase KeyAdapter. Para ser conciso y conveniente, solo necesita reescribir los métodos que necesita usar. Este método es más simple y más conveniente que implementar directamente la interfaz KeyListener. Si implementa directamente la interfaz KeyListener, debe reescribir todos los métodos en la interfaz KeyListener, pero solo se usa realmente un método. De esta manera, la reescritura de otros métodos pero no usarlos inevitablemente hará un trabajo inútil*/ Class KeyMonitor extiende KeyAdapter {public void keyPressed (keyEvent e) {int keyCode = e.getKeyCode (); /*Use el método getKeyCode () para obtener el código virtual de la tecla* / /*Si el código virtual de la tecla obtenida es igual al código virtual de la tecla UP, significa que la tecla presionada actualmente es la tecla UPSEVENT.VK_UP significa que el código virtual de obtener la tecla UP. Cada tecla en el teclado corresponde a un código virtual. Estos códigos virtuales se definen como constantes estáticas en la clase Keyvent. Por lo tanto, puede usar la forma de "Nombre de clase. Nombre constante estatal" para acceder a estas constantes estáticas*/ if (keyCode == keyEvent.vk_up) {System.out.println ("Presione la tecla Up"); }}}}/*El teclado maneja eventos como este: cada tecla corresponde a un código virtual. Cuando se presiona una determinada tecla, el sistema encontrará el código virtual correspondiente a esta tecla para determinar qué tecla se presiona actualmente*/A través de este artículo, aprendí programación de GUI contigo. Espero que tengas una comprensión más completa de la programación de GUI. Hay más que esto sobre la programación de GUI, y debe continuar aprendiendo.