Todo programa em Java é composto de pacotes, definidos com package, mas o que realmente importa é que toda classe Java tem que ter o cabeçalho da classe, definido com public class (classe pública). Dentro do bloco da classe criamos o método (função) principal (public static void main). Veja a estrutura básica de um programa em Java:
package primeiroprograma;
public class PrimeiroPrograma {
public static void main(String[] args) {
}
}
No caso acima, o public static void main nada mais é do que um método (função) público, estático, vazio e principal. O public static indica que o método deverá ser toalmente acessível e estático. O void indica que o método não dará retorno nenhum. O main é o nome do método e indica que é principal. O String[] args é um vetor que o método main recebe como argumento.
Cuidado com os usos de minúsculas e maiúsculas no Java, pois determinadas coisas já são diferenciadas por isso, por exemplo:
O comando pra escrever na tela (nesse caso, no prompt ou num programa), usamos o comando System.out.print().
Para criar um programa Java simples, abrimos um novo projeto e criamos a classe principal normalmente. O comando básico é o primeiro acima, mas as IDEs costumam o escrever automaticamente.
Veja o comando para executar uma frase no Prompt com o comando System.out.print:
package primeiroprograma;
public class PrimeiroPrograma {
public static void main(String[] args) {
System.out.print("Olá, Mundo!");
}
}
Depois é só executar para testar. Se funcionar, pode ser construído e executado em qualquer sistema que tenha o JRE instalado.
PS: você pode escrever sout e teclar o tab que aparecerá System.out.println. Se fizer o mesmo com psvm Aparecerá a estrutura básica do método principal. O System.out.println pula uma linha, mas tirando isso, é a mesma coisa que System.out.print.
Os comentários de uma linha se colocam ao lado de //, e de várias linhas entre /* */, por exemplo:
// Comentário de uma linha
/*
Comentário
de
várias
linhas
*/
Para importar datas, podemos usar o código assim (não esqueça dos imports java.util.Date e java.text.SimpleDateFormat, mas a própria IDE vai sugerir as importações):
package horadosistema;
import java.util.Date;
import java.text.SimpleDateFormat;
public class HoraDoSistema {
public static void main(String[] args) {
Date atual = new Date();
SimpleDateFormat formataData = new SimpleDateFormat("dd/MM/yyyy"); // Formata data, se colocar 3 M ele exibe o nome abreviado, e 4 ou mais exibe o nome completo.
SimpleDateFormat formataHora = new SimpleDateFormat("HH:mm:ss"); // Formata hora, se quiser formato 12 horas, coloque os dois hh minúsculos, uma letra a exibe o AM/PM.
SimpleDateFormat formataSemana = new SimpleDateFormat("EEEE"); // Exibe o dia da semana por extenso, com 3 E ou menos exibe abreviado.
System.out.print("A data do sistema é: ");
System.out.println(formataData.format(atual));
System.out.println(formataSemana.format(atual));
System.out.print("A hora do sistema é: ");
System.out.println(formataHora.format(atual));
}
}
PS: O new identifica a criação de um objeto.
Caso for usar uma palavra dentro do SimpleDateFormat, coloque aspas simples pra ele não confundir com os caracteres de formatação, assim:
SimpleDateFormat formataData = new SimpleDateFormat("EEEE',' dd 'de' MMMM 'de' yyyy");
Use o exemplo acima para mostrar o idioma do sistema e a resolução da tela.
Para exibir o idioma (não esqueça da importação para java.util.Locale):
package idiomadosistema;
import java.util.Locale;
public class IdiomaDoSistema {
public static void main(String[] args) {
Locale loc = Locale.getDefault();
System.out.println(loc.getDisplayLanguage().substring(0, 1).toUpperCase() + loc.getDisplayLanguage().substring(1)); // Exibe inteiro, esse é um macete pra deixar só a primeira letra maiúscula.
System.out.println(loc.getLanguage().toUpperCase()); // Exibe abreviado.
// O método deixa só a primeira maiúscula
// O método toUpperCase() deixa todas maiúsculas.
}
}
Para exibir a resolução da tela:
package resolucaodatela;
import java.awt.Dimension;
import java.awt.Toolkit;
public class ResolucaoDaTela {
public static void main(String[] args) {
Toolkit tk = Toolkit.getDefaultToolkit();
Dimension d = tk.getScreenSize();
System.out.println(d.width + " x " + d.height);
}
}
Após construir o programa, ele só poderá ser executado na linha de comando, ao clicar nele, é provável que ele execute e feche. Para executar, você deve ir na linha de comando, procurar o caminho do arquivo (com o comando cd) e executar o executável com o comando java -jar, dessa forma:
java -jar OlaMundo.jar
Lembrando que essa não é a única forma de criar programas Java.
O Java não é usado só em computador, o System.out pode ser qualquer saída. O Java é utilizado também em celulares (principalmente os mais antigos), placares, letreiros, decodificadores de sinais, velocímetros eletrônicos ou relógios compatíveis, além de poder rodar em qualquer sistema operacional. Teoricamente, qualquer sistema que tenha uma Java Virtual Machine rodaria os programas Java (pacotes com extensão jar contendo classes compiladas class), o que possibilita criarmos um programa Java em Windows e ele poder rodar num Linux ou num Mac, por exemplo. O próprio Android tem seus aplicativos feitos em Java (só que nesse caso ele gera um pacote de extensão apk com classes compiladas dex, e é interpretado na máquina virtual do Android Dalvik) e possuí outras bibliotecas.
PS: Você pode criar arquivos de classe java numa pasta (pacote) e compilar sem IDE. Para isso, crie uma pasta, que será o pacote, e um arquivo java que será a classe (como Teste.java). Vá até ao diretório da pasta e digite o comando javac teste/Teste.java (substituindo pelo nome do pacote e da classe, caso tenha mais de um arquivo no mesmo pacote, execute apenas o que tiver o método main), ele compilará para um arquivo CLASS que pode ser executado diretamente via terminal, usando algo tipo java teste/Teste, e para isso devemos configurar o path corretamente. Para gerar o Jar dessa classe, digite jar cfe Teste.jar teste/Teste teste/Teste.class. Para ver a versão do Java instalada, digite java -version.
O Java funciona por pacotes, é meio que como um carro popular (que só vem o básico, e outros itens você vai adicionando). Todo carro básico tem por exemplo, volante, mas não vem por exemplo, com ar-condicionado, que tem que ser adicionado. Vendo o Java como um carro popular, os pacotes que já existem não precisam importar (como para fazer contas), mas os que não possuí pode ser importado (apenas o pacote java.lang é carregado automaticamente por padrão), na verdade, a maioria deve ser importada.
Com o pacote Swing, você pode criar interfaces gráficas. Ele é um sucessor do AWT (que ainda é usado), mas este se comporta de maneira diferente em outros sistemas que não sejam o Windows.
As interfaces gráficas também são feitas baseadas em orientação a objetos, pois elas são criadas facilmente graças ao conceito de herança.
Para criar um programa Java com Swing, cria-se o projeto da mesma forma anterior, mas sem criar a classe principal (essa será definida ao testar a execução do programa pela primeira vez). Nos pacotes de códigos-fontes, clique no Pacote Default com o botão direito, em Novo e em Outros, escolha Forms Gui Swing e Form JFrame. Defina o nome da Classe (primeira maiúscula com pascalcase) e do Pacote (todas em minusculas). A janela será aberta para configurar o layout dela e o código-fonte.
Após definir os nomes das variáveis, você poderá mexer no código-fonte.
PS: Se quiser evitar que o aplicativo tenha a janela redimensionada, clique no iframe e desmarque a opção "resizable" (que pode também ser feita com o this.setResizable(false), abaixo de initComponents(), no construtor). Se quiser colocar título na janela do programa Java Swing, coloque this.setTitle("Título Desejado") abaixo do InitComponents() dentro do construtor, no código (também é possível pelas propriedades do frame). Da mesma forma, pra centralizar, coloque setLocationRelativeTo(null) no mesmo local (ou nas propriedades vá em código e marque a opção de centralizar). E no mesmo local, para mudar a cor de fundo do frame, colocamos getContentPane().setBackground(Color.BLUE) (substituindo pela cor desejada), mas é recomendado usar um painel pra isso.
No exemplo abaixo, você clicará com o botão direito sobre o botão do frame para definir o evento (vá em Eventos, Action e ActionPerformed, onde está o nome da variável).
Ele criará um código grande para definir o layout da janela, mas essa será a parte do código que você precisará digitar pra exibir uma mensagem no programa:
private void cliqueBotaoActionPerformed(java.awt.event.ActionEvent evt) {
labelMensagem.setText("Olá, Mundo");
}
O JavaFX é uma evolução do Swing, não é tão usada, mas futuramente será mais usada, ele ainda não é compatível com todos os dispositivos. O JavaFX cria interfaces mais complexas que o Swing.
Abra um novo projeto JavaFX e escolha Aplicação FXML do JavaFX (pode escolher a classe normalmente). Essa aplicação permite unir Java com HTML, CSS e XML. Ele criará vários arquivos, inclusive um FXML, clique duas vezes nele para abrir o Java Scene Builder para poder criar as janelas. Se ele não criar, crie o AnchorPane, que criará o painel (frame) para o sistema (que pode ser navegador, celular e etc.), da mesma forma, labels e botões são escolhidos.
PS: Não Esqueça de ir no Code alterar os nomes das IDs. Só depois disso você salva. Você pode editar diretamente o XML se for o caso.
No Document Controller, você criará algo assim, abaixo do primeiro @FXML:
@FXML
private Label labelMensagem;
@FXML
private Button botaoClicar;
PS: No código acima, terá que adicionar a importação do botão para JavaFX, será algo assim:
import javafx.scene.control.Button;
import javafx.scene.control.Label;
No Scene Builder, em Code, coloque em OnAction o nome do evento do botão (no exemplo, será "clicouBotao").
Na IDE, ainda em Document Controller, coloque abaixo do segundo @FXML isso:
@FXML
private void clicouBotao(ActionEvent event) {
labelMensagem.setText("Olá, Mundo!");
}
PS: Tanto no Swing quanto no FX podemos também mudar a cor do nosso label, usando constantes, por exemplo:
labelMensagem.setForeground(Color.RED); // Importe java.awt.Color
Execute, se funcionar, pode compilar ele.
Lembrando que caso o programa não abra ao executar, vá no documento FXML e na tag Anchor Pane, coloque fx:controller="nomedopacotedoprojeto.FXMLDocumentController". Ou dentro o Scene, vá em Controller e Controller Class.
PS: Caso não queira que o aplicativo seja maximixado, coloque isso na classe principal java (com o nome do aplicativo), no método start. No mesmo local, podemos colocar um título:
stage.setScene(scene);
stage.setResizable(false);
stage.setTitle("Olá Mundo!");
stage.show();
Vamos num exemplo, fazer um programa em Swing onde ele pega o horário do sistema, e inseriremos imagens no programa. Crie o projeto Swing e o frame normalmente. Depois, nos Pacotes de Códigos-fonte, crie um novo pacote para as imagens.
Para colocar imagem, crie um label e em Icon, procure a imagem no seu computador, importe ela para o pacote de imagens, logo ela será carregada no frame. Não esqueça de clicar em "Importar Arquivo para o Projeto" e verificar se ela está no pacote criado pra imagens!
Veja abaixo o código para o botão funcionar (não esqueça das importações):
private void botaoClicarActionPerformed(java.awt.event.ActionEvent evt) {
Date atual = new Date();
SimpleDateFormat formataData = new SimpleDateFormat("dd/MM/yyyy");
SimpleDateFormat formataHora = new SimpleDateFormat("HH:mm:ss");
labelData.setText(formataData.format(atual));
labelHora.setText(formataHora.format(atual));
}
Lembrando que para pegar o arquivo JAR pronto, após compilar, basta ir na pasta de projetos da IDE, e procurar ele na pasta dist (geralmente), e ele poderá ser executado em qualquer sistema com JRE instalado, e clicando diretamente nele.
Faça os exercícios de pegar Idioma do Sistema e Resolução de Tela igual no anterior, mas em Java Swing. E colocando imagens também.
PS: Mesmo que o java.lang seja carregado por padrão, podemos fazer uma importação direta de algum objeto ou classe. Veja um exemplo de importação direta do objeto out:
import static java.lang.System.out; // Nesse caso tem que colocar o static no caso de métodos ou atributos estáticos, na maioria dos casos não se coloca o static
public class Teste {
public static void main(String[] args) {
out.println("Olá, Mundo!");
}
}
Existem três maneiras básicas para fazer declarações de tipos primitivos no Java. Pra atribuir uma idade, por exemplo, fazemos dessas formas:
Maneira mais simples, com a declaração no início:
int idade = 3;
float sal = 1825.54f;
char letra = 'G';
boolean casado = false;
PS: Observe que números reais tem que ter o f no final, em Java. O char não permite mais de uma letra e tem que usar aspas simples.
Declaração especificando com typecast (para considerar o número como inteiro, número com ponto como real e assim por diante):
int idade = (int)3;
float sal = (float)1825.54;
char letra = (char)'G';
boolean casado = (boolean)false;
Usando classes (nesse caso eles são objetos, não variáveis comuns):
Integer idade = new Integer(3);
Float sal = new Float(1825.54);
Character letra = new Character('G');
Boolean casado = new Boolean(false);
Na última, Integer, Float, Character e Boolean não são tipos, são classes. O new indica que o conteúdo não é uma variável, e sim a criação de um objeto. O número será considerado inteiro e colocado dentro do objeto, o mesmo acontece com as outras classes. O nome que se dá a esse tipo de classe é Wrapper Class (wrapper é invólucro).
PS: Evite de criar variáveis com Classes usando o new desnecessariamente, pois caso ele estivesse num loop, ele criará novas instâncias do mesmo objeto em cada repetição, que deixará o programa pesado. Podemos usar a classe invólucro e iniciar como um tipo primitivo comum nesse caso, dessa forma:
Integer idade = 3;
Float sal = 1825.54f;
Character letra = 'G';
Boolean casado = false;
Veja uma tabela com os tipos suportados pelo Java:
| Família | Tipo Primitivo | Classe Invólucro | Tamanho | Exemplo |
|---|---|---|---|---|
| Lógico | boolean | Boolean | 1 bit | true |
| Literais | char | Character | 1 byte | 'A' |
| - | String | 1 byte por letra | "Java" | |
| Inteiros | byte | Byte | 1 byte | 127 |
| short | Short | 2 bytes | 32767 | |
| int | Integer | 4 bytes | 2147483 | |
| long | Long | 8 bytes | 263 | |
| Reais | float | Float | 4 bytes | 3.4e+38 |
| double | Double | 8 bytes | 1.8e+308 |
Podem ver que, para guardar strings, não usamos tipos, e sim a classe String, ela não tem limite de tamanho e tem que usar aspas duplas. Em tipo byte e classe Byte não dá pra armazenar números maiores que 127, na tabela acima, inclusive, estão os números máximos de todos. Esses vários tipos primitivos existem para o caso de criar aplicativos para pequenos aparelhos (como um pequeno relógio em Java) ou aplicativos maiores, para economizar dados, se preciso.
PS: As classes invólucros devem ser utilizadas em casos como parâmetros de entidades genéricas, quando precisamos de métodos estáticos dessas classes e principalmente quando precisamos atribuir null à variável, já que, por elas serem classes, permitem valores nulos, coisas que os tipos primitivos comuns não permitem.
Agora vamos mostrar saída de dados usando os tipos primitivos, usando o simples método, faça uma aplicação Java nova, assim:
public static void main(String[] args) {
float nota = 8.5f;
System.out.println("A nota é " + nota);
}
Também podemos usar o comando System.out.printf para formatar números, usando o %f, dessa forma:
System.out.printf("A nota é %f\n", nota);
E também podemos formatar a quantidade de números decimais usando a máscara com o número de casas e a letra f, dessa forma:
System.out.printf("A nota é %.2f\n", nota);
PS: Esse uso da porcentagem para formatação se chama máscara de formatação. E note também que nesse caso deve se usar vírgulas ao invés de mais, porque não é concatenação e sim formatação. E note que o \n é para quebrar a linha, essas já são chamadas de sequências de escape e podem ser usadas em qualquer situação. Todas são originárias da linguagem C e são usadas em várias outras descendentes, como o próprio Java.
As máscaras também podem ser usadas em outros casos, como nesse:
public static void main(String[] args) {
String nome = "Gustavo";
float nota = 8.5f;
System.out.printf("A nota de %s é %.1f\n", nome, nota);
}
Podemos utilizar format no lugar de printf, dessa forma:
System.out.format("A nota de %s é %.1f\n", nome, nota);
Existe também o String.format(), que funciona do mesmo modo, ele é usado dentro de métodos de componentes Swing, JavaFX, JOptionPane e outros.
Essas são algumas das máscaras aceitas em Java:
| Máscara | Significado |
|---|---|
| %d | Valor decimal (positivo ou negativo) |
| %u | Valor decimal sem sinal (só positivo) |
| %f | Valor real |
| %s | String |
| %c | Caractere único |
| %b | Valor booleano |
PS: Em qualquer situação de uso de Strings, para transformar os caracteres em maiúsculos, usamos o método toUpperCase() do objeto String, da mesma forma para minúsculos usamos o toLowerCase(), como por exemplo:
String frase = "Um Texto Qualquer";
System.out.println("Em minúsculas: " + frase.toLowerCase());
System.out.println("Em maiúsculas: " + frase.toUpperCase());
Para fazer o mesmo com char, use os métodos do mesmo nome da classe Character, assim:
char letra = 'a';
letra = Character.toUpperCase(letra); // Convertendo pra maiúsculaa
System.out.println(letra);
letra = Character.toLowerCase(letra); // Convertendo novamente pra minúscula
System.out.println(letra);
Agora vamos ver como faz para mostrar entrada de dados, o que não vem por padrão do Java.
Para isso, vamos importar a classe java.util.Scanner e criar um objeto com o comando Scanner. Veja um exemplo na prática:
import java.util.Scanner;
public class TiposPrimitivos {
public static void main(String[] args) {
Scanner teclado = new Scanner(System.in, "CP1252");
System.out.print("Digite o nome do aluno:");
String nome = teclado.nextLine();
System.out.print("Digite a nota do aluno:");
float nota = teclado.nextFloat();
System.out.printf("A nota de %s é %.1f\n", nome, nota);
}
}
PS: Evite carregar todas as classes de um determinado pacote sem necessidade, isso ocorre usando algo como import java.util.*; (asterisco é um coringa pra "todos"), mas isso deixa o programa mais pesado.
Lembre-se dos métodos para ler importações, como descrito na tabelinha acima. Veja alguns exemplos:
int idade = teclado.nextInt();
float salario = teclado.nextFloat();
String nome = teclado.nextLine();
String login = teclado.next();
char letra = teclado.next().charAt(0);
O nextLine() pega uma linha inteira, e o next() apenas a primeira palavra. E pode ser necessário colocar como parâmetro do Scanner o charset para mostrar acentos, que pode ser ISO-8859-1, CP850 ou CP1252, como por exemplo Scanner(System.in, "CP1252").
PS: Caso o nextLine() não seja reconhecido, coloque outro nextLine() (não coloque next()) sem atribuir à nenhuma variável, antes do nextLine() da variável que deu erro. Isso é comum acontecer após usar números antes de strings. E se quiser remover espaços desnecessário de uma string, use o método trim() na variável.
Diferente de outras linguagens, o Java tem incompatibilidade entre tipos, principalmente de famílias diferentes, como nos valores numéricos e strings (que não são resolvidos com typecasts). Para resolver isso, convertemos os valores com classes invólucros.
Exemplo que converte int para String:
int idade = 30;
String valor = Integer.toString(idade);
System.out.println(valor);
Outro exemplo, que converte String para int:
String valor = "30";
int idade = Integer.parseInt(valor);
System.out.println(idade);
Terceiro exemplo, que converte String para float:
String valor = "30.5";
float idade = Float.parseFloat(valor);
System.out.println(idade);
Temos também outras opções, como a Float.toString() (que converte float para String), Boolean.parseBoolean() (que converte String para boolean), Boolean.toString() (que converte boolean para String) e outras opções parecidas para double e outros tipos.
Podemos converter uma string de uma moeda para float também, dessa forma:
String dinheiro = "R$ 125,94";
float grana = Float.parseFloat(dinheiro.replace(",", ".").replace("R$", "").trim());
System.out.println(grana);
PS: O método replace é utilizado basicamente para trocar alguma parte de alguma string por outra. Ele substitui todas as ocorrências de uma string.
Podemos também inverter uma string, dessa forma:
Scanner teclado = new Scanner(System.in, "CP1252");
System.out.print("Digite o Texto a ser Invertido: ");
String texto = teclado.nextLine();
StringBuilder frase = new StringBuilder(texto);
String invertida = frase.reverse().toString();
System.out.println(invertida);
Podemos usar o método trim() para remover espaços de strings, assim:
Scanner teclado = new Scanner(System.in, "CP1252");
System.out.print("Digite uma frase: ");
String texto = teclado.nextLine().trim();
System.out.println(texto);
O método substring seleciona determinados caracteres de uma string, contados a partir do zero até um número limite, o indexOf pode determinar esse limite:
String frase = "Estude Java! É Muito Legal!";
String selec = frase.substring(0, frase.indexOf("!"));
System.out.println(selec);
Para encontrar uma palavra em uma String, use o método contains, assim:
String frase = "Estude Java! É Muito Legal!";
if(frase.contains("Java")) {
System.out.println("Palavra encontrada.");
}
else {
System.out.println("Palavra não encontrada.");
}
Para ver se uma string está vazia, use o método isEmpty() do objeto, assim:
String nome = "";
System.out.println("Nome está vazio? " + nome.isEmpty());
PS: Isso não verifica valores null, para isso use nome == null.
Para ver a quantidade de caracteres de uma string, use o método length() do objeto, assim:
String frase = "Exemplo de String";
System.out.println("Quantidade de caracteres: " + frase.length());
Podemos concatenar strings usando o método concat, assim:
String frase = "Isso é uma String";
System.out.println(frase.concat(" com mais algo!"));
Para converter uma string em array de char, basta usar o método do objeto string toCharArray(), e pro contrário usamos o método String.valueOf, assim:
String frase = "Isso é uma String!";
char[] vetor = frase.toCharArray(); // Convertendo pra array de char
String novo = String.valueOf(vetor); // Convertendo array de char em string
Para dividir uma string ao encontrar um delimitador, podemos fazer assim:
String frase = "Exemplo de Frase";
String dividido[] = frase.split(" "); // Pode ser qualquer caractere.
System.out.println(dividido[0]);
Para criar constantes, basta declarar como uma variável, com static final no começo (que impedirá que ela seja modificada, o static indica que só terá uma cópia dessa variável na memória, o final impede a alteração do atributo) e sempre a coloque inicializada, elas geralmente são escritas em maiúsculas, assim:
static final double PI = 3.14159265359;
PS: As constantes são declaradas dentro da classe, mas fora do método principal e de qualquer outro método.
Agora vamos fazer um Java Swing, de forma que coloquemos dois números para somar, crie um frame e no botão, vá em Action Permorfed para isso, dessa vez usaremos o método getter, vamos ver um exemplo:
private void btnSomaActionPerformed(java.awt.event.ActionEvent evt) {
int n1 = Integer.parseInt(txtN1.getText());
int n2 = Integer.parseInt(txtN2.getText());
int s = n1 + n2;
lblResultado.setText(Integer.toString(s));
}
PS: Lembre-se que get é pra pegar o texto, e set é pra mudar.
Vamos criar uma nova aplicação de Java Swing, para calcular idade (com imagens). Mas ao invés de caixa de texto, vamos usar caixas numéricas.
PS: Caixas numéricas podem ser configuradas, nas propriedades, como o model, que é pra definir o modelo de controle numérico, como data, números e listas, além de valores mínimos e máximos.
No modelo sugerido, colocaremos também uma propriedade que pegue o ano atual do sistema.
Para pegar o ano do sistema, fazemos assim, no construtor:
public NovoFrame() {
initComponents();
Calendar anoSys = Calendar.getInstance();
int anoAt = anoSys.get(Calendar.YEAR);
lblSys.setText(Integer.toString(anoAt));
}
E apenas isso você colocará no evento do botão:
int anoNs = Integer.parseInt(numAn.getValue().toString());
Calendar anoSys = Calendar.getInstance();
int anoAt = anoSys.get(Calendar.YEAR);
int idade = anoAt - anoNs;
lblIdade.setText(Integer.toString(idade));
Não esqueça da importação java.util.Calendar. É só compilar.
PS: Caso queira que, além do botão, ele seja executado ao clicar enter, podemos usar o evento Key e KeyPressed nas caixas de texto, numéricas e outros, e escolher dentro do método a tecla que deverá ser pressionada, assim:
private void txtSenhaKeyPressed(java.awt.event.KeyEvent evt) {
if(evt.getKeyCode() == KeyEvent.VK_ENTER) { // Podemos utilizar outra tecla aqui, importe java.awt.event.KeyEvent
// Coloque o mesmo código aqui.
}
}