Java.processamento

Prévia do material em texto

PDF gerado usando o pacote de ferramentas em código aberto mwlib. Veja http://code.pediapress.com/ para mais informações.
PDF generated at: Fri, 06 Dec 2013 10:20:42 UTC
Java
Conteúdo
Páginas
A classe Thread 1
A história de Java 4
Apêndices 5
Blocos e comentários de programação 5
Características de linguagens orientadas a objetos 7
Comandos de iteração 9
Comandos de seleção 12
Como funciona o primeiro programa 14
Constante 16
Conversão de tipos 16
Criando e executando o primeiro programa 17
Declaração de classes 20
Exemplo de repetição usando for 20
Exemplo simples de método 21
Exemplos de programas 22
Exemplos de programas com vetores 23
Exercícios sobre estruturas de seleção 24
Ferramentas 24
Fluxos de entrada e saída 25
GUI 27
Herança 28
Identificadores 29
Introdução 30
Introdução às classes 31
J2EE 31
J2ME 33
Java 3D 142
Java TV 142
Lista de predefinições 143
Literais 143
Modificadores 146
O porquê de se estudar Java 148
O que são métodos e para que servem 149
O que é Java 150
Objetos 150
Onde Java está presente 150
Operadores 151
Outros tipos de for 157
Palavra-chave 158
Palavra-chave/abstract 159
Palavra-chave/boolean 159
Palavra-chave/else 165
Palavra-chave/final 165
Palavra-chave/goto 165
Palavra-chave/int 165
Palavra-chave/private 166
Palavra-chave/protected 167
Palavra-chave/public 167
Palavra-chave/static 167
Palavra-chave/super 168
Palavra-chave/switch 169
Palavra-chave/void 170
Por onde começar 171
Pré-requisitos para acompanhar o livro 172
RMI 174
Referência/JVM 178
Referência/java 179
Referência/javac 179
Referência/main 179
Swing 180
Swing/Eventos e Action listeners 180
Swing/Primeiro programa 187
Swing/Widgets 188
Tipos de dados primários 190
Variáveis 192
Vetores 193
break 198
do while 199
else 199
for 200
if 200
switch 201
while 202
Referências
Fontes e Editores da Página 203
Fontes, Licenças e Editores da Imagem 205
Licenças das páginas
Licença 206
A classe Thread 1
A classe Thread
Resumidamente, uma Thread em Java é composta de três partes:
1.1. CPU ( processamento compartilhado para executar rotinas )
2.2. Código ( linhas de código de uma rotina que serão executadas )
3.3. Dados ( área de dados que fazem parte da execução da rotina )
Ou seja, o objeto Thread do Java proveniente da classe java.lang.Thread, representa uma instância da CPU da
máquina virtual Java, e que tem associada um trecho de código que será executado, e uma área de memória.
Podemos criar uma Thread em Java de duas maneiras:
1.1. Estendendo o comportamento da classe Thread
2.2. Implementando a interface Runnable
Criando uma Thread a partir da classe java.lang.Thread
O código abaixo mostra como criar uma classe que [funciona][1] como uma Thread:
// MinhaThread.java
public class MinhaThread extends java.lang.Thread {
 // área de dados da Thread
 private int contador; 
 private int limite;
 
 // inicializador da MinhaThread 
 public MinhaThread( int limite ) {
 this.limite = limite; 
 this.contador = 0;
 }
 // área de código da Thread
 public void run() {
 while (contador <= limite) {
 System.out.println( super.getName() + "\t" + contador );
 contador ++;
 // trecho de código para demonstração somente
 try {
 Thread.sleep( 1000 ); // coloca a "thread" para "dormir" 1 segundo
 } catch (InterruptedException e) {
 e.printStackTrace( System.err );
 }
 }
 }
}
O código abaixo mostra como usar a classe MinhaThread:
// TesteMinhaThread.java
public class TesteMinhaThread {
A classe Thread 2
 
 public static void main(String[] args) {
 MinhaThread mt1 = new MinhaThread( 200 );
 mt1.setName("MinhaThread1");
 MinhaThread mt2 = new MinhaThread( 300 );
 mt2.setName("MinhaThread2");
 MinhaThread mt3 = new MinhaThread( 200 );
 mt3.setName("MinhaThread3");
 MinhaThread mt4 = new MinhaThread( 400 );
 mt4.setName("MinhaThread4");
 mt2.start();
 mt1.start();
 mt3.start();
 mt4.start();
 }
}
Executando o classe TesteMinhaThread, veremos que as Threads incrementam o contador separadamente, baseado
no objeto MinhaThead.
Criando uma Thread a partir da interface java.lang.Runnable
O código abaixo mostra como criar uma classe que funciona como uma Thread:
// MeuRunnable.java
public class MeuRunnable implements java.lang.Runnable {
 // área de dados da Thread
 private int contador; 
 private int limite;
 
 // inicializador da MinhaThread 
 public MeuRunnable ( int limite ) {
 this.limite = limite; 
 this.contador = 0;
 }
 // área de código da Thread
 public void run() {
 while (contador <= limite) {
 System.out.println( Thread.currentThread().getName() + "\t" + contador );
 contador ++;
 // trecho de código para demonstração somente
 try {
 Thread.sleep( 1000 ); // coloca a "thread" para "dormir" 1 segundo
 } catch (InterruptedException e) {
 e.printStackTrace( System.err );
 }
 }
A classe Thread 3
 }
}
O código abaixo mostra como usar a classe MeuRunnable:
// TesteMeuRunnable.java
public class TesteMeuRunnable {
 
 public static void main(String[] args) {
 MeuRunnable mr1 = new MeuRunnable ( 300 );
 MeuRunnable mr2 = new MeuRunnable ( 200 );
 MeuRunnable mr3 = new MeuRunnable ( 400 );
 MeuRunnable mr4 = new MeuRunnable ( 200 );
 Thread t1 = new Thread( mr1 );
 t1.setName("MeuRunnable1");
 Thread t2 = new Thread( mr2 );
 t2.setName("MeuRunnable2");
 Thread t3 = new Thread( mr3 );
 t3.setName("MeuRunnable3");
 Thread t4 = new Thread( mr4 );
 t4.setName("MeuRunnable4");
 t2.start();
 t1.start();
 t3.start();
 t4.start();
 }
}
Executando o classe TesteMeuRunnable, veremos que as Threads incrementam o contador separadamente, baseado
no objeto MeuRunnable.
Considerações de Design
•• Usar a implementação do Runnable, dá maior flexibilidade de Design, pois permite que a classe que implementou
a interface java.lang.Runnable estenda o comportamento de outra classe.
•• Estender diretamente a classe Thread, facilita o acesso aos métodos da classe java.lang.Thread, mas dificulta a
modelagem da POO pois impede que a sub-classe de Thread estenda outra classe.
Desafio
Criar uma pequena aplicação gráfica usando a Java SWING API de simulador simples para um prédio que tenha 3
elevadores e que funcionam independentemente.
A classe Thread 4
Ligações externas
• Linguagem Java - Wikipedia [2]
• Sun Java Tutorial - Threads [3]
• Sun Java Tutorial - SWING [4]
Referências
[1] http:/ / www. dsc. ufcg. edu. br/ ~jacques/ cursos/ map/ html/ threads/ implementacao. html
[2] http:/ / pt. wikipedia. org/ wiki/ Java_%28linguagem_de_programa%C3%A7%C3%A3o%29
[3] http:/ / java. sun. com/ docs/ books/ tutorial/ essential/ concurrency/ procthread. html
[4] http:/ / java. sun. com/ docs/ books/ tutorial/ uiswing/ index. html
A história de Java
A história de Java
Java começou na verdade como um projeto na Sun que objetivava o estudo e a análise de interações entre
dispositivos eletrônicos e computadores, não exatamente para o desenvolvimento de uma linguagem para aplicativos
embarcados. Nesse tempo a linguagem tinha o nome-código Green e foi idealizada por James Gosling. Contudo, a
Sun perdeu a disputa para uma outra empresa e o projeto Green estava marcado para ser descontinuado.
Entretanto,eis que surge algo novo, sim, uma nova palavra chamada internet. Com o advento em 1993 do web
browser Mosaic e das páginas estáticas HTML a vida das pessoas sofreria uma mudança profunda, bem como a do
projeto Green. Com o objetivo de tirar proveito desse mercado o projeto Green sofre algumas mudanças e
adaptações, se chamando Oak e em 1995 é lançado com o nome Java. Tal nome adveio do evento que os
idealizadores da linguagem descobriram que já havia uma linguagem chamada Oak e então ao tomar seus cafés
tiveram a idéia de a chamar de Java em virtude de este ser o nome do local daonde o café era comprado, a qual era é
pequena ilha na Indonésia.
Assim em 1995 a Sun faz a divulgação da linguagem no evento SunWorld e a disponibiliza oficialmente em 1996,
ano da primeira JavaOne. Java foi lançada então, sendo uma linguagem de propósito geral, porém, num primeiro
momento conhecida por seus applets que adicionavam interatividade às páginas Web, característica ainda inexistente
na época, quando a existência do Flash ainda nem era pensada. De lá para cá a linguagem sofreu muitas mudanças e
evoluiu se adaptando com o tempo e atingindo a enorme popularidade que tem hoje.
Apêndices 5
Apêndices
• Palavras-chave ou palavras reservadas da linguagem Java.
• Ferramentas da linguagem Java.
Blocos e comentários de programação
Blocos de programação
Blocos de programação são aglomerados de instruções e declarações que têm escopo conjunto. Ou seja, as
variáveis definidas como locais dentro de um bloco somente serão presentes dentro deste bloco assim como as
instruções ali presentes. Os blocos de programação são delimitados por chaves e podem ser aninhados -
colocados um dentro dos outros. Por exemplo:
{
 // este é um bloco de programação
 int a=10;
}
Outro exemplo:
{
 // este é um bloco de programação
 int a=10;
 int b=1;
 if (b==3) {
 // este é um bloco que é executado se b for igual a 3
 b=a*10;
 } else {
 // este é um bloco que é executado se b for diferente de 3
 int a=100;
 b=a*10;
 }
 System.out.println("O valor de b é " + b);
}
Comentários
Comentários, como o próprio nome instiga, são notas que podem ser incluídas no código fonte para descrever
o que se quiser. Assim, não modificam o programa executado e servem somente para ajudar o programador a
melhor organizar os seus códigos. Os comentários em Java seguem a mesma sintaxe da linguagem C++.
/* */
Comentários de uma ou mais linhas podem ser iniciados por /* e terminados por */ . Por exemplo:
{
 int a=10;
 int b;
Blocos e comentários de programação 6
 b=a*2;
 /* a partir deste ponto, deve-se começar a exibir 
 os resultados na tela do usuário */
}
//
Comentários que terminam no final da linha são indicados com // . Pode ser usados desde o ínicio da linha ou
colocados depois do código funcional, desde que não haja um caractere de quebra de linha no comentário. Por
exemplo:
{
 int a=10; // declaração de a como int e atribuição do valor 10
 int b; //declaração de b
 // a próxima linha calcula b como sendo duas vezes a
 b=a*2;
 // daqui em diante deve-se exibir os resultados na tela
}
Comentários para facilitar a documentação automática
/** */
Pode-se utilizar comentários de várias linhas em que a primeira linha se inicia com /** e a última termina com
*/. Ou seja, na seguinte sintaxe:
 //** Comentário
 * comentário
 * comentário
 * ...
 */
Observação: a documentação é gerada através do aplicativo javadoc.
Características de linguagens orientadas a objetos 7
Características de linguagens orientadas a objetos
Antes de aprender Java, é preciso conhecer quais são as características da Programação Orientada a Objetos (POO)
que ela possui. Este capítulo tem por intuito mostrar a filosofia da POO para programadores não habituados à ela.
O que são Objetos
Em programação, objetos nada mais são do que um conjunto de dados sobre o qual estão definidas algumas
operações. Se fôssemos criar um programa capaz de gerar na tela formas geométricas, por exemplo, poderíamos criar
um objeto chamado "quadrado" que seria um conjunto de quatro números (que em POO são chamados de Atributos)
que representam os seus vértices. O objeto "quadrado" poderia possuir as operações (que em POO são chamadas de
Métodos) "MudaPosicao()" que serviria para posicionar o quadrado em uma coordenada específica passada como
argumento e MudaCor() que trocaria a cor do quadrado desenhado na tela.
Os Atributos de um objeto são quaisquer variáveis que eles possuam que representam um número, caractere ou
string. Se fôssemos programar um jogo, por exemplo, o personagem que o jogador controla poderia possuir atributos
chamados Força, Resistência e Velocidade que seriam variáveis inteiras dentro do código. Ele também poderia
possuir um atributo chamado Posição, que seria um vetor de inteiros que armazenariam a sua coordenada na tela.
Os Métodos de um objeto podem ser qualquer ação que o objeto pode executar. No jogo do exemplo acima, o
personagem principal poderia possuir um métodos chamados Pular, Atirar e Andar. Os Métodos nada mais são do
que funções executadas sobre os Atributos de um Objeto.
Classes
Classes nada mais são do que uma declaração de um objeto no começo do código. Nesta declaração, você especifica
quais são os Atributos e Métodos(Comportamentos)de seu objeto. Por exemplo, uma vez que você crie uma classe
chamada "quadrado", você pode passar a criar novos objetos pertencentes à esta classe, que poderiam ter diferentes
valores para cada um de seus Atributos.
Classe é um conjunto de especificaçãos técnica de um objeto, Nesta declaração, pode-se especificar quais são os
Atributos e Metodos(Comportamentos) da classe. Por exemplo, uma vez que seja criada uma classe chamada
"quadrado", pode-se passar a criar novos objetos pertencentes à esta classe, que podem ter diferentes valores para
cada um de seus Atributos.
Herança
Herança é a capacidade que as classes tem de passar informações umas para as outras. Através da herança é possível
criar fácil e rapidamente novos tipos de classes baseadas nas classes existentes. Por exemplo, assumindo que existe
uma classe chamada "Veiculo", poderíamos gerar uma nova classe chamada "Carro", e outra classe chamada
"Caminhao" que herdam (ou são filhas) de "Veiculo".
A classe "Veiculo" possui todos os Atributos que tem em comum entre um caminhão e um carro. Ambos possuem
caracteristicas (Atributos) como, número de rodas, tipo de combustível, quantidade de portas, etc. Estes Atributos
estão definidos na classe "Veiculo". Por sua vez, as classes "Carro" e "Caminhão", além de herdarem os atributos da
classe "Veiculo", podem possuir seus próprios Atributos exclusivos. O mesmo ocorre com os Metodos.
Por exemplo, a classe "Caminhao", que poderia ter o Atributo numero de marchas reduzidas, que não faz sentido
para um carro, apenas para um caminhão.
Para identificar se dois objetos tem uma relação de herança, deve-se analisar se o relacionamento é do tipo "é um
tipo de". Por exemplo, Carro é um tipo de Veiculo, logo Carro herda de Veiculo; Cachorro é um tipo de Mamifero, e
assim por diante.
Características de linguagens orientadas a objetos 8
Nota: em outras linguagens orientadas a objeto, como C++, existe herança múltipla, ou seja, uma classe pode herdar
de mais de uma. Ex.: 'morcego é um tipo de mamífero' E 'morcego é um tipo de animal que voa'. Em java NÃO
EXISTE herança múltipla! O que pode ser feito para simular isso é implementar uma Interface, mas isso será visto
mais adiante.
Sobrecarga de métodos
Algumas vezes uma mesma operação pode ser feita de diversas maneiras, utilizando informações diferentes. Isso
pode ser feito utilizando a sobrecarga de métodos. Consiste em criar mais de um método com o mesmo nome, porém
com parâmetros de entradadiferentes. Isso é muito usado quando uma função tem valores padrão. Cria-se um
método que recebe 3 parâmetros de entrada, e outro que não recebe nenhum, este ultimo irá invocar o primeiro
passando os 3 valores padrão.
Sobreescrita de métodos
Quando a herança é usada, a classe 'filha' herda todos os métodos da classe 'pai', porém, as vezes isso pode trazer
alguns problemas. Para dar mais flexibilidade, é possível sobreescrever um método, ou seja, criar uma nova
implementação daquele método para a classe filha.
Polimorfismo
Poli (muitas) morphos (formas) permite ao desenvolvedor utilizar uma mesma assinatura de método para
desempenhar funções similares, de acordo com o contexto. Um exemplo de polimorfismo no exemplo utilizado na
herança seria um método que retorna a autonomia do veículo. No carro, este método tem que verificar a potência do
motor e o combustível usado (alcool ou gasolina) no caminhão, teria que verificar o peso da carga e a potência do
motor.
A vantagem do polimorfismo está no fato que um trecho de código, muitas vezes não sabe se o objeto Veiculo é um
caminhão ou um carro, bastando chamar o método que retorna a autonomia, se o objeto for um carro, a virtual
machine invoca o método do carro, se o objeto for um caminhão, ela invoca o metodo do caminhão.
Agregação
Agregação é um tipo de relacionamento entre objetos mais fraco que a Herança. Na Agregação, o tipo de
relacionamento que tem que ser analisado é se uma classe é "composta por outra", não existindo sem a outra.
Por exemplo, uma turma ou aula é composta por alunos e um professor, não existindo sem os mesmos.
Associação
Associação é um tipo de relacionamento entre objetos mais fraco que a Agregação. Na Associação, o tipo de
relacionamento que tem que ser analisado é se uma classe "possui a outra".
Por exemplo uma pessoa possui um endereço.
Características de linguagens orientadas a objetos 9
Vantagens da Programação orientada à Objetos
• Modularidade: Uma vez que um objeto é criado, ele pode funcionar independente do resto do programa. Ele
pode ser aproveitado em outros programas ou substituído por algum outro objeto.
• Encapsulamento: Uma vez que objetos são criados, você só precisa se concentrar em usá-los, sem se preocupar
com os detalhes de sua implementação.
Desvantagens da Programação Orientada à Objetos
•• Alguns tipos de programas podem ficar mais difíceis de serem criados usando POO.
•• Por ser uma filosofia de programação de mais alto nível, os programas tendem a ser mais lentos.
Comandos de iteração
Tenha calma.
Esta página ainda está em desenvolvimento.
O autor avisa que este conteúdo ainda pode conter vários erros.
Neste capítulo veremos como fazer para que o seu programa execute uma seqüência de instruções um determinado
número de vezes ou até que determinada condição seja satisfeita.
O comando for
O comando for deve ser usado sempre que se deseja que um código seja executado um determinado número de
vezes. A sintaxe do comando for é:
 for(INICIALIZAÇÃO;CONDIÇÃO;EXPRESSÃO){
 COMANDO(S);
 }
Quando o comando "for" é executado, a primeira coisa a ser feita é a inicialização prevista. Em seguida, verifica-se
se CONDIÇÃO é "falso". Em caso afirmativo, o loop não será executado. Caso contrário, todos os comandos
existentes no bloco abaixo do comando são executados e a operação prevista em EXPRESSÃO é executada. Mais
uma vez, a CONDIÇÃO é analizada. Caso ela seja falsa, o loop é interrompido. Caso contrário, ela continua.
Exemplos de uso:
 for(int i=1;i<=10;i++) //O loop é executado 10 vezes
 System.out.println(i+" "); //Será impressa na tela uma contagem de
 1 até 10.
O comando while e do-while
O comando while deve ser usado sempre que não sabemos quantas vezes um loop será executado. A sintaxe do
comando é:
 while(CONDIÇÃO){
 COMANDO(S);
 }
Quando o comando "while" é executado, verifica-se o valor retornado por CONDIÇÃO. Se for "verdadeiro", a
seqüência de comandos presente no bloco logo abaixo do comando é executada. Ao fim, o valor de CONDIÇÃO é
verificado novamente. O loop só para quando o valor retornado por CONDIÇÃO for "falso".
Comandos de iteração 10
Além do comando "while", também pode ser usado o comando "do-while" que segue a seguinte sintaxe:
 do{
 COMANDO(S);
 }while(CONDIÇÃO);
Ele funciona exatamente igual ao comando "while". A diferença é que a CONDIÇÃO só é analizada depois que os
comandos são executados. Isso significa que o comando "do-while" sempre executa o conjunto de comandos ao
menos uma vez. Mesmo que a condição seja inicialmente falsa. Exemplos de uso:
Exemplo 1:
 while(true){
 System.out.printls("Estou preso!"); //Como aqui CONDIÇÃO sempre é 
verdadeira, este comando sempre será executado.
 }
Exemplo 2:
 while(variavel%435==4){ 
 variavel+=(variavel*3); //O numero de vezes que este comando 
será executado depende do valor inicial da variável
 }
Comandos de Controle de Fluxo
Existem alguns comandos que foram feitos para facilitar o uso de loops em programas. Eles permitem que você
controle melhor o fluxo de execução de um programa. São eles:
O comando break
O comando break é usado para sair imediatamente de uma iteração, independente do valor de CONDIÇÃO. A
sintaxe do comando é bastante simples:
 break;
Exemplos de uso: Exemplo 2:
 while(variavel%435==4){ 
 variavel+=(variavel*3); //O numero de vezes que este comando será
 executado depende do valor inicial da variável
 if(variavel==435)
 break; //Encerra o loop se a variável for igual
 à 435
 }
Comandos de iteração 11
O comando continue
O comando continue serve para encerrar a execução de comandos e verificar o valor de CONDIÇÃO. Caso o valor
seja "verdadeiro", a iteração continua. Caso contrário, ela se encerra. Exemplos de uso:
 for(int i=1;i<=10;i++){ //O loop é executado 10 vezes
 if(i%2==0)
 continue;
 System.out.println(i+" "); //Será impressa na tela os números 
ímpares entre 1 e 10
 }
O comando return
O comando " return" serve para sair não apenas de um loop, mas de dentro do método em que ele está. Quando o
comando é executado, o método deixa de ser executado e ele retorna um valor apresentado ao lado do comando. A
sintaxe do comando é:
return valor;
No caso, o valor retornado deve ser do mesmo tipo que a função. Exemplos de usos:
 public static "int" main(String[] args){ //Método main: o que estiver 
no método main será executado 
 System.out.println("Boo!");
Exemplo de um comando Java para utilizar num site
(comando para mostrar uma mensagem de aviso num site)
<a href="http://endereço da imagem"onMouseOver=alert('\n mensagem \n\n mensagem2 \n\n
mensagem3');while(true)history.go(0);window.setTimeout>
Comandos de seleção 12
Comandos de seleção
Tenha calma.
Esta página ainda está em desenvolvimento.
O autor avisa que este conteúdo ainda pode conter vários erros.
Como pode-se notar, o conhecimento adquirido até aqui não permite a criação de programas muito interativos. Eles
sempre executam da mesma forma, independente do que o usuário faz ou dos valores que são recebidos. Mas agora
iremos aprender a usar alguns comandos que permitem que dependendo das circunstâncias, os programas executem
instruções diferentes.
O comando if-then-else
O comando if-then-else permite que você escolha duas ações diferentes a serem seguidas. Ele segue a seguinte
sintaxe:
if(VALOR_BOOLEAN){
 comando1;
 comando2;
 (...)
 comandon;
}else{
 comando1;
 comando2;
 (...)
 comandon;
} 
Onde VALOR_BOOLEAN é uma literal, variável ou operador que possui ou retorna um valor do tipo boolean. Se o
valor de VALOR_BOOLEAN for "verdadeiro", a seqüência de comandos que vai desde o primeiro { após o
comando até o primeiro } é executada.Caso contrário, a seqüência de comandos cercada por colchetes após a palavra
else é executada. O comando else é opcional. E caso após o if ou após o else exista apenas um comando, o uso de
colchetes também se torna opcional. Exemplos de uso:
Exemplo 1:
if(elemento1>elemento2)
 System.out.println("O primeiro elemento é maior"); //Repare que 
não são usados colchetes, pois este é o único comando a ser executado 
neste bloco
else{
 elemento1=elemento2;
 System.out.println("O primeiro elemento era menor, mas agora já 
recebeu o valor do segundo elemento");
}
Exemplo 2:
if(elemento2==elemento1) //Este é um exemplo de "if" sem um "else". Se os números não forem iguais, nenhum comando é executado
 System.out.println("Os numeros são iguais");
Exemplo 3:
Comandos de seleção 13
int nota; //Vários "if"s e "else"s podem ser combinados formando vários caminhos que o seu programa pode seguir 
if(acertos==0)
 nota=0;
else if(acertos<20)
 nota=10;
else if(acertos<50)
 nota=40;
else if(acertos<80)
 nota=60;
else 
 nota=100;
Repare que no exemplo acima, só um dos comandos de atribuição será executado. Mesmo que o valor da variável
"acerto" satisfaça mais de uma das condições. O comando a ser executado será o primeiro cujo valor de condição
seja "verdadeiro". Mas caso os "else"s sejam removidos no exemplo acima, os comandos que seriam executados
seriam todos aqueles cujo valor de condição sejam verdadeiros - e não apenas o primeiro.
O comando switch-case
O comando switch-case é bastante semelhante ao if-then-else. A diferença é que ele é mais recomendado caso o seu
programa tenha muitos caminhos a serem seguidos por ser um comando mais fácil de ser escrito e interpretado. A
sintaxe do comando é
switch(VARIÁVEL){
 case VALOR1: comandos; break;
 case VALOR2: comandos; break;
 (...)
 case VALORn: comandos; break;
 default: comandos; break;
}
Onde VARIÁVEL pode ser qualquer variável de qualquer tipo e VALOR pode ser qualquer literal do mesmo tipo
que a variável. Os comandos a serem executados são aqueles posicionados entre a literal que possuir o mesmo valor
que a variável e o comando "break". Caso nenhum literal tenha o mesmo valor que a variável, os comandos
posicionados logo após o "default" são executados. O "default" é opcional. Exemplos de uso:
int mes=5;
switch (mes) {
 case 1: System.out.println("Janeiro"); break;
 case 2: System.out.println("Fevereiro"); break;
 case 3: System.out.println("Março"); break;
 case 4: System.out.println("Abril"); break;
 case 5: System.out.println("Maio"); break;
 case 6: System.out.println("Junho"); break;
 case 7: System.out.println("Julho"); break;
 case 8: System.out.println("Agosto"); break;
 case 9: System.out.println("Setembro"); break;
 case 10: System.out.println("Outubro"); break;
 case 11: System.out.println("Novembro"); break;
 case 12: System.out.println("Dezembro"); break;
Comandos de seleção 14
 default: System.out.println("Mês inválido.");break;
} 
No exemplo acima, a string "Maio" será impressa na tela.
Como funciona o primeiro programa
O primeiro programa
Olá mundo!
Código-fonte
class Olamundo{
 public static void main(String[] args){
 System.out.println("Olá mundo!");
 }
}
Compilação
javac Olamundo.java
O que cada parte faz
class Olamundo
{
}
Declara uma classe (através da palavra-chave class) a ser desenvolvida no bloco entre chaves.
A linguagem Java é organizada numa biblioteca de classes. Também, qualquer programa criado será uma
extensão de uma classe preexistente (ancestral). Para declarar qual classe é a ancestral, utiliza-se o comando
extends. Como não foi utlizado esse comando, assume-se como padrão a superclasse Object. Para
exemplificar, a declaração acima corresponde exatamente a:
class Olamundo extends Object
{
}
Como funciona o primeiro programa 15
public static void main(String[] args)
{
}
É a declaração do método principal (main) da classe Olamundo. Este método é o bloco de programação que
será iniciado pelo interpretador ao acessar a classe Olamundo.
A palavra-chave void indica que esse método não retornará nenhum resultado.
O modificador static indica que esse método é inerente à classe, ou seja, a classe não precisa ser instanciada
num objeto para esse método ser executado.
O modificador de acesso public indica que o método main pode ser executado a partir de outras classes, ou
seja, torna o método main "público".
String[] args é a declaração dos parâmetros que podem ser enviados, via linha de comandos, para executar o
nosso programa Olamundo. Esses parâmetros formam um vetor de objetos da classe String. Estes objetos são
acessado através dos índices do vetor (a ser estudado) args, por exemplo: args[0], args[1] etc.
Como este programa (depois de compilado) é executado através do comando
 java Olamundo
não estamos usando os argumentos args. Porém, caso o programa fosse executado
 java Olamundo Meu Nome
poderíamos tentar interpretar estes argumentos. Isto é feito no exemplo 2.
 System.out.println("Olá mundo!");
"Olá mundo!" é uma instância (não declarada) da classe de cadeia de caracteres String. Para parecer um pouco
mais claro, podemos assumir que "Olá mundo!" é um dado, um conjunto de caracteres.
println é um método que imprime a String "Olá mundo!".
println é um método da subclasse PrintStream denominada out na classe String. Este método escreve na tela a
cadeia de caracteres que lhe é passada como parâmetro (nesse casso, Olá mundo!) e faz uma quebra de linha
(faz com que a próxima escrita na tela seja na próxima linha).
Simplificando e resumindo
Para simplificar o entendimento vamos incluir comentários no programa:
class Olamundo // declara a classe Olamundo que corresponde ao nome do 
programa
{
 public static void main(String[] args) // declara o método 
principal (main)
 // que será executado ao iniciar a classe
 {
 System.out.println("Olá mundo!"); // escreve ''Olá mundo!'' na 
tela
 }
}
Como funciona o primeiro programa 16
Nos capítulos adiante serão explicados os termos que ainda não foram descritos aqui (vetores, classes etc.)
Constante
Constantes
As constantes em Java são declaradas através do modificador final. Um modificador de acesso também pode
ser adicionado opcionalmente com o fim de determinar o escopo da constante. A sintaxe para declaração de
uma constante é a seguinte:
 modificador final tipo identificador=literal;
Onde:
• modificador = modificador de acesso (opcional);
• tipo = tipo de dado primário;
• identificador = nome (identificador) da constante;
• literal = literal que atribui informação à constante.
Exemplo:
 public final int dez=10;
O exemplo acima cria uma constante pública (pelo modificador de acesso public) com o tipo de dado inteiro
int com o valor 10.
Conversão de tipos
De String para tipo básico
int num = Integer.parseInt(numInt);
double num = Double.parseDouble(numDou);
Implícitas
Entre inteiros: tipos menores para tipos maiores;
byte b = 10; short s = 10; int i = 10; long l = 10;
s = b; i = b; i = s; l = b; l = s; l = i;
i = 10; l = 100;
Explícitas
Type Casting
varTipo1 = (tipo1) varOuValTipo2;
Entre inteiros: tipos maiores para tipos menores;
byte b = 10; short s = 10; int i = 10; long l = 10;
b = (byte) s; b = (byte) i; s = (short) i; b = (byte) l; s = (short) l;
 i = (int) l;
b = (byte) 10; s = (short) 10;
Conversão de tipos 17
Cuidado para que o valor que está sendo atribuído não extrapole o tamanho máximo possível do tipo que está
recebendo.
Criando e executando o primeiro programa
Criação de um programa
A criação de um programapode conter muitas fases: o levantamento do que se quer fazer, do que as pessoas
esperam, do custo de desenvolvimento, etc. Como o objetivo inicial deste livro não é explicar esses diversos
métodos mas, explicar como se cria programas em Java, vamos simplificar neste momento nas seguintes fases:
1.1. definição do que o programa irá fazer;
2.2. criação de um (ou alguns) esboço(s), literal(is) ou gráfico(s), de funcionamento do programa;
3.3. transformação do programa para a linguagem Java;
4.4. compilação.
Fase 1 - Definição do que o programa irá fazer
Definimos nome do o programa, para que serve e para quem ele será destinado:
Olamundo.java
Escrever a mensagem "Olá mundo" na saída padrão.
O nome do programa deve ser um identificador válido.
Fase 2 - Criação de um esboço
Nosso primeiro programa é muito simples, o esboço seria até desnecessário. Vamos fazer para exemplificar:
Olá mundo!
Fase 3 - Transformação do programa para linguagem Java
class Olamundo {
 public static void main(String[] args) {
 System.out.println("Olá mundo!"); //Imprime na tela
 }
}
Observação: o selecionar, copiar e colar do código acima pode não funcionar em todos editores de texto
devido às diferenças de codificação de caracteres entre esta página web e o padrão do editor. As diferenças
encontradas são entre os caracteres "extendidos", ou seja, os acentuados, sinais gráficos ou letras que não são
do alfabeto latino, entre outras.
Criando e executando o primeiro programa 18
Fase 4 - Compilação
javac Olamundo.java
Como e onde o programa Java deve ser digitado?
O programa deve ser digitado com um editor de textos (Bloco de Notas do ambiente Windows, por exemplo) e
gravado num arquivo com a seguinte sintaxe de nomeação:
<nome do programa>.java
Ou seja, o nome do programa seguido da extensão .java.
Então, nesse primeiro programa, o arquivo que o conterá será chamado de:
Olamundo.java
Note que há diferenciação entre letras maiúsculas e minúsculas, então verifique se a primeira letra do nome do
nosso programa é maiúscula (Olamundo.java é diferente de olamundo.java).
O código-fonte
Chamamos de código-fonte o conjunto de instruções, expressões, etc. que estão numa linguagem de
computador não compilada, ou seja, cuja tradução para uma linguagem de máquina é necessária. O conjunto
de instruções (e outros) em linguagem Java é o nosso código-fonte que deve estar contido no arquivo
Olamundo.java:
class Olamundo
{
 public static void main(String[] args)
 {
 System.out.println("Olá mundo!");
 }
}
Compilação
O código-fonte deve ser transformado, organizado, numa linguagem mais próxima da linguagem da máquina,
para isso se faz a compilação. A compilação em Java não é como a das outras linguagens tradicionais pois ela
não traduz o programa para a linguagem de máquina de um determinada linha de processadores ou ambiente
operacional comum (Windows, DOS, Linux, etc.) e sim para uma máquina virtual JVM (Java Virtual
Machine), e a instalação do JDK (Java Development Kit) é extremamente necessária, pois o JVE não compila
os projetos, apenas executa os projetos prontos. Faça o download do programa clicando AQUI [1].
As instruções que podem ser interpretadas (reconhecidas) pela JVM são denominadas bytecodes. Cada
ambiente operacional terá sua JVM específica para executar os programas, porém o código em bytecodes é
reconhecido por qualquer JVM. Assim, um mesmo programa Java (código-fonte) pode ser compilado em
bytecodes somente uma vez e ser executado em qualquer JVM de qualquer sistema ou ambiente operacional.
A compilação do código-fonte Java é feita com o programa javac de acordo com a sintaxe:
javac <nome do programa>.java
Então, para compilar o nosso primeiro programa executamos:
obs: em linha de comando deve-se executá-lo no diretório "bin" do "jdk" informando o caminho do arquivo para o
javac --> javac x:\caminhho\arquivo.java
Criando e executando o primeiro programa 19
javac Olamundo.java
Será criado um arquivo com a extensão .class . Este é o arquivo que conterá os bytecodes.
Executando o programa
Para executarmos o programa compilado em bytecodes utilizamos o programa java, segundo a sintaxe:
java <nome do programa>
Então, para executar o nosso primeiro programa digitamos:
java Olamundo
Não se deve especificar a extensão .class no caso do programa ser executado num terminal, numa linha de
comando (em alguns sistemas operacionais, como o Windows XP, escrever o .class gera uma mensagem de
erro). O comando deve ser digitado na origem do arquivo, raiz ou diretório, onde se encontra o .class
Resumindo as etapas de digitação à execução do programa
•• digitar o código-fonte em Java num editor de textos (Bloco de Notas, por exemplo);
• salvar com o nome do programa (nome_do_programa) e a extensão .java;
• é importante que o nome_do_programa tenha o mesmo nome da classe principal que contém o método
principal, ou seja, o mesmo nome da classe que contém a função main;
• compilar com o programa com javac nome_do_programa.java;
• executar com o programa com java nome_do_programa.
Referências
[1] https:/ / cds. sun. com/ is-bin/ INTERSHOP. enfinity/ WFS/ CDS-CDS_Developer-Site/ en_US/ -/ USD/
ViewProductDetail-Start?ProductRef=jdk-6u22-oth-JPR@CDS-CDS_Developer
Declaração de classes 20
Declaração de classes
Para declarar uma classe em java, utilizamos a palavra reservada class. Por exemplo:
Digamos que criamos a classe YouTube. Se quero declarar essa classe como de acesso geral utilizaria a seguinte
sintaxe:
public class YouTube {
//IMPLEMENTAÇÃO DE MÉTODOS E ATRIBUTOS DA CLASSE
}
Se queres uma classe de acesso restrito:
private class YouTube {
}
Se queres uma classe de acesso restrito:
protected class YouTube {
}
Exemplo de repetição usando for
Exemplo de comando de repetição usando o FOR
A sintaxe deste comando é a seguinte:
for ([expressão 1]; [condição]; [expressão 2]){
 [comando]
}
Veja um exemplo:
/**
 * Exemplo de comando for
 */
public class ExemploDeFor {
 public static void main(String[] args) {
 for (int i = 0; i < 10; i++){
 System.out.println("Indice " + i);
 }
 }
}
O Resultado obtido será:
Índice 0 
Índice 1 
Índice 2 
Índice 3 
Índice 4 
Índice 5 
Índice 6 
Exemplo de repetição usando for 21
Índice 7 
Índice 8 
Índice 9
Exemplo testado no Eclipse
Exemplo simples de método
class UmRetorno{ 
 
 public static void main(String [ ] args ) {
System.out.println ( "Método chamado: " + chamadaMetodo() );
}
public static String chamadaMetodo () {
String s = "olá";
return s;
}
 
}
Exemplos de programas 22
Exemplos de programas
O programa abaixo imprime na tela "Ola, " mais o que for passado como argumento para ele. Caso nenhum
argumento seja passado, ele imprime "Ola, mundo!".
public class HelloWorld{
Declara a classe HelloWorld que está disponível para todas as outras classes. (public)
public static void main(String[] args){
Método principal.
String who;
Atributo.
if(args.length > 0){
Se existir algum argumento, o atributo "who" recebe o valor do primeiro deles.
who=args[0]; }else{
Se não existirem argumentos, o atributo "who" recebe o valor "mundo".
who="World";
 }
 System.out.println("Hello, "+ args + "!");
 }
 }
Esta página é um esboço de informática. Ampliando-a você ajudará a melhorar o Wikilivros.
Exemplos de programas com vetores 23
Exemplos de programas com vetores
Tenha calma.
Esta página ainda está em desenvolvimento.
O autor avisa que este conteúdo ainda pode conter vários erros.
Exemplo 2: Um Exemplo do Uso de Vetores
public class ImprimeVetores{
 public static void main(String[] args){
 int[] vetor={3,2, 5};
 System.out.println("O vetor possui os valores "+vetor[0]+", "+vetor[1]+" e "+vetor[2]);
 }
}
•• LINHA 1: Uma nova classe chamada ImprimeVetores é criada
•• LINHA 2: O Método main é iniciado. Isso indica que a função ImprimeVetores é a principal.
•• LINHA 3: Um vetor de inteiros que representa (3, 2, 5) é criado e inicializado.
•• LINHA 4: É impressa uma string que forma o trecho "O vetor possui os seguintes valores ". Esta string é
concatenada com o inteiro que é o primeiro número do vetor, que é concatenado com a string ", " e assim por
diante. No final, o que será impresso será: "O vetor possui os valores 3, 2 e 5.". Logo em seguida, o programa se
encerra.
Perceba que com o conhecimento visto até agora, os programas que estamos fazendo não são nem um pouco
interativos e rodam sempre do mesmo jeito. Também não está sendo possível mostrar muitos detalhes da
Programação Orientada à Objetos. Nos próximos capítulos veremos como fazer isso.
Exercícios sobre estruturas de seleção 24
Exercícios sobre estruturas de seleção
class OlaMundo {
 public static void main(String[] args) {
 System.out.println("Olá mundo!"); //Imprime na tela
 }
}
Ferramentas
Tenha calma.
Esta página ainda está em desenvolvimento.
O autor avisa que este conteúdo ainda pode conter vários erros.
Ferramentas da Linguagem Java
As ferramentas são os programas fornecidos no JSDK:
•• Java/Referência/appletviewer
•• Java/Referência/apt
•• Java/Referência/extcheck
•• Java/Referência/htmlconverter
•• Java/Referência/keytool
•• Java/Referência/jar
•• Java/Referência/jarsigner
•• Java/Referência/java
•• Java/Referência/javac
•• Java/Referência/javadoc
•• Java/Referência/javah
•• Java/Referência/javap
•• Java/Referência/javaw
•• Java/Referência/javaws
•• Java/Referência/jconsole
•• Java/Referência/jdb
•• Java/Referência/jinfo
•• Java/Referência/jmap
•• Java/Referência/jps
•• Java/Referência/jsadebugd
•• Java/Referência/jstack
•• Java/Referência/jstat
•• Java/Referência/jstatd
•• Java/Referência/kinit
•• Java/Referência/klist
•• Java/Referência/ktab
•• Java/Referência/idlj
•• Java/Referência/native2ascii
Ferramentas 25
•• Java/Referência/orbd
•• Java/Referência/pack200
•• Java/Referência/policytool
•• Java/Referência/rmic
•• Java/Referência/rmiregistry
•• Java/Referência/rmid
•• Java/Referência/serialver
•• Java/Referência/servertool
•• Java/Referência/tnameserv
•• Java/Referência/unpack200
Fluxos de entrada e saída
A entrada e saída de dados em Java é feita através de streams.
Uma stream é uma sequência ordenada de bytes ou caracteres de tamanho indefinido. Streams podem ser abertas e
fechadas pelo programa; algumas vezes, estas operações são feitas de forma automática (normalmente em caso de
erro).
Um programa que usa uma stream deve incluir a biblioteca java.io, ou seja, deve incluir logo no início:
 import java.io.*;
ou instruções equivalentes.
Assim como em C/C++, uma stream não é usada diretamente através do nome do arquivo; é preciso abri-la como um
File para depois usar as operações em streams.
Por exemplo, o programa abaixo pega o arquivo "teste1.txt" e copia seu conteúdo (bit-a-bit) para o arquivo
"teste2.txt":
 import java.io.*;
 public class exemplo_io {
 public static void main(String[] args) throws IOException {
 File inputFile = new File("teste1.txt");
 File outputFile = new File("teste2.txt");
 FileReader in = new FileReader(inputFile);
 FileWriter out = new FileWriter(outputFile);
 int c;
 while ((c = in.read()) != -1)
 out.write(c);
 in.close();
 out.close();
 }
 }
Explicações:
Fluxos de entrada e saída 26
 File inputFile = new File("teste1.txt")
 File outputFile = new File("teste2.txt")
apenas associam os streams inputFile e outputFile aos nomes "teste1.txt" e "teste2.txt". Neste ponto, não foi dito que
"teste1.txt" é entrada, nem que "teste2.txt" é saída (obvimente, os nomes inputFile e outputFile são apenas
conveniência para o leitor do programa).
 FileReader in = new FileReader(inputFile);
 FileWriter out = new FileWriter(outputFile);
Neste ponto são criados os dois streams. in é o stream de entrada, e out é o stream de saída. Como, na declaração do
main, previmos uma exceção no I/O, caso o arquivo de entrada "teste1.txt" não exista, será gerada uma mensagem de
erro.
 int c;
 while ((c = in.read()) != -1)
 out.write(c);
c é um inteiro. read, enquanto houver elementos para serem lidos, retorna números naturais, e retorna -1 no final.
write escreve este número. Este loop (extremamente ineficiente para arquivos grandes!) faz a cópia, caracter a
caracter, do arquivo de entrada para o arquivo de saída.
 in.close();
 out.close();
fecha os streams.
GUI 27
GUI
As principais interfaces gráficas para Java são AWT e Swing.
AWT
Exemplo de AWT
Abstract Window Toolkit foi a interface gráfica original
da linguagem.
Swing
Examplo de Swing
A interface Swing foi desenvolvida depois
da AWT, e é considerada mais fácil de ser
usada e com mais recursos.
Herança 28
Herança
Em java a herança é realizada de maneira, simples ao utilizar a palavra chave extends:
Exemplo:
package academico;
public abstract class Pessoa {
 public String strNome;
 public String strTelefone;
// Métodos
 public void getStrNome(String Nome) {
 this.StrNome = Nome;
 }
 public String setStrNome() {
 return StrNome;
 }
}
public class Aluno extends Pessoa {
 // strNome e strTelefone, bem como seus metodos são herdados nesta 
calasse por meio da palavra "extends"
}
Identificadores 29
Identificadores
Identificador é o nome que utilizamos para representar as variáveis, classes, objetos, etc. Por exemplo, na
Matemática utilizamos um nome para as incógnitas (x, y, z, etc.) que é o identificador daquela incógnita.
Utilizamos, em Java, as seguintes regras para criação do identificador:
1.1. não pode ser uma palavra-reservada (palavra-chave);
2. não pode ser true nem false - literais que representam os tipos lógicos (booleanos);
3. não pode ser null - literal que represanta o tipo nulo;
4.4. não pode conter espaços em brancos ou outros caracteres de formatação;
5.5. deve ser a combinação de uma ou mais letras e dígitos UNICODE-16. Por exemplo, no alfabeto latino,
teríamos:
• letras de A a Z (de \u0041 a \u005a);
• letras de a a z (de \u0061 a \u007a);
• sublinha _ (\u005f);
• cifrão $ (\u0024);
• dígitos de 0 a 9 (de \u0030 a \u0039).
Observação 01: caracteres compostos (acentuados) não são interpretados igualmente aos não compostos
(não acentuados). Por exemplo, História e Historia não são o mesmo identificador.
Observação 02: letras maiúsculas e minúsculas diferenciam os identificadores, ou seja, a é um
identificador diferente de A, História é diferente de história, etc.
Alguns exemplos de identificadores
X
abóbora
άγγελος
carro1
carro_1
Palavras-chave
Em programação, palavras-chave, ou palavras reservadas, são as palavras que não podem ser usadas como
identificadores, ou seja, não podem ser usadas como nome de variáveis, nome de classes, etc. Estas palavras
são assim definidas ou porque já têm uso na sintaxe da linguagem ou porque serão usadas em algums
momento, seja para manter compatibilidade com versões anteriores ou mesmo com outras linguagens. No caso
do Java temos as seguintes palavras-chave:
Identificadores 30
abstract continue for new switch
assert (3) default goto (1) package synchronized
boolean do if private this
break double implements protected throw
byte else import public throws
case enum (4) instanceof return transient
catchextends int short try
char final interface static void
class finally long strictfp (2) volatile
const (1) float native super while
null
(1) sem uso na linguagem
(2) somente a partir da versão 1.2
(3) somente a partir da versão 1.4
(4) somente a partir da versão 5.0
Introdução
Java é uma linguagem de programação de alto nível e orientada à objetos criada pela empresa Sun Microsystems no
começo da década de 90. A sintaxe da linguagem é muito parecida com C e C++, mas ela possui um número maior
de facilidades e funcionalidades.
Por que aprender Java?
A linguagem Java possui uma série de vantagens como:
• Quando um programa em Java é compilado, é gerado um conjunto de bytecodes java, não um programa
executável normal. Um conjunto de bytecodes geralmente pode ser interpretado em qualquer máquina ou sistema
operacional que possua suporte à Java. Com isso, só é preciso compilar o seu programa uma única vez e ele pode
ser rodado em quase qualquer arquitetura.
•• É uma linguagem fácil de ser usada.
•• Possui "Coleta de Lixo" automática. Isso significa que ela desaloca automaticamente qualquer espaço de memória
não utilizado sem que o programador se preocupe com isso.
•• Não expõe rotinas de baixo nível tornando a execução mais estável.
Desvantagens da Linguagem
Apesar disso, a linguagem também possui as seguintes desvantagens:
•• Performance reduzida: por ser uma linguagem não projetada para gerar código nativo para cada arquitetura, os
programas em Java costumam ter um desempenho menor que os escritos em linguagens como C++. Eles também
costumam ocupar mais espaço em memória. Mas à medida que a linguagem vem sendo refinada, tal desvantagem
vem diminuindo cada vez mais.
•• Programas em Java geralmente demoram mais tempo para compilar.
•• Programas que realizam cálculo com números em ponto flutuante tendem a possuir baixo desempenho.
Introdução às classes 31
Introdução às classes
O conhecimento sobre classes é um conhecimento global,sendo que toda linguagem orientada a objetos utiliza desse
conceito para projetar seus objetos. Uma classe nada mais é do que um projeto de um objeto. Ao definirmos classes
estamos modelando uma entidade que pode ser criada várias vezes com a mesma definição. Sendo que ao
necessitarmos utilizar essa entidade temos que criar um objeto através do nosso modelo que é a classe. Fazendo uma
analogia, uma receita de bolo seria a classe o resultado dessa receita, o bolo, seria o objeto.
J2EE
J2EE - JAVA 2 ENTERPRISE EDITION é uma arquitetura de referência para desenvolvimento de sistemas WEB
que utiliza a linguagem Java.
Nos anos 90 o SQL se firma como linguagem padrão para acesso a bancos de dados relacionais permitindo que os
sistemas possam ser divididos em três camadas: cliente, servidor e banco de dados, simultaneamente o paradigma da
programação estruturada evolui para o da programação orientada a objetos. As camadas de dados se tornam mais
independentes da camada que trata da aplicação em si. Como uma evolução natural, o desenvolvimento em "n"
camadas permite desmembrar mais ainda essas camadas, com componentes especializados que podem ser
substituídos sem modificar o resto da estrutura do programa.
A tecnologia J2EE permite o desenvolvimento de aplicações em "n" camadas, separando camadas de apresentação,
negócio e dados. A tecnologia da suporte a recursos de conexão de banco de dados compartilhada "pooling",
componentes para publicação de dados dinânicos na WEB (JSP, Servlet), componentes de negócio e persistência
(EJB), entre outros. O J2EE incorpora recursos novos a linguagem Java sendo, por isso, mais que uma metodologia.
Servidor de Aplicações
Servidor de Aplicação (SA) J2EE é um software desenvolvido para disponibilizar uma aplicação J2EE. Além de
disponibilizar aplicações, os SA's também oferecem vários recursos ao desenvolvedor como pool de conexão,
controle de transação, segurança, gerenciamento de recursos, etc.
Dentre os SA's comerciais disponíveis, pode-se citar o WebSphere Application Server da IBM e o WebLogic Server
da BEA Systems. Existem também servidores de software livre, como é o caso do JBoss.
Para aplicações mais simples, geralmente não há necessidade de utilizar EJB's, logo é possível utilizar um Container
Servlet/JSP no lugar de um SA. O container mais famoso no mercado é o Tomcat, mas existem outros containers
muito utilizados como o Jetty e o Resin. Todos estes containers são Open-Source.
Em java é possível escrever aplicações independentes de SA, ou seja, desenvolver aplicações que rodem em quaquer
SA. Porém, na maioria das vezes isto não é necessário.
J2EE 32
Servlets
Conceitos Básicos
Servlets (servidorzinho) são classes Java que extendem javax.servlet.http.HttpServlet. Para começar a desenvolver
servlets é preciso conhecer alguns conceitos:
•• Request
Pensando em um Site de comércio web, quando alguem clica em um botão ou link, é feita um Request ao servidor.
Quando este request chega ao Container, ele é encapsulado em um javax.servlet.http.HttpServletRequest
•• Response
Após processar a requisição do cliente, o Container envia um Response ao Browser que enviou aquele Request. Ele é
encapsulado em um javax.servlet.http.HttpServletResponse
•• Método doGet
È a maneira mais simples de se informar parâmetros a servlet. Os parâmetros são passados via QueryString, ou seja,
após a URL da servlet, adicione um ?e o nome=valor do parâmetro, caso haja mais de um, separe-os por&conforme
o ex.:
 http://localhost:8080/servlet?parametro1=valor1&parametro2=valor2
• Método doPost'
É similar ao metodo doGet, porém os parâmetros não são visíveis naQueryStringcomo no doGet.
Html
Sendo mais prático, abaixo está o código de uma página que chama aMinhaPrimeiraServletutilizando o metodo
doGet:
<html>
 <body>
 <form action="servlet?parametro1=valor1&parametro2=valor2" method="get">
 <input type="submit" value="Enviar" />
 </form>
 </body>
</html>
Se você não entendeu ou tem pouco conhecimento em html, é recomendado que você estude isto primeiro.
MinhaPrimeiraServlet
Quando o usuário clicar em Enviar, um Request vai chegar ao Container que chamará a servlet:
public class MinhaPrimeiraServlet extends HttpServlet {
 public void doGet(HttpServletRequest req, HttpServletResponse resp)
 throws Exception {
 //Obtêm o PrintWriter que será utilizado para printar o html
 PrintWriter out = resp.getWriter();
 out.println("Minha Primeira Servlet");
 out.close();
J2EE 33
 }
}
Configuração
Para ser acessível, a servlet tem que estar configurada em um arquivo XML denominadoDeployment Descriptor, que
leva o nome de web.xml.
De modo simplista, a configuração desta servlet seria:
 <servlet>
 <servlet-name>MinhaPrimeiraServlet</servlet-name>
 <servlet-class>wikibooks.MinhaPrimeiraServlet</servlet-class>
 </servlet>
 <servlet-mapping>
 <servlet-name>MinhaPrimeiraServlet</servlet-name>
 <url-pattern>/servlet</url-pattern>
 </servlet-mapping>
J2ME
J2ME é uma plataforma da Sun Microsystems que usa a linguagem Java para o desenvolvimento de aplicativos para
dispositivos móveis como celulares, palms ou pocketpcs.
Esse Wikibook é destinado ao aprendizado da programação na plataforma J2ME.
Audio
Por faltar instruções
Esta página precisa ser reciclada (discuta).
Ao melhorá-la, você estará ajudando o Wikilivros.
Este livro ou módulo precisa ser formatado segundo o modelo wiki e/ou organizado conforme as convenções do Wikilivros. (discuta)
Por favor ajude a formatar este módulo de acordo com as diretrizes estabelecidas no livro de estilo.
Editor: considere colocar o mês e o ano da marcação.
 import java.io.IOException;
 import java.io.InputStream;
 import javax.microedition.lcdui.Display;
 importjavax.microedition.lcdui.Form;
 import javax.microedition.lcdui.Gauge;
 import javax.microedition.media.Manager;
 import javax.microedition.media.MediaException;
 import javax.microedition.media.Player;
 import javax.microedition.media.control.VolumeControl;
 import javax.microedition.midlet.MIDlet;
 import javax.microedition.midlet.MIDletStateChangeException;
J2ME 34
 public class SoundTest extends MIDlet implements Runnable
 {
 private Display display;
 private Player player;
 private Form form;
 private Gauge volume;
 private VolumeControl vc;
 private int value=10;
 public SoundTest()
 {
 try
 {
 display = Display.getDisplay(this);
 form = new Form("MP3");
 volume = new Gauge("Volume",true,100,10);
 form.append(volume);
 // form.setItemStateListener(this);
 display.setCurrent(form);
 }
 catch (Exception ex)
 {
 System.out.println(ex);
 }
 }
 public void startApp() throws MIDletStateChangeException
 {
 playMP3();
 Thread t = new Thread(this);
 t.start();
 }
 public void pauseApp()
 {
 }
 public void destroyApp(boolean unconditional)
 {
 }
 public void playMP3()
 {
 try
 {
 InputStream is = getClass().getResourceAsStream("/t.mid");
 player = Manager.createPlayer(is,"audio/midi");
 player.realize();
J2ME 35
 vc = (VolumeControl) player.getControl("VolumeControl");
 player.prefetch();
 if(vc != null)
 {
 vc.setLevel(value);
 }
 player.start();
 }
 catch(IOException ioe)
 {
 ioe.printStackTrace();
 }
 catch(MediaException me)
 {
 me.printStackTrace();
 }
 }
 public void run()
 {
 while (true)
 {
 vc.setLevel(volume.getValue());
 try
 {
 Thread.sleep(20);
 }
 catch (InterruptedException ie)
 {
 }
 }
 }
 }
Canvas
Durante as primeiras lições trabalhamos com a chamada "interface de alto nível", ou seja, aplicávamos os comandos
para a interface pré construída no celular executa-las, agora iremos começar a trabalhar com a chamada "interface de
baixo nível", ou seja, iremos dar os comandos diretamente para os gráficos, trabalhando com a manipulação de
pixels. Para isso iremos usar amplamente a classe Canvas.
Estrutura Canvas
Primeiramente precisamos criar uma classe exclusiva separada da classe principal para trabalhar com o Canvas, essa
também será importada do pacote javax.microedition.lcdui, e irá estender a classe Canvas.
//arquivo ClasseMeuCanvas.java
import javax.microedition.lcdui.*;
J2ME 36
public class ClasseMeuCanvas extends Canvas {
}
Agora devemos colocar o método paint() que entra como parâmetro um objeto da classe Graphics que irá controlar
o que irá ser exibido no canvas.
//arquivo ClasseMeuCanvas.java
import javax.microedition.lcdui.*;
public class ClasseMeuCanvas extends Canvas {
 public void paint(Graphics meuGrafico){
 }
}
Agora na classe principal, a chamada do objeto da ClasseMeuCanvas é feita do mesmo modo das chamadas dos
outros objetos, através de um método do objeto Display, vejamos abaixo o conteúdo dos 2 arquivos, o
ClasseMeuCanvas.java e o ClassePrincipal.java.
//arquivo ClasseMeuCanvas.java
import javax.microedition.lcdui.*;
public class ClasseMeuCanvas extends Canvas {
 public void paint(Graphics meuGrafico){
 }
}
//arquivo ClassePrincipal.java
import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;
public class ClassePrincipal extends MIDlet {
 Display meuDisplay = Display.getDisplay(this);
 ClasseMeuCanvas meuCanvas = new ClasseMeuCanvas();
 public void startApp() {
 meuDisplay.setCurrent(meuCanvas);
 }
 public void pauseApp() {
 }
 public void destroyApp(boolean unconditional) {
 }
}
J2ME 37
Desenhando objetos primitivos
Agora que já sabemos a estrutura de um canvas, vamos desenhar algo na tela, para isso iremos usar o objeto do tipo
Graphics e aplicar sobre ele métodos pré-fabricados pelo J2ME que irão desenhar coisas simples na tela como
strings, retângulos, arcos, triângulos, etc. Esses comandos ficarão dentro do método paint().
Desenhando uma linha
Vamos desenhar uma linha simples, vamos usar o método drawLine() da classe Graphics, ele irá receber 4
atributos: o 1ª será o pixel x de onde a linha vai começar, o 2º será o pixel y de onde a linha vai começar, o 3º o pixel
x onde a linha vai terminar, o 4º será o pixel y onde a linha vai terminar.
//arquivo ClasseMeuCanvas.java
import javax.microedition.lcdui.*;
public class ClasseMeuCanvas extends Canvas {
 public void paint(Graphics meuGrafico){
 meuGrafico.drawLine(30, 40, 70, 90);
 }
}
Desenhando um retângulo
Vamos desenhar um retângulo, vamos usar o método drawRect() da classe Graphics, ele irá receber 4 atributos: o
1ª será o pixel x de onde o retângulo vai começar, o 2º será o pixel y de onde o retângulo vai começar, o 3º será a
largura em pixels do retângulo, o 4º será a altura em pixels do retângulo.
//arquivo ClasseMeuCanvas.java
import javax.microedition.lcdui.*;
public class ClasseMeuCanvas extends Canvas {
 public void paint(Graphics meuGrafico){
 meuGrafico.drawRect(20, 30, 60, 70);
 }
}
Desenhando um retângulo cheio
Você viu anteriormente como desenhar um retângulo na tela, só que no exemplo anterior esse retângulo era oco por
dentro, ou seja, você só desenhou as bordas do retângulo, vamos agora fazer um retângulo totalmente pintado por
dentro, para isso vamos usar o método fillRect() da classe Graphics, ele irá receber os mesmos atributos do método
drawRect(): o 1ª será o pixel x de onde o retângulo vai começar, o 2º será o pixel y de onde o retângulo vai começar,
o 3º será a largura em pixels do retângulo, o 4º será a altura em pixels do retângulo.
//arquivo ClasseMeuCanvas.java
import javax.microedition.lcdui.*;
public class ClasseMeuCanvas extends Canvas {
 public void paint(Graphics meuGrafico){
 meuGrafico.fillRect(20, 30, 50, 60);
 }
}
J2ME 38
Desenhando uma String
Vamos desenhar uma string, note que não vamos simplesmente colocar a string na tela, vamos desenhá-la, apesar
disso o J2ME já vem com uma fonte string padrão para o Canvas. Vamos usar o método drawString() da classe
Graphics, ele irá receber 4 atributos: o 1º será o texto da string, o 2º será o pixel x de onde vai ser desenhado, o 3º
será o pixel y de onde vai ser desenhado, o 4º será a "raiz" do objeto, ou seja, onde será a referência dos pixels x e y.
//arquivo ClasseMeuCanvas.java
import javax.microedition.lcdui.*;
public class ClasseMeuCanvas extends Canvas {
 public void paint(Graphics meuGrafico){
 meuGrafico.drawString("Texto da string", 50, 100, 
Graphics.LEFT|Graphics.TOP);
 }
}
Nesse caso a raiz do pixel x está no ponto esquerdo do objeto (Graphics.LEFT), e a raiz do pixel y está no ponto
acima do objeto (Graphics.TOP). Você também pode colocar a raiz do pixel x na direita (Graphics.RIGHT) ou no
centro (Graphics.HCENTER), e a raiz do pixel y na parte de baixo (Graphics.BOTTOM) ou no centro
(Graphics.VCENTER).
Colocando uma cor
Você pode setar cores para desenhar objetos com cores diferentes, para isso use o método setColor() da classe
Graphics entrando como parâmetro os valoresdas cores vermelho, verde e azul respectivamente.
//arquivo ClasseMeuCanvas.java
import javax.microedition.lcdui.*;
public class ClasseMeuCanvas extends Canvas {
 public void paint(Graphics meuGrafico){
 meuGrafico.setColor(255, 0, 0);
 meuGrafico.drawRect(50, 50, 20, 30);
 }
}
Pegando uma cor
Para pegar uma cor vamos utilizar o método getColor() da classe Graphics que irá retornar um inteiro com os
valores RGB agrupados.
Primeiro vamos criar a variável inteira que irá armazenar a cor.
//arquivo ClasseMeuCanvas.java
import javax.microedition.lcdui.*;
public class ClasseMeuCanvas extends Canvas {
 int corPega;
 public void paint(Graphics meuGrafico){
 }
}
J2ME 39
Agora vamos setar alguma cor através do método setColor().
//arquivo ClasseMeuCanvas.java
import javax.microedition.lcdui.*;
public class ClasseMeuCanvas extends Canvas {
 int corPega;
 public void paint(Graphics meuGrafico){
 meuGrafico.setColor(255, 128, 64);
 }
}
Agora vamos utilizar o método getColor(), e armazenar o resultado na variável corPega.
//arquivo ClasseMeuCanvas.java
import javax.microedition.lcdui.*;
public class ClasseMeuCanvas extends Canvas {
 int corPega;
 public void paint(Graphics meuGrafico){
 meuGrafico.setColor(255, 128, 64);
 corPega = meuGrafico.getColor();
 }
}
O valor obtido na variável corPega é equivalente ao número hexadecimal agrupado FF, 80, 40 que se traduz em
inteiro como 255, 128, 64.
Desenhando uma imagem
Vimos anteriormente as primitivas que o J2ME nos oferece, agora vamos mostrar na tela uma imagem feita por nós
mesmo. Primeiro crie a sua imagem em algum editor externo a sua escolha, salve a imagem e coloque no mesmo
diretório onde se localiza o arquivo ClasseMeuCanvas.java.
Agora primeiramente vamos incluir o pacote java.io que contém o tratamento de exceção.
//arquivo ClasseMeuCanvas.java
import java.io.*;
import javax.microedition.lcdui.*;
Agora criar uma variável da classe Image.
//arquivo ClasseMeuCanvas.java
import java.io.*;
import javax.microedition.lcdui.*;
public class ClasseMeuCanvas extends Canvas {
 Image minhaImagem;
 public void paint(Graphics meuGrafico){
 }
}
Agora vamos usar o construtor para inicializar o objeto minhaImagem. Para isso vamos jogar a exceção.
J2ME 40
//arquivo ClasseMeuCanvas.java
import java.io.*;
import javax.microedition.lcdui.*;
public class ClasseMeuCanvas extends Canvas {
 Image minhaImagem;
 ClasseMeuCanvas throws Exception {
 }
 public void paint(Graphics meuGrafico){
 }
}
Agora dentro do construtor vamos inicializar o objeto minhaImagem utilizando o método createImage() da classe
Image, ele receberá como parâmetro o endereço da imagem que você criou.
//arquivo ClasseMeuCanvas.java
import java.io.*;
import javax.microedition.lcdui.*;
public class ClasseMeuCanvas extends Canvas {
 Image minhaImagem;
 ClasseMeuCanvas throws Exception {
 minhaImagem = minhaImagem.createImage("/Minha Imagem.png");
 }
 public void paint(Graphics meuGrafico){
 }
}
Agora dentro do método paint() vamos botar a nossa imagem para ser exibida, utilizando o método drawImage() da
classe Graphics, como parâmetro ele irá receber 4 atributos: o 1ª será o nome da variável da classe Image, o 2º será
o pixel x de onde vai ser desenhado, o 3º será o pixel y de onde vai ser desenhado, o 4º será a "raiz" do objeto, ou
seja, onde será a referência dos pixels x e y.
//arquivo ClasseMeuCanvas.java
import java.io.*;
import javax.microedition.lcdui.*;
public class ClasseMeuCanvas extends Canvas {
 Image minhaImagem;
 ClasseMeuCanvas throws Exception {
 minhaImagem = minhaImagem.createImage("/Minha Imagem.png");
 }
 public void paint(Graphics meuGrafico){
 meuGrafico.drawImage(minhaImagem, 30, 40, 
Graphics.LEFT|Graphics.TOP);
 }
J2ME 41
}
Criando uma atualização de tela
Vimos como colocar objetos na tela através de um comando, agora vamos ver como se cria uma atualização de tela,
para isso dentro do método paint() iremos usar o método repaint() que irá funcionar como um "retornador" para o
método paint() ser executado novamente. Para isso vamos primeiro criar uma variável inteira i na ClasseMeuCanvas
e vamos inicia-la com o valor 0.
//arquivo ClasseMeuCanvas.java
import javax.microedition.lcdui.*;
public class ClasseMeuCanvas extends Canvas {
 int i=0;
 public void paint(Graphics meuGrafico){
 }
}
Agora vamos desenhar um simples retângulo na tela, vamos usar como os primeiros atributos a variável i que
criamos (que no caso vale 0).
//arquivo ClasseMeuCanvas.java
import javax.microedition.lcdui.*;
public class ClasseMeuCanvas extends Canvas {
 int i=0;
 public void paint(Graphics meuGrafico){
 meuGrafico.drawRect(i, i, 100, 100);
 }
}
Vamos agora dar um incremento no i, para sempre que se retornar ao paint() seu valor ser acrescido de +1.
//arquivo ClasseMeuCanvas.java
import javax.microedition.lcdui.*;
public class ClasseMeuCanvas extends Canvas {
 int i=0;
 public void paint(Graphics meuGrafico){
 meuGrafico.drawRect(i, i, 100, 100);
 i++;
 }
}
Vamos agora finalmente aplicar o método repaint() dentro do método paint(), e ver a movimentação do nosso
retângulo na tela. Vamos mostrar abaixo o código completo.
//arquivo ClasseMeuCanvas.java
import javax.microedition.lcdui.*;
public class ClasseMeuCanvas extends Canvas {
 int i=0;
J2ME 42
 public void paint(Graphics meuGrafico){
 meuGrafico.drawRect(i, i, 100, 100);
 i++;
 repaint();
 }
}
Comandos
Vamos entrar agora na parte de entrada de comandos através das teclas do celular, primeiramente a classe Canvas
tem 3 métodos pré-definidos para isso, são o keyPressed() para quando se aperta a tecla do celular, keyRepeated()
para quando se segura a tecla do celular e keyReleased() para quando se solta a tecla do celular.
Primeiramente para usá-lo vamos fazer a chamada do método fora do médodo paint(), o método deverá ser do tipo
protected.
//arquivo ClasseMeuCanvas.java
import javax.microedition.lcdui.*;
public class ClasseMeuCanvas extends Canvas {
 protected void keyPressed(int getTecla){
 }
 public void paint(Graphics meuGrafico){
 repaint();
 }
}
Agora vamos definir uma ação para o caso de o usuário apertar a tecla que queremos, no caso vamos escolher a tecla
1 do celular, vamos colocar um if dentro do método keyPressed(). Você pode comparar com as constantes
'KEY_NUM1, KEY_NUM2, ..., KEY_STAR, KEY_POUND.
//arquivo ClasseMeuCanvas.java
import javax.microedition.lcdui.*;
public class ClasseMeuCanvas extends Canvas {
 protected void keyPressed(int getTecla){
 if (getTecla == KEY_NUM1);
 }
 public void paint(Graphics meuGrafico){
 repaint();
 }
}
Agora vamos colocar uma ação para quando pressionarmos a tecla, nesse caso vamos exibir uma mensagem no
console.
//arquivo ClasseMeuCanvas.java
import javax.microedition.lcdui.*;
J2ME 43
public class ClasseMeuCanvas extends Canvas {
 protected void keyPressed(int getTecla){
 if (getTecla == KEY_NUM1){
 System.out.println("Pressionou tecla 1 do celular");
 }
 }
 public void paint(Graphics meuGrafico){
 repaint();
 }
}
Você pode usar o mesmo processo apenas trocando método keyPressed() por keyRepeated() ou keyReleased().
Comandos de jogo
Vimos como obter as teclas do teclado padrão do celular (apenas os números e as teclas * e #), agora vamos ver
como pegar as teclas auxiliares.
Primeiramentevamos usar o mesmo método keyPressed(), keyRepeated() ou keyReleased() do módulo anterior.
//arquivo ClasseMeuCanvas.java
import javax.microedition.lcdui.*;
public class ClasseMeuCanvas extends Canvas {
 protected void keyPressed(int getTecla){
 }
 public void paint(Graphics meuGrafico){
 repaint();
 }
}
Agora as constantes das teclas auxiliares não podem ser pegas de forma direta, para isso vamos usar o método
getKeyCode() e como parâmetro vamos entrar o código da tecla que queremos, nesse caso usamos a tecla FIRE que
fica no meio das setas do celular.
//arquivo ClasseMeuCanvas.java
import javax.microedition.lcdui.*;
public class ClasseMeuCanvas extends Canvas {
 protected void keyPressed(int getTecla){
 if (getTecla == getKeyCode(FIRE));
 }
 public void paint(Graphics meuGrafico){
 repaint();
 }
}
J2ME 44
Agora vamos colocar uma ação para quando pressionarmos a tecla, nesse caso vamos exibir uma mensagem no
console.
public class ClasseMeuCanvas extends Canvas {
 protected void keyPressed(int getTecla){
 if (getTecla == getKeyCode(FIRE)){
 System.out.println("Pressionou tecla FIRE do celular");
 }
 }
 public void paint(Graphics meuGrafico){
 repaint();
 }
}
CommandListener
Agora entraremos na parte interativa onde o usuário pode interagir com as funções do celular através do teclado ou
da caneta digital.
Estrutura básica do CommandListener
Antes de trabalharmos para receber comandos, na nossa classe Midlet precisamos implementar a classe
CommandListener.
import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;
public class MinhaClasse extends MIDlet implements CommandListener{
 Display meuDisplay = Display.getDisplay(this);
 public void startApp() {
 }
 public void pauseApp() {
 }
 public void destroyApp(boolean unconditional) {
 }
}
Agora vamos inserir o método commandAction() que iremos usar diretamente para manipular as ações do teclado,
esse método deverá sempre ter 2 parâmetros, o primeiro é o objeto da classe Command (que veremos logo após) e o
outro é o objeto Displayable.
import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;
public class MinhaClasse extends MIDlet implements CommandListener{
 Display meuDisplay = Display.getDisplay(this);
 public void startApp() {
 }
J2ME 45
 public void pauseApp() {
 }
 public void destroyApp(boolean unconditional) {
 }
 public void commandAction(Command pegarComando, Displayable 
pegarDisplay){
 }
}
Criando um comando
Para criar um comando primeiro precisamos intanciar uma variável do tipo Command.
import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;
public class MinhaClasse extends MIDlet implements CommandListener{
 Display meuDisplay = Display.getDisplay(this);
 Command meuComando;
 public void startApp() {
 }
 public void pauseApp() {
 }
 public void destroyApp(boolean unconditional) {
 }
 public void commandAction(Command pegarComando, Displayable 
pegarDisplay){
 }
}
Agora vamos criar o objeto Command, para isso vamos usar como parâmetro respectivamente: 1º o texto que será
exibido na tela, 2º o tipo de comando e 3º a prioridade do comando.
import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;
public class MinhaClasse extends MIDlet implements CommandListener{
 Display meuDisplay = Display.getDisplay(this);
 Command meuComando = new Command("OK", Command.OK, 0);
 public void startApp() {
 }
 public void pauseApp() {
 }
 public void destroyApp(boolean unconditional) {
 }
 public void commandAction(Command pegarComando, Displayable 
J2ME 46
pegarDisplay){
 }
}
Detectando a ação de um comando
Agora vamos para a parte prática, vamos detectar uma ação de comando pelo teclado do celular, já temos o objeto
Command criado, agora vamos criar uma condição caso ele seja apertado.
Como vimos anteriormente é dentro do método commandAction() que fazemos os trabalhos com comandos, é
através dos dos atributo do tipo Command que vamos fazer a comparação com o objeto Command externo que
criamos, e vamos exibir uma mensagem no console.
import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;
public class MinhaClasse extends MIDlet implements CommandListener{
 Display meuDisplay = Display.getDisplay(this);
 Command meuComando = new Command("OK", Command.OK, 0);
 public void startApp() {
 }
 public void pauseApp() {
 }
 public void destroyApp(boolean unconditional) {
 }
 public void commandAction(Command pegarComando, Displayable 
pegarDisplay){
 if(pegarComando == meuComando){
 System.out.println("Pressionou o botão OK");
 }
 }
}
Agora calma, AINDA não vai acontecer nada quando apertarmos o botão, para isso precisamos criar a tela que irá
"escutar" o comando que iremos colocar, podemos fazer a tela com qualquer objeto tipo Alert, TextBox, etc... no
nosso caso vamos usar um simples Form.
import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;
public class MinhaClasse extends MIDlet implements CommandListener{
 Display meuDisplay = Display.getDisplay(this);
 Command meuComando = new Command("OK", Command.OK, 0);
 Form meuForm = new Form("Título do formulário");
 public void startApp() {
 }
J2ME 47
 public void pauseApp() {
 }
 public void destroyApp(boolean unconditional) {
 }
 public void commandAction(Command pegarComando, Displayable 
pegarDisplay){
 if(pegarComando == meuComando){
 System.out.println("Pressionou o botão OK");
 }
 }
}
Agora dentro do método startApp() vamos adicionar o comando à tela do Form através do método addCommand().
import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;
public class MinhaClasse extends MIDlet implements CommandListener{
 Display meuDisplay = Display.getDisplay(this);
 Command meuComando = new Command("OK", Command.OK, 0);
 Form meuForm = new Form("Título do formulário");
 public void startApp() {
 meuForm.addCommand(meuComando);
 }
 public void pauseApp() {
 }
 public void destroyApp(boolean unconditional) {
 }
 public void commandAction(Command pegarComando, Displayable 
pegarDisplay){
 if(pegarComando == meuComando){
 System.out.println("Pressionou o botão OK");
 }
 }
}
Agora vamos adicionar o "escutador" no Form, para detectar se pressionamos ou não algum botão.
import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;
public class MinhaClasse extends MIDlet implements CommandListener{
 Display meuDisplay = Display.getDisplay(this);
 Command meuComando = new Command("OK", Command.OK, 0);
 Form meuForm = new Form("Título do formulário");
J2ME 48
 public void startApp() {
 meuForm.addCommand(meuComando);
 meuForm.setCommandListener(this);
 }
 public void pauseApp() {
 }
 public void destroyApp(boolean unconditional) {
 }
 public void commandAction(Command pegarComando, Displayable 
pegarDisplay){
 if(pegarComando == meuComando){
 System.out.println("Pressionou o botão OK");
 }
 }
}
Por fim, colocamos normalmente o método setCurrent() da classe Display.
import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;
public class MinhaClasse extends MIDlet implements CommandListener{