1. Monitoramento de eventos
Código de teste 1:
pacote cn.javastudy.summary; importar java.awt.*; importar java.awt.event.*; public class TestTextfield {public static void main (string args []) {new MyFrameTextField (); }} classe myFrameTextField estende o quadro {myFrameTextfield () {textfield tf = new textfield (); add (tf); tf.addactionListener (new Monitor3 ()); tf.setEchochar ('*'); / * * Este método setechar () é para definir os caracteres exibidos ao entrar na caixa de texto. Aqui está definido como *, para que qualquer conteúdo de entrada seja exibido como *, mas você ainda pode ver o conteúdo de entrada ao imprimir */ setVisible (true); pacote(); }} classe Monitor3 implementa o ActionListener { / * * Todos os métodos na interface são públicos (públicos) *; portanto, ao copiar o void actionPormed (ActionEvent E) do documento da API, você deve adicionar público na frente do void * /public void ActionPormed (ActionEvent e) { / * A informação relevante do evento é encapsulada no objeto e. As informações relevantes do evento podem ser obtidas através dos métodos relevantes do objeto e*/ textfield tf = (textfield) e.getSource (); / * * O método getSource () é obter a fonte do evento. Nota: Quando você obtém esta fonte de evento, * trate -o como a classe pai do TextField. A definição do método getSource () é: "Public Object getSource ()" O valor de retorno é um objeto de objeto, * para que você seja lançado para um objeto de tipo de texto do tipo * Se deseja acessar o objeto de origem do evento de outra classe em uma classe, você pode usar o método getSource () */ system.out.println (tfetText () ///) tf.settext (""); // limpe o conteúdo na caixa de texto}} Código de teste 2:
pacote cn.javastudy.summary; importar java.awt.*; importar java.awt.event.*; public class testActionEvent2 {public static void main (string args []) {quadro f = new Frame ("testActionEvent"); Botão btn1 = new Button ("Iniciar"); Botão btn2 = new Button ("Stop"); Monitor2 m2 = new Monitor2 (); // Crie o objeto de escuta BTN1.AddactionListener (M2); /*Um objeto de escuta ouve as ações de dois botões ao mesmo tempo*/ btn2.addactionListener (m2); btn2.SetActionCommand ("Gameover"); // Defina as informações de retorno depois de executar o comando click do btn2 f.add (btn1, borderlayout.north); f.add (btn2, borderlayout.center); f.pack (); f.SetVisible (true); }} classe Monitor2 implementa o ActionListener {public void ActionPerformed (ActionEvent E) {System.out.println ("Um botão foi pressionado"+"A informação relativa é:/n"+e.getActionCommand ()); /* Use o objeto de escuta retornado e para chamar o método getActionCommand () para obter as informações de retorno após os dois botões executar o comando click. De acordo com as diferentes informações de devolução, qual botão é a operação atual. O BTN1 não usa o método setActionCommand () para definir, portanto as informações retornadas por BTN1 são o texto exibido no botão*/}}2. Monitoramento de eventos do campo de texto
Código de teste:
pacote cn.javastudy.summary; importar java.awt.*; importar java.awt.event.*; public class TestTextfield {public static void main (string args []) {new MyFrameTextField (); }} classe myFrameTextField estende o quadro {myFrameTextfield () {textfield tf = new textfield (); add (tf); tf.addactionListener (new Monitor3 ()); tf.setEchochar ('*'); / * * Este método setechar () é para definir os caracteres exibidos ao entrar na caixa de texto. Aqui está definido como *, para que qualquer conteúdo de entrada seja exibido como *, mas você ainda pode ver o conteúdo de entrada ao imprimir */ setVisible (true); pacote(); }} classe Monitor3 implementa o ActionListener { / * * Todos os métodos na interface são públicos (públicos) *; portanto, ao copiar o void actionPormed (ActionEvent E) do documento da API, você deve adicionar público na frente do void * /public void ActionPormed (ActionEvent e) { / * A informação relevante do evento é encapsulada no objeto e. As informações relevantes do evento podem ser obtidas através dos métodos relevantes do objeto e*/ textfield tf = (textfield) e.getSource (); / * * O método getSource () é obter a fonte do evento. Nota: Quando você obtém esta fonte de evento, * trate -o como a classe pai do TextField. A definição do método getSource () é: "Public Object getSource ()" O valor de retorno é um objeto de objeto, * para que você seja lançado para um objeto de tipo de texto do tipo * Se deseja acessar o objeto de origem do evento de outra classe em uma classe, você pode usar o método getSource () */ system.out.println (tfetText () ///) tf.settext (""); // limpe o conteúdo na caixa de texto}} Implementando uma calculadora simples usando a classe de campo de texto
pacote cn.javastudy.summary; importar java.awt.*; importar java.awt.event.*; classe pública testmath {public static void main (string args []) {new tfframe (); }}/* Aqui está principalmente para preencher o layout dos elementos da calculadora*/classe tfframe estende o quadro {tffRame () {/** Crie 3 caixas de texto e especifique seus tamanhos iniciais como 10 caracteres e 15 caracteres, respectivamente. Aqui está outro método de construção da classe Textfield Public TextField (int colunas) */ TextField num1 = new TextField (10); TextField num2 = novo campo de texto (10); TextField num3 = new TextField (15); /* Crie um botão de sinal igual*/ botão btnequal = new Button ("="); btnequal.addactionListener (New MyMonitor (num1, num2, num3)); /* Adicione um ouvinte ao botão de sinal igual para que ocorra um evento de resposta após clicar no botão*/ etiqueta lblplus = new Label ("+"); /* "+" é um texto estático; portanto, use a classe Label para criar um objeto de texto estático*/ setLayout (new FlowLayout ()); /* Altere o layout padrão da borda do quadro para o layout do fluxo de fluxo*/ add (num1); add (lblplus); add (num2); add (btnequal); add (num3); pacote(); setvisible (true); }} classe MyMonitor implementa ActionListener {TextField num1, num2, num3; / * * Para permitir que a escuta dos botões funcione em caixas de texto, * Portanto, três objetos de campo de texto na classe personalizada MyMonitor são definidos em num1, num2, num3, * também define um método construtor da classe MyMonitor. Esse método construtor possui três parâmetros do tipo de campo de texto, * é usado para receber três parâmetros do tipo de campo de texto passados da classe TffRame * e atribua os três parâmetros recebidos do tipo de campo de texto aos três parâmetros do tipo de campo de texto declarados nesta classe. Em seguida, processe num1, num2, num3 no 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) { /* As informações relevantes do evento são encapsuladas no objeto e. As informações relevantes do evento podem ser obtidas através dos métodos relevantes do objeto e*/ int n1 = Integer.parseInt (num1.getText ());/*num1 objeto chama o método getText () para obter a sequência de texto exibida por si mesma*/ int n2 = integer.ParseInt (num2.getText ()); num3.Settext ("" + (n1 + n2));/* num3 Objeto chama o método setText () para definir seu próprio texto de exibição*/ num1.settext (""); / * Após a conclusão do cálculo, limpe o conteúdo das caixas de texto num1 e num2 */ num2.settext (""); // num3.settext (string.valueof ((n1+n2))); /* Quando as strings são conectadas a qualquer tipo de dados usando "+", a sequência deve ser uma string. * Aqui está uma string vazia e um número do tipo int, para que o número do tipo int obtido por (n1+n2) possa ser diretamente convertido em uma string. * Este é um pequeno truque para converter outros tipos de dados básicos em strings. * Você também pode usar "String.valueof ((n1+n2))" para converter a soma de (n1+n2) em uma string */}} Uso clássico em Java: mantendo referências a outra classe em uma classe
pacote cn.javastudy.summary; importar java.awt.*; importar java.awt.event.*; classe pública testmath1 {public static void main (string args []) {new ttmyframe (). LaunchFrame (); /* Crie o objeto ttmyframe e ligue para o método lauchframe () para exibir o formulário da calculadora*/}}/* Faça a interface do formulário da calculadora*/classe ttmyframe estende o quadro {/* encapsular o código que projeta o formulário da calculadora em um método*/textfield num1, num2, num3; public void LaunchFrame () {num1 = new TextField (10); num2 = novo campo de texto (15); num3 = novo campo de texto (15); Etiqueta lblplus = new Label ("+"); Botão btnequal = new Button ("="); btnequal.addactionListener (novo MyMonitorbtNequal (this)); setLayout (new FlowLayout ()); add (num1); add (lblplus); add (num2); add (btnequal); add (num3); pacote(); setvisible (true); }}/* * Here, by obtaining a reference to the TTMyFrame class, and then using this reference to access the member variables in the TTMyFrame class* This approach is much better than the previous method to directly access the member variables in the TTMyFrame class, * Now you need to access the member variables in the TTMyFrame class, and you can directly access the member variables in the TTMyFrame class object. * Este objeto de classe Ttmyframe é como uma grande governanta, e eu disse à grande governanta que quero acessar as variáveis de membros na aula de ttmyframe, * a referência do grande domicílio me ajudará a encontrá -la, e eu não preciso mais encontrá -la. * Este uso de referências de retenção a outra classe em uma classe é um uso muito típico* Use a referência obtida para acessar todos os membros de outra classe em uma classe*/classe MyMonitorBTNequal implementos 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 (""); }}Os resultados da operação são os seguintes:
Iii. Classe interna
Exemplos de classes internas:
pacote cn.javastudy.summary; importar java.awt.*; importar java.awt.event.*; classe pública testmath3 {public static void main (string args []) {new MyMathFrame (). LaunchFrame (); }} classe myMathFrame estende o quadro {textfield num1, num2, num3; public void LaunchFrame () {num1 = new TextField (10); num2 = novo campo de texto (15); num3 = novo campo de texto (15); Etiqueta lblplus = new Label ("+"); Botão btnequal = new Button ("="); btnequal.addactionListener (new MyMonitor ()); setLayout (new FlowLayout ()); add (num1); add (lblplus); add (num2); add (btnequal); add (num3); pacote(); setvisible (true); } /** Esta classe MyMonitor é uma classe interna, que define a classe MyFrame na classe MyFrame chamada The Wrapper Class* / /** Os benefícios do uso de classes internas:* O primeiro benefício enorme é que ele pode acessar todas as variáveis de membro e métodos da classe externa (isto é, a classe de um membro da classe interna), sem que qualquer uma das obstações e as obstações*, por exemplo, o número de membros do número de números do número. (classe externa),* você pode acessá -la diretamente no MyMonitor (classe interna)* Isso é equivalente ao objeto de classe interna, com uma referência ao objeto de classe externa por padrão ao criar um objeto de classe externa*/ classe privada myMonitor implementa ActionListener {public void ActionPerford (ActionEvent e) {int n1 = integger.Parsent (num1.get.TETTEXT (n1) int n2 = Integer.parseint (num2.getText ()); num3.Settext ("" + (n1 + n2)); num1.settext (""); num2.Settext (""); }}}Os enormes benefícios das classes internas são:
4. Gráficos
Código de teste:
pacote cn.javastudy.summary; importar java.awt.*; public class TestPaint {public static void main (string args []) {new myPaint (). launchFrame (); /*O método Paint (Gráfico G) não é exibido no método Main (), mas após a criação do formulário do quadro, você pode ver que os círculos e retângulos são desenhados no formulário do quadro. Isso ocorre porque o método Paint () é um método especial. Ele ligará automaticamente implicitamente ao criar o formulário do quadro. Quando minimizamos o formulário do quadro e o abrimos novamente, chamaremos o método Paint () novamente e desenhamos os círculos e retângulos no formulário da estrutura. Ou seja, toda vez que precisamos repintar o formulário de quadro, o método pint () será chamado automaticamente*/}} classe myPaint estende o quadro {public void LaunchFrame () {SetBounds (200.200.640.480); setvisible (true); } public void Paint (gráficos g) { / *Paint (gráfico g) O método possui um parâmetro de tipo gráfico g. Podemos tratar esse g como pintor, o pincel segura um pincel na mão e desenhamos as várias imagens que queremos, definindo a cor e a forma do pincel * / / *Defina a cor da escova * / g.setcolor (cor.red); G.FILLOVAL (100.100.100.100);/*Desenhe uma elipse sólida*/ g.setColor (color.green); G.FillRect (150.200.200);/*Desenhe um retângulo sólido*//*As duas linhas de código abaixo são escritas para bons hábitos de programação em programas de escrita. Agora você deve restaurar a cor inicial do pincel, o que é equivalente à limpeza da cor no pincel depois que o pintor usou o pincel*/ color c = g.getColor (); g.setColor (c); }}Resultados em execução:
5. Adaptador de eventos do mouse
Código de teste:
pacote cn.galc.test; importar java.awt.*; importar java.awt.event.*; importar java.util.*; classe pública myMouseAdapter {public static void main (string args []) {new myframe ("desenhando ..."); }} classe MyFrame estende o quadro {ArrayList Points = null; MyFrame (strings s) {super (s); pontos = new ArrayList (); setLayout (nulo); Setbounds (300.300.400.300); this.setbackground (nova cor (204.204.255)); setvisible (true); this.addmouseListener (new Monitor ()); } public void Paint (gráficos g) {iterator i = points.iterator (); while (i.hasNext ()) {ponto p = (ponto) i.next (); g.setColor (color.blue); G.FillOval (PX, PY, 10,10); }} public void addPoint (ponto p) {points.add (p); }} classe Monitor estende mouseAdapter {public void mousePressed (mouseevent e) {myFrame f = (myFrame) e.getSource (); f.addpoint (novo ponto (e.getx (), e.gety ())); F.Repaint (); }}6. Evento do Windows
Código de teste:
pacote cn.galc.test; importar java.awt.*; importar java.awt.event.*; classe pública testwindowclose {public static void main (string args []) {new windowframe ("close windowframe"); }} classe windowframe estende o quadro {public windowframe (strings s) {super (s); Setbounds (200.200.400.300); setLayout (nulo); contratempo (nova cor (204.204.255)); setvisible (true); this.addwindowlistener (new windowmonitor ());/*Ouça as ações desse formulário, encapsulam todas as informações de ação em um objeto e transmitam -o para a classe de escuta*/this.addwindowlistener (/*Definir uma classe em um método, essa classe é chamada de classe, também é chamada de classe de classe, também é chamada de classe, a classe também é chamada de classe. Classe como uma classe WindowAdapter. System.Exit (-1); } /*A classe de escuta também é definida como uma classe interna* /classe WindowMonitor estende a classe WindowAdapter { /*WindowAdapter (adaptador de janela) implementa a interface de escuta do WindowsListener. Reescreva todos os métodos na interface WindowListener. Se você usar diretamente a classe WindowMonitor personalizada para implementar diretamente a interface do WindowsListener, precisará reescrever todos os métodos na interface WindowListener. Mas agora você só precisa usar um desses métodos. Portanto, você pode herdar uma subclasse da interface de escuta do WindowListener e reescrever o método que você precisa usar nesta subclasse. Este método é muito mais simples e mais conveniente do que implementar diretamente a interface de escuta do WindowsListener. */*Reescreva o método WindowClosing (WindowEvent E) que precisa ser usado*//*public void WindowClosing (WindowEvent e) {setvisible (false);/*Defina o formulário para não ser exibido, e o formulário está fechado*/System.exit (0);/*Exit normalmente*/}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}7. Evento de resposta ao teclado - KeyEvent
Código de teste:
pacote cn.galc.test; importar java.awt.*; importar java.awt.event.*; classe pública testkeyevent {public static void main (string args []) {new Keyframe ("Evento de resposta ao teclado"); }} classe KeyFrame estende o quadro {public KeyFrame (strings s) {super (s); Setbounds (200.200.400.300); setLayout (nulo); setvisible (true); addKeyListener (new Keymonitor ()); } /*Defina a classe de escuta do teclado personalizada como uma classe interna. Essa classe de escuta herda da classe KeyAdapter adaptador do teclado. Herda da classe KeyAdapter. Para ser conciso e conveniente, você só precisa reescrever os métodos que precisa usar. Este método é mais simples e mais conveniente do que implementar diretamente a interface KeyListener. Se você implementar diretamente a interface KeyListener, precisará reescrever todos os métodos na interface KeyListener, mas apenas um método é realmente usado. Dessa forma, reescrever outros métodos, mas não usá -los inevitavelmente, o trabalho inútil*/ classe Keymonitor estende KeyAdapter {public void KeyPressed (KeyEvent e) {int keyCode = e.getKeyCode (); /*Use o método getKeyCode () para obter o código virtual da chave* / /*se o código virtual da tecla obtida for igual ao código virtual da tecla UP, significa que a tecla UP keyEvent, atualmente pressionada, significa que o código virtual para obter a tecla UP. Cada tecla no teclado corresponde a um código virtual. Esses códigos virtuais são definidos como constantes estáticas na classe KeyEvent. Portanto, você pode usar o formulário de "nome da classe. }}}}/*O teclado lida com eventos como esta: cada tecla corresponde a um código virtual. Quando uma certa tecla é pressionada, o sistema encontrará o código virtual correspondente a essa tecla para determinar qual tecla está pressionada atualmente*/Através deste artigo, aprendi a programação da GUI com você. Espero que você tenha uma compreensão mais abrangente da programação da GUI. Há mais do que isso sobre a programação da GUI, e você precisa continuar aprendendo.