Prontos para programar?
Para começar, acho interessante terminar o assunto da lição passada e implementar as funcionalidades do botão e do campo de texto. Para isso, vejamos um pouco de teoria sobre Controle de Eventos:
---//---
[Controle de Eventos]
Existem diversas classes receptoras de evento que podem ser incluídas nos objetos das janelas da interface do usuário, dando mais interatividade no conteúdo. Seja pelos eventos do mouse, teclas pressionadas, eventos da janela, etc. Alguns deles estão abaixo:
ActionListener: Eventos do clique do mouse sobre um botão.
KeyListener : Eventos do teclado (tecla pressionada, solta, etc).
MouseListener: Eventos do mouse (clicado, entra na área de um componente, etc).
WindowListener: Eventos da janela (minimizada, maximizada, etc).
Para adicionar a funcionalidade, implementaremos o passo #5 na função eventos() até agora deixada em branco em nosso projeto:
-------------------------------------------\\-----------------------------------------------
private void eventos(){
botao.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent e){
JOptionPane.showMessageDialog(null,"Clicado!");
}
});
}
-------------------------------------------\\-----------------------------------------------
Código 1 - Trecho de código do controle de eventos do botão.
Para evitar repetição de código, foi somente mostrado acima o trecho que sofre alteração do Código 3 da lição passada (#3). Observe que o clique do mouse agora chama uma caixa de texto.
Figura 1 - Janela com interface gráfica e controle de eventos.
Vamos agora adicionar uma função à caixa de texto. Suponhamos que queremos fechar o programa quando o usuário digitar a letra "Q". Teremos então o seguinte código, inserido dentro do escopo de eventos():
-------------------------------------------\\-----------------------------------------------
digite.addKeyListener(new KeyListener(){
public void keyTyped(KeyEvent e){} // Diferentes controles de evento para KeyListener.
public void keyReleased(KeyEvent e){}
public void keyPressed(KeyEvent e){
System.out.println(e.getKeyCode()); // Imprime o código Ascii da tecla pressionada.
if (e.getKeyCode()==81) // Código ASCII da letra Q
{
digite.setText(digite.getText()+" Letra Q! "); // Imprime mensagem na caixa de texto.
JOptionPane.showMessageDialog(null,"Fechando programa!"); // Caixa de diálogo
System.exit(0); // Fecha o programa
}
}
});
-------------------------------------------\\-----------------------------------------------
Código 2 - Trecho de código para fechar programa ao clicar tecla Q.
Figura 2 - Fechando programa ao pressionar tecla Q.
Muito simples, não? E além disso, com as funcionalidades apresentadas até agora, já é possível desenvolver aplicações diversas e até complexas, como será o caso da Calculadora com interface gráfica, assunto do próximo post, bem como uma breve introdução à POO. Mas antes farei uma pequena abordagem à sintaxe dos métodos.
---//---
[Métodos]
Independente de você, leitor, já ter algum conhecimento prévio de programação Java ou não, você já tem certo conhecimento sobre os métodos e já faz uso deles, embora o conteúdo não tenha sido apresentado formalmente.
Métodos são trechos de códigos, pequenos blocos ou funções que realizam determinada tarefa. No caso da interface gráfica, por exemplo, tínhamos os métodos inicializar() e eventos(). O objetivo deles é organizar o código para facilitar manutenções e melhorar a lógica de funcionamento dele, ficando mais fácil a tarefa de implementar o programa.
A estrutura de um método é a seguinte:
qualificador tipo-de-retorno nome-do-método (parâmetros){
<corpo do código>
}
private void inicializar () {
<...>
}
public static void main(String[] args){
<...>
}
Lembrando que o método main é o principal, sendo que a execução do programa sempre começar por ele, sendo, portanto, indispensável.
<Retorno>
Um método pode não ter retorno, que o caso dos métodos void. Ele pode também retornar alguma informação, como um valor inteiro, uma frase, etc. Veja o exemplo:
-------------------------------------------\\-----------------------------------------------
package helloworld;
public class HelloWorld {
public static void main(String args[]){
String txt = "A média vale: ";
int x;
imprimir(); // Imprime uma frase determinada.
imprimirTexto("olá"); // Imprime uma frase passada no argumento "olá"
x = media(10,8); // x recebe o valor do retorno da função média, com dois argumentos, 10 e 8.
txt += x; // A frase txt adiciona o valor de x ao seu final.
imprimirTexto(txt);
}
public static void imprimir(){
System.out.println("Aprender Java é divertido");
}
public static void imprimirTexto(String texto){
System.out.println(texto);
}
public static int media(int x, int y){
return (x+y)/2;
}
}
-------------------------------------------\\-----------------------------------------------
Código 3 - Métodos com e sem retorno.
Figura 3 - Métodos com e sem retorno.
<Qualificador>
Define o nível de acesso dos elementos (variáveis ou métodos) de uma determinada classe. Isso é, define uma espécie de "privacidade" do método. Ele pode ser usado por todos sem restrição? (public). Existe uma restrição de uso, protegendo assim as informações e métodos? (private)
Esse assunto será tratado com mais detalhes na próxima lição.
Até a próxima.
Até a próxima.
Nenhum comentário:
Postar um comentário