Anda di halaman 1dari 10

NetBeans IDE NetBeans Platform Enterprise Plugins Docs & Support Community Search

HOME
Primeiros passos com o NetBeans e Java
Contribuio de Ben Suter como parte da competio Win With NetBeans
Esse artigo assume que voc tenha instalado com xito o NetBeans 4.0 e um Java SDK (tambm conhecido como JDK).
Primeiro vamos explorar nosso novo IDE e um dos aplicativos de amostra incorporado. Na primeira seo faremos uso intenso de capturas de tela e permitiremos que voc mergulhe - imediatamente aps completar a instalao
NetBeans. A seguir, iremos aprender como usar o NetBeans para modificar, compilar e executar um aplicativo Java. Ao progredirmos, hver menos capturas de tela e mais cdigo-fonte. Nosso passo ir acelarar ao aprendermo
usar algumas das funes mais avaadas de produtividade e aprimoramento do NetBeans, ao adicionar aprimoramentos interessantes no aplicativo de amostra "Anagram Game". No final deste artigo, voc saber como usar o N
para escrever cdigo Java que abra e analise documentos XML, solicita a entrada pelo usurio em caixas de dilogo simples, e muito mais. Mais importante, voc estar bem apto para criar e estender aplicativos Java. Vamos m
Primeiros passos: Explorando o NetBeans e Iniciando um Projeto 1.
Modificando o cdigo-fonte 2.
Porque to previsvel? 3.
Uma dose saudvel do java.util.Random 4.
Carregando listas de palavras a partir de arquivos 5.
Listagem dos arquivos relacionados 6.
Primeiros passos: Explorando o NetBeans e Iniciando um Projeto
Quando inicie pela primeira vez o NetBeans no menu Iniciar, ele foi carregado em 15 segundos. Em alguns casos, isso pode levar mais tempo na primeira vez devido ao fato de que o NetBeans est conhecendo seu sistema.
Neste ponto voc deveria se sentir a vontade para explorar um pouco - e quando em dvida, escolha "Cancelar"! Quando estiver pronto para continuar, siga em frente e clique no boto "Projeto de amostra" sob o grfico Bem-vin
Choose page language
Primeiros passos com o NetBeans e Java https://netbeans.org/competition/win-with-netbeans/get-started-with-nb_...
1 de 10 9/2/2014 8:02 PM
Por padro, a localizao do projeto ser definda na sua pasta principal. Vamos adiante para criar uma pasta denominada "code" na unidade C:, e a seguir uma unidade denominada "java" na mesma. Esnto use o boto Procura
escolher esta nova pasta como a localizao do projeto, como mostrado na prxima captura de tela.
Aps clicar em "Concluir" na caixa de dilgo acima, aparece uma caixa de dilogo "Varrendo classpaths do projeto" que pode durar cerca de um minuto.
Agora a aba "Projetos" no "painel" esquerdo exibe um n nico denominado "AnagramGame". A tela splash de boas vindas ainda est visvel na rea "principal". A expanso do n "AnagramGame" na aba "Projetos", e sequencia
Primeiros passos com o NetBeans e Java https://netbeans.org/competition/win-with-netbeans/get-started-with-nb_...
2 de 10 9/2/2014 8:02 PM
expandir seus ns secundrios, resulta na seguinte estrutura de rvore:
Acima Eu redimensionei a janela principal do NetBeans para apenas mostrar o "painel" esquerdo.
Devemos observar que este aplicativo de amostra composto de dois "pacotes de cdigo-fonte (um uma biblioteca, e outro a interface do usurio) e um "pacote de teste (para a biblioteca). Devemos tambm observar cada class
da Fields/Constructors/Methods, h um n "Bean Patterns" (embora este n esteja vazio para cada classe atual acima). Neste artigo no iremos usar ns "Bean Pattern", mas voc deveria saber que eles ajudam a tornar seu cd
modular, flexvel e reutilizvel atravs do uso de componentes JavaBeans.
A seguir, clique duas vezes no n "About.java" - voc ver algo parecido com isso:
Se desejar, poder fechar a aba "Bem-vindo" na rea/painel principal. Neste momento voc uma vez mais pode desejar explorar o NetBeans por si prprio: voc pode abrir arquivos de cdigo-fonte, visualizar "formas" visuais par
algumas das classes de interface do usurio, ou examinar arquivos no de cdigo fonte ao alternar da aba "Projetos" para a aba "Arquivos" no painel esquerdo. Ali possvel examinar diversos arquivos .properties e script de bui
No menu "Ferramentas", a janela "Opes" lhe dar uma idia de quo flexvel e personalizvel o IDE realmente !
Como uma boa medida e para assegurar que voc seja capaz de descansar e saber como reiniciar novamente, vamos adiante e fechar e a seguir reabrir o NetBeans. Caso o faa, voc ver que desta vez o IDE abre com uma
Primeiros passos com o NetBeans e Java https://netbeans.org/competition/win-with-netbeans/get-started-with-nb_...
3 de 10 9/2/2014 8:02 PM
principal em branco, e a rea "Projetos" ir mostrar o projeto AnagramGame. Agora clique no boto "Executar projeto principal (F6)" na barra de ferramentas ( verde e amarelo; voc pode passar o mouse sobre ela para ver o tt
cone), e o NetBeans abre uma janela "Sada", contendo o seguinte texto:
init:
deps-jar:
Created dir: C:\code\java\AnagramGame\build\classes
Compiling 3 source files to C:\code\java\AnagramGame\build\classes
compile:
run:
Alm disso, aparece uma pequena janela, a interface do usurio para o AnagramGame.
Dei a primeira resposta certa em minha primeira tentativa! Acho que ajudou o fato de ter navegado atravs das pastas e arquivos do projeto anterirmente, j que me lembro de ter visto uma longa lista de palavras (a lista de palav
misturadas, presumo) e isso pode ter me ajudado. Vamos ter isso em mente para mais tarde...
Modificando o cdigo-fonte
Primeiro ns alteramos o texto de uma das mensagens ao usurio no aplicativo de amostra. No painel "Projetos", clique duas vezes no n toy.anagram.ui.Anagram e o seu cdigo-fonte ser aberto como uma nova aba na rea da
principal. O canto superior direito da aba tem um boto "Projeto" e "Cdigo-fonte". Escolha o boto "Cdigo-fonte" caso j no esteja selecioado - e voc vera agora o cdigo-fonte Java para a classe Anagram no editor. Clique co
boto direito do mouse na margem esquerda e assegura que "Mostrar nmeros de linhas" esteja selecionado. Siga para a linha n 211 (CTRL-G rpido). Esta linha deveria ler:
feedbackLabel.setText("Incorrect! Try again!");
Ns iremos (trib=vialmente) alterar o texto, compilar e executar o aplicativo, adivinhas errado uma palavra, e ver a mensagem modificada. Eu alterei a minha para ler:
feedbackLabel.setText("Not quite ... please try again!");
Neste momento, observe que no ttulo da aba do editor agora h um pequeno astersco entre a palavra "Anagramas" e o "X" (comando Fechar). Este astersco indica que o arquivo foi modificado, mas ainda no foi salvo. Arquivo
(ou CTRL-S) ir salvar nossas alteraes. Portanto, neste momento, nosso arquivo de cdigo-fonte foi modificado e salvo, mas o arquivo da classe compilada ainda reflete o cdigo antigo. Aqui onde o NetBeans ir tratar das d
etapas de uma s vez por ns: clique no cone verde/amarelo "Executar projeto principal" ou pressione F6. O aplicativo ser aberto como antes. No entanto, no console de sada, voc deveria ver o seguinte:
init:
deps-jar:
Compiling 1 source file to C:\code\java\AnagramGame\build\classes
compile:
run:
Como voc pode ver, antes de executar o aplicativo, o NetBeans (de fato nosso script Ant do build) verificou que aquele arquivo foi modificado e compilou o mesmo por ns antes de executar a "tarefa de execuo". Siga adiante
uma adivinhao, preferencialmente incorreta. Se tudo correr como o esperado, a mensagem de feedback deveria agora aparecer com o texto acima personalizado.
Siga adiante e jogue algumas rodadas - Eu fiquei preso em "iccmustsnaec". Para poder demonstrar os recursos essencials do NetBeans, irei trapacear e pesquisar a soluo no cdigo-fonte. Isso pressupem que as verses mis
de cada palavra esto listadas nos arquivos de cdigo-fonte do projeto, ao invs de ser gerada cada vez ao misturar aleatoriamente a palavra original. Em um minuto, ns veremos que essa de fato a natureza do aplicativo atua
tarde faremos algo sobre isso...
Na aba "projetos", clique com o boto direito do mouse no n "Pacotes de cdigo-fonte" e selecione "Localizar..." no menu de contexto. Voc ser apresentado com a seguinte tela, denominada "Localizar":
Na captura de tela, voc pode ver que Eu j inseri o texto "iccrmutsnaec" como meu termo de pesquisa. Ns iremos deixar as outras configuraes como esto e iremos clicar em "Pesquisar" para iniciar o processo. Aparecer um
aba junto ao console de sada, indicando os resultados da pesquisa. Como voc pode ver, foi encontrada uma coincidncia, no arquivo "WordLibrary.java" na linha n 53:
Primeiros passos com o NetBeans e Java https://netbeans.org/competition/win-with-netbeans/get-started-with-nb_...
4 de 10 9/2/2014 8:02 PM
Clique duas vezes na coincidncia (o n denominado "iccrmutsnaec", [posio 63:10] acima). Isso ir abrir o arquivo de cdigo-fonte correspondnete no editor. Assegure que a linha apropriada esteja visvel e realce a frase coinci
que voc deveria ver que o termo "iccrmutsnaec" a sexta entrada em uma matriz de sequncia de caracteres; essa matriz denominada "SCRAMBLED_WORD_LIST". Observe agora que imediatamente acima desta matriz h
matriz de sequncia de caracteres, mas nessa as entradas paracem ser palavras reais no idioma Ingls. Vamos ver porque aquela matriz denominada: "WORD_LIST". Neste ponto, estou seguro, que ns verificamos que a solu
para a palavra "iccrmutsnaec" misturada pode ser encontrada na sexta entrada da matriz "WORD_LIST". claro que possvel que o autor original escolheu um mapeamento menos bvio entre o texto claro e suas verses mistu
mas afortunadamente no o fez! Portanto, examinando a linha n 16 ns vemos a palavra "circumstance" Ao digitar esta palavra no aplicativo (caso entrementes voc o tenha fechado, poder jogar novamente at alcanar o pon
apropriado), voc ver a seguinte tela:
Porque to previsvel?
Agora j sabemos como abrir um arquivo para edio, como modificar o cdigo-fonte, como compilar e executar o aplicativo, como pesquisar o cdigo-fonte e como trapacear. Vamos juntar alguns desses conhecimentos para tor
AanagramGame mais interessante. Ns iremos implementar a gerao dinmica de palavras misturadas, eliminando a necessidade de manter uma lista de palavras misturadas no cdigo-fonte. Como resultado, iremos eliminar u
forma de trapacear. Na segunda etapa ns iremos assegurar que as verses misturadas sejam geradas aletoriamente, portanto, a forma de jogar se torna mais interessante.
Ainda no cdigo-fonte WordLibrary, voc ver um mtodo denominado "getScrambledWord". Examinando mais de perto este mtodo, ns veremos que sua implementao extramamente simples.
return SCRAMBLED_WORD_LIST[idx];
Esse de fato um bom lugar para fazerr nossas modificaes. Vamos comear por alterar esta linha (n 126) para o seguinte:
return generateScrambledWord(idx);
O NetBeans agora marca esta linha de cdigo com uma linha ondulada sublinhada vermelha e com um cone X vermelho na margem, indicando que ali encontrou um problema de sintaxe em nosso cdigo-fonte. Se colocarmos o
sobre qualquer parte do cdigo-fonte sublinhado, aparecer uma pequena mensagem, indicandando que ele no reconhece a assinatura do mtodo generateScrambledWord(int). claro, ns ainda no criamos este mtodo, por
vamos faz-lo agora. Basta adicion-lo no fim da classe, iniciando na linha n 147:
/**
* For a specified index, finds the corresponding word in the
* dictionary and generates a scrambled version of this word.
* @param idx index of the word to be scrambled
* @return a scrambled version of the relevant word
*/
protected static String generateScrambledWord(int idx)
{
int j = 0;
String word;
String scrambled = "";
java.util.Random r;
r = new java.util.Random();
word = getWord(idx);
for (j = 0; j <word.length(); j++)
{
if ( r.nextBoolean() )
scrambled = scrambled + word.charAt(j);
else
scrambled = word.charAt(j) + scrambled;
}
return scrambled;
}
O propsito de nossa funo generateScrambledWord(int) o de retornar uma verso misturada da entrada do dicionrio especificada pelo argumento inteiro, o ndice. Estou certo que ns poderamos pensar sobre diferentes ma
de misturara (reordenar) as letras de uma palavra e, voc tem a liberdadede de implementar o corpo deste mtodo da forma que achar melhor. Isso poderia ser simples como reverter a ordem das letras, mas ento o jogo poderia
muito fcil (mesmo assim, tente faz--lo). Alternativamente, poderamos trocar a posio de quaisquer letras adjacentes, um par de cada vez, at alcanarmos o fim da palavra. Deixe sua imaginao fluir e encontre um algortmo
seja divertido de implementar e que fornea um jogo divertido. Permita-me explicar um pouco a pensamento por trs da implementao que forneci neste exemplo. Eu escolhi usar o utilitrio de gerao de nmeros aleatrios
incorporado no Java, de tal forma que o resultado da mistura de uma determinada palavra ainda parea diferente cada vez que for gerada. Ns contrumos a palavra misturada, uma letra de cada vez, e para cada nova letra, deix
que um nmero aleatrio determine se a nova letra deve ser adicionada no incio ou no fim da palavra fragmentada. Desta forma, ns construmos um nova palavra, consistindo em todas as letras da palavra original, mas em uma
sequncia um pouco aleatria. Neste ponto, siga adiante e execute o aplicativo. Desta vez no fui capaz de adivinhar corretamente muitas das palavras, mas devido ao grau de aleatoridade do sequenciamento, algumas vezes po
uma palavra misturada que se parece de perto com a forma no misturada. Voc pode tentar modificar o algortmo acima para reordenar pares de caracteres ao invs de caracteres individuais e, as palavras resultantes podem se
pouco mais fceis de serem indentificadas. Caso voc implemente um algortmo que cria um jogo especialmente desafiante, compartilhe o mesmo com os leitores deste artigo.
Neste momento, ns no estamos mais fazendo uso do dicionrio de palavras misturadas (a matriz SCRAMBLED_WORD_LIST), portanto, vamos seguir adiante e remov-lo do cdigo-fonte WordLibary.java (linhas 57 a 104).
Uma dose saudvel do java.util.Random
Caso voc jogue a nova verso do jogo, poder (como Eu fiz) ficar frustado com sua inabilidade de identificar as palavras subjacentes. O que fazer? Bom, ns sabemos que as palavras originais so armazenadas em um dicion
simples e, tambm sabemos que o jogo passa por este dicionrio uma palavra de cada vez, do incio ao fim. Portanto, com o cdigo atual, como temos acesso ao cdigo-fonte, ainda podemos trapacear ao manter o acompanham
quantas palavras j tentamos e ao examinar a entrada correspondente do dicionrio. Quando executo o jogo, a primeira palavra misturada que vejo noiatabsrct e no a reconheo imediatamente. Mas se formos para a linha n
WordLibrary.java, vemos que a entrada do dicionrio abstraction. Nosso prximo objetivo definir a aleatoridade da ordem com a qual as palavras so tiradas do dicionrio, e vamos ento fazer isso de novo usando a classe Ra
do pacote java.util. J que estamos usando esta classe duas vezes, vamos examinar um pouco sua documentao API, para termos um entendimento bsico do ela faz por ns:
Uma instncia dessa classe usada para gerar um fluxo de nmeros pseudo-aleatrios. A classe usa uma semente de 48 bits, que modificada usando uma frmula "Linear Congruential". (Consulte Donald Knuth, The Art of Co
Programming, Volume 2, Seo 3.2.1.) Se duas instncias de Random forem criadas com a mesma semente, e a mesma chamada do mtodo de sequncia feita para cada, elas iro gerar e retornar sequncias idnticas de n
At agora, ns usamos o construtor de argumento zero para o java.utilRandom, por convenincia. Como os comentrios API acima indicam, ns deveramos tomar cuidado em inicializar cada instncia de Random com uma sem
Primeiros passos com o NetBeans e Java https://netbeans.org/competition/win-with-netbeans/get-started-with-nb_...
5 de 10 9/2/2014 8:02 PM
nica, caso contrrio o uso repetitivo do aplicativo pode no ter uma natureza aleatriia suficiente. Examinando a documentao para o construtor de argumento zero, podemos ver que ela de fato usa a hora atual (em milesegun
como uma semente, portanto, nosso cdigo atual est OK e podemos ento seguir em frente para coisas mais importantes.
Quais so as modificaes que precisamos fazer para tornar aleatria a ordem das palavras escolhidas no dicionrio? Em nossa classe WordLibrary, vemos que h dois mtodos que percem relevantes: getWord(int idx) e
getScrambledWord(int idx) aceitam como seu argumento um ndice para o dicionrio. Vamos primeiro colocar o cursor no mtodo getWord, e a seguir, clicar com o boto direito do mouse e escolhar a opo Localizar usos. Ns v
trs chamadas para este mtodo (uma em WordLibraryTest, duas em WordLibrary itself). Cada uma destas usada internamente pelo componente WordLibrary (incluindo seu teste de harness) e nada precisa aqui ser modificado
seguir, colocaremos nosso cursor no mtodo getScrambledWord, e a seguir pressionar Alt-F7. Uma vez mais vemos trs usos do mtodo, mas agora dois desles esto na classe Anagrams e vamos focar ateno nos mesmos. E
ambos os casos (linhas 28 e 195) o valor do argumento passado para getScrambledWord uma varivel denominada wordIdx. Essa prpria varivel est declarada na linha 22 e inicializada como zero. Vamos pesquisar os usos
varivel wordIdx: h trs.
Na linha 28 ns vemos que o construtor de nosso jogo preenche inicialmente o controle de palavra misturada usando a primeira palavra no dicionrio. 1.
No mtodo nextTrialActionPerformed a varivel wordIdx incrementada (observe que ela repete em zero quando todas as palavras tiveram sido tentadas) e ento usada para preencher o controle de palavra misturada c
novo valor.
2.
No mtodo guessedWordActionPerformed as adivinhaes do usurio so avaliadas, usando o valor atual da varivel wordIdx para indicar a palavra relevante. 3.
Agora vemos que a varivel wordIdx variable determina qual palavra escolhida aps cada adivinhao, e esta varivel somente modificada em um lugar, a linha n 192 do Anagrams.java:
wordIdx = (wordIdx + 1) % WordLibrary.getSize();
Para tornar aleatria a ordem de escolha das palavras no dicionrio, precisamos modificar esta linha para que a wordIdx pegue os valores aleatrios que estejam dentro dos limites inferior e superior do dicionrio. O mtodo
java.util.Random.nextInt(int n) faz exatamente isso, portanto, vamos seguir adiante e substituir a linha n 192 pela seguinte linha de cdigo:
wordIdx = new java.util.Random().nextInt(WordLibrary.getSize());
Para verificar se isso alcana o efeito desejado, precisamos claro jogar uma vez mais! A primeira palavra est se tornando fcil agora, j que sempre parece seu uma forma misturada da palavra abstraction. De fato, o construto
Anagram sempre comea o jogo ao escolher a primeira palavra no dicionrio, j que a varivel wordIdx incialiizada de forma esttica com um valor de zero. Mas aps passar da primeira palavra no jogo, todas as escolhas
subsequentes parecem ser adequadamente imprevisveis. Portanto, esperamos ter tornado o jogo um pouco mais divertido, e ns temos apenas uma forma mais (assumindo que possa ler o cdigo-fonte) de trapacear. Caso gost
pode seguir adiante e assegurar que a primeira palavra do jogo seja tambm escolhida aleatoriamente do dicionrio. Para fazer isso, assegure que o valor inicial da varivel wordIdx seja calculado da mesma forma que os valores
subsequentes - com isso, a linha n 22 do Anagrams.jva, se torna:
private int wordIdx = wordIdx = new
java.util.Random().nextInt(WordLibrary.getSize());
Carregando listas de palavras a partir de arquivos
Se voc como Eu, poder adivinhar que elxical a forma misturada de lexical, mas quando confrontado com lasiugsidintinhbe iria estar clicando depressa em Nova palavra. O que torna indistinguishable mais difcil em mdia do
lexical? Quanto menos letras houve na palavra original, mais provavelmente a forma misturada no ser muito diferente, em funo de nosso algortmo atual para misturar as palavras. Geralmente acho ser mais fcil desmisturar
palavar quo mais curta for, independente de como ela foi misturada. Para um iniciante, um conjunto de palavras mais curtas seria divertido, mas para um jogador mais experiente, um conjunto de palavras longas seria apropriado
claro que h outras caracterstcas alm do comprimento da palavra, tal como se a palavra raramente usada, ou se faz parte de um discurso, idioma ou tpico. Podemos usar estas observaes para tornar o jogo mais til e, pod
aprender algo novo sobre o NetBeans e Java, j que estamos aqui?
Nesta seo, n iremos externalizar o dicionrio, o que significa que ser possvel jogar o jogo com um nmero diferente de listas de palavras e que o usurio poder suprir sua prpria lista personalizada de palavras. H vrias m
de fazer isso. Ns iremos implementar esta funcionalidade ao ler um arquivo contendo uma lista de palavras, estruturada e formatada como XML. No final desta seo, voc saber como abrir e ler arquivos do sistema de arquivo
ou da Web e analisar com eficincia um arquivo XML simples.
Ns desejamos adicionar um novo item de menu para carregar uma lista externa de palavras. Para fazer isso, ns alternamos para o modo de projeto. Ns iremos de algo como isso:
Para isso:
Primeiros passos com o NetBeans e Java https://netbeans.org/competition/win-with-netbeans/get-started-with-nb_...
6 de 10 9/2/2014 8:02 PM
No modo de projeto, ns tambm vemos uma painel na direita denominado Inspetor. Inicialmente ele se parece como:
O painel Inspetor nos mostra uma estrutura hierarquica dos componentes Wing que compem nossa interface grfica do usurio. Se expandirmos o n [JFrame]", veremos que o primeiro componente denominado como mainM
[JMenuBar]. Este por sua vez contm um item fileMenu [JMenu], que por sua vez contm dois ns adicionais: aboutMenuItem [JMenuItem] e exitMenuItem [JMenuItem]. O padro aqui visto que cada n denominado com o no
varivel correspondente. O tipo de componente est entre colchetes. O quadro pincipal de fato a prpria classe Anagrams (ela herda de JFrame) e, portanto, o Inspetor no mostra um nome de instncia para aquele primeiro
componente. Nosso objetivo o de adicionar um comando de menu para carregar uma lista externa de palavras, portanto, vamos usar o Inspetor para adicionar um novo item entre as entradas Sobre e Sair do menu Arquivo.
Clique com o boto direito do mouse no n fileMenuItem, escolha Adicionar e a seguir JMenuItem. Um novo item de menu adicionado na terceira posio aps o item Sair. Inicialmente o NetBeans fornece um nome este item
auto-gerado, mas ns iremos alterar isso para openNewListMenuItem ao clicar com o boto direito do mouse no novo item e escolher Renomear. Finalmente, clicamos com o boto direito do mouse novamente no novo item e
escolhemos Mover acima, o que vai resultar na ordem desejada.
Agora selecionamos exitMenuItem e clicamos no boto Proprieadeas no painel Propriedades imediatamente abaixo do Inspetor. Entre outras coisas, ns vemos trs propriedades interessantes: mnemonic, text, toolTipText. Para
item especfico de menu, os valores para esses so, respectivamente, S, Sair e Sair equipe, Sair!. Vamos selecionar nosso novo item de menu e definir suas propriedades correspondentes como A, Abrir lista de palavras, Escolhe
arquivo de lista de palavras, substituindo a lista atual respectivamente.
A seguir, desejamos adicionar cdigo que ser executado sempre que este item de menu for selecionado pelo usurio: O NetBeans nos ajuda aqui de novo: no Inspetor, clique com o boto direito do mouse no n openNewListMe
escolha Eventos, a seguir, Aes, e a seguir actionPerformed nos menus suspensos. O NetBeans ir criar um mtodo "event-handler" e retorn-lo para a vista de Cdigo-fonte, para que estejamos prontos para redigir a implemen
necessria. O novo mtodo recebe automaticamenteo nome openNewListMenuItemActionPerformed, mas seguro renome-lo usando os comandos Refactor, caso assim o deseje. Um comentrio para os que tenham experinc
anterior com as ferramentas de projeto de IGU Swing: bom visualizar qo limpo e bem estruturado, nomeado e formatado est o cdigo auto-gerado. Por exemplo, o cdigo para nossos trs itens no menu Arquivo mantm a me
ordem que os prprios menus. Mas voltando para nossa tarefa: quando o usurio seleciona o item de menu Abrir a lista de palavras, ns faremos que escolha um arquivo sem seu sistema de arquivos local, e a seguir tente abrir,
e usar esta nova lista de palavras. Se o arquivo estiver indisponvel ou no contm uma lista vlida de palavras, o jogo ir continuar a usar a lista atual de palavras. Aqui est o que o NetBeans nos forneceu para iniciar:
private void openNewListMenuItemActionPerformed(java.awt.event.ActionEvent evt) {
// TODO add your handling code here:
}
Nosso Carregador ir pegar um URL como seu argumento principal, portanto, precisamos gerar um URL apropriado com base no arquivo escolhido pelo usurio. Primeiro ns criamos uma instncia de JFileChooser e a usamos p
exibir a caixa de dilogo Abrir arquivo. Se o usurio seleciona um arquivo, ns geramos um URL para o mesmo ao pr-anexar o arquivo:/// protocolo ao nome do caminho absoluto.
private void openNewListMenuItemActionPerformed(java.awt.event.ActionEvent evt) {
/* The "initialDirectory" variable determines what directory is first
displayed
Primeiros passos com o NetBeans e Java https://netbeans.org/competition/win-with-netbeans/get-started-with-nb_...
7 de 10 9/2/2014 8:02 PM
* when choosing a new word list. An empty or a null string will start the
chooser
* in the user's default directory, which for Windows is typically "My
Documents",
* and for *nix is typically the user's home directory.
*/
String initialDirectory = "";
String fileURL;
JFileChooser chooser;
int returnVal;
chooser = new JFileChooser(initialDirectory);
returnVal = chooser.showOpenDialog((Component) evt.getSource());
if ( returnVal == chooser.APPROVE_OPTION )
{
/* To create a URL for a file on the local file-system, we simply
* pre-pend the "file" protocol to the absolute path of the file.
*/
fileURL = "file:///" + chooser.getSelectedFile().getAbsolutePath();
this.loadWordList(fileURL);
}
}
O mtodo acima demonstra como voc pode apresentar uma caixa de dilogo para escolher o arquivo. Isso ento chama o mtodo ainda desconhecido loadWordList. Esse mtodo deveria tomar como argumento o endereo de
arquivo de lista de palavras, e assumindo que o arquivo esteja OK, substituir a lista atual de palavras. Aqui est como se parece o mtodo:
/**
* Attempts to open and parse an XML file containing a
* word list. If successful, this list of words will be
* used in place of the current list.
* The URL can for example point to a document on the local file-system,
* such as "file:///C:/testlist.xml", or to a document on the World Wide Web,
* such as "http://www.stanford.edu/~bsuter/simplewordlist.xml".
*
* @param url Address of an XML document containing a word list.
*/
protected void loadWordList(String url)
{
/* Create an instance of the loader */
com.toy.anagrams.lib.WordListFileLoader wlfl = new
com.toy.anagrams.lib.WordListFileLoader();
/* Open and parse the file, replace the current word list with the newly
loaded list. */
WordLibrary.setWordList(wlfl.loadList(url));
/* Since the new word list's number of entries may be different from the old,
* we make sure that the current value of wordIdx is valid for the new list.
*/
wordIdx = new java.util.Random().nextInt(WordLibrary.getSize());
}
Vemos que h uma nova classe em jogo, denominada WordLisdtFileLoader. Alm disso, a classe WordLibrary tem um novo mtodo denominado setWordList. Adicionei este mtodo na linha n 125, bem simples:
public static void setWordList(String[] wordList)
{
if ( wordList != null )
WORD_LIST = wordList;
}
Todo o cdigo-fonte para a classe WordListFileLoader est aqui disponvel, mas vamos examinar as partes importantes, uma de cada vez. Esta nova classe tem um mtodo signficativo, assim como uma classe interna que herda
org.xml.sax.helpers.DefaultHandler. Uma instncia do WordListFileLoader para abrir, ler, analisar e avaliar o contedo de um arquivo XML de um sistema de arquivos local ou de um documento XML acessvel via HTTP. Vamos
examinar a descrio de alto nvel sobre o que faz o mtodo WordListFileLoader.loadList:
Obtm um InputStream para o documento especificado
Cria um analisador SAX (API simples para XML) para este documento
Define um "handler" que ir responder a todos os eventos relevantes vindo do analisador SAX
H diversas formas para analisar um documento XML no Java. A abordadgem DOM (Document Object Model) pervasiva, resulta em um modelo hierarquico na memria para o conjunto de ns de documentos XML. Em nosso ca
estrutura de nosso conjunto de dados simples (ula lista de palavras), e ns imeditamente convertemos a lista analisada em uma matriz String[], portanto, manter um documento XML na memria e de pouco valor. O SAX uma
abordagem com base no evento quer a classe "handler" ouve para eventos do analisador que ocorrem quando o analisador encontra um elemento XML, ou um atributo, ou o fim de um elemento. O "handler" pode decidir escolhe
processar ou desconsiderar tais eventos. Caso adequada para o propsito, a abordagem SAX tende a ser prefervel, j que pode tratar com facilidade documentos muito grandes.
public String[] loadList(String url)
{
InputStream is;
try {
URL u = new URL(url);
is = u.openConnection().getInputStream();
} catch (IOException ioe) {
report("Unable to open or find the specified wordlist.");
is = null;
}
if (is == null)
{
report("Unable to load the requested wordlist. An error occurred while
opening the file.");
return null;
}
SAXParserFactory parserFactory = SAXParserFactory.newInstance();
SAXParser parser;
try {
parser = parserFactory.newSAXParser();
} catch ( ParserConfigurationException pce ) {
report("Error setting up the XML Parser. The parser is not properly
Primeiros passos com o NetBeans e Java https://netbeans.org/competition/win-with-netbeans/get-started-with-nb_...
8 de 10 9/2/2014 8:02 PM
configured. Loading aborted.");
return null;
} catch ( SAXException saxe ) {
report("Error setting up the XML Parser. Loading aborted.");
return null;
}
try {
WordListHandler handler = new WordListHandler();
parser.parse(is, handler);
} catch ( Exception e ) {
report("Unable to load the list, probably while performing SAX
parsing.");
return null;
}
return this.list;
}
Como acima descrito, o "handler" SAX precisa impmentar diveros "handlres" de eventos, em nosso caso extamente trs: iniciando um elemento, o contedo de um elemento e fechando um elemento. O cdigo resultante se parec
public class WordListHandler extends DefaultHandler
{
protected String nodeType;
protected ArrayList al;
public void startElement(String uri, String localName, String qName,
Attributes attributes) throws SAXException
{
if ( qName == "word" )
{
nodeType = "word";
} else if ( qName == "wordlist" ) {
al = new ArrayList();
}
}
public void endElement(String uri, String localName, String qName) throws
SAXException
{
if ( qName == "word" )
{
nodeType = null;
} else if (qName == "wordlist" ) {
/* Cast the ArrayList to a an array of String objects. */
list = (String[]) this.al.toArray(new String[al.size()]);
}
}
public void characters(char[] chars, int start, int length) throws
SAXException
{
if ( this.nodeType == "word" )
{
this.al.add(new String(chars, start, length).trim());
}
}
}
Nossa estrutura do documento da lista de palavras contm apenas doi tipos de elementos XML: element: <word> e <wordlist>. Nesta listagem de cdigo, voc pode ver que o trabalho real de adicionar uma nova palavra lista oc
dentro do mtodo de caracterstica. Os outros dois mtodos mantm o registro que qual n estamos no momento lendo, e executa a configurao apropriada e aes de limpeza, tal como inicializar a nova lista de palavras e atua
campo da lista de classe externa, respectivamente.
Todo o cdigo Java WordListFileLoader est aqui disponvel. Um documento de amostra de lista de palavras est aqui disponvel ou pode se parecer com:
<?xml version="1.0" encoding="utf-8" ?>
<wordlist>
<word>welcome</word>
<word>jacuzzi</word>
<word>elefant</word>
<word>abracadabra</word>
</wordlist>
Portanto, agora voc capaz de criar suas prprias listas de palavras ao criar e editar arquivos XML em um processador de palavras ou semelhante. Tendo algum tempo, tenho certeza que voc ir criar listas de palavras divertid
temticas. Voc no gostaria de compartilhar as mesmas com outras pessoas? Voc gostaria de usar listas de palavras criadas por outras pessoas, talvez para tornar a adivinhao de palavras mais desafiante? A boa notcia q
j quase implementamso isso. A m notcia que desta vez no vou lhe guiar pelas etapas necessrias. Primeiro crie um novo item de menu (talvez chamado de Download arquivo de listas) da mesma forma que criamos o coma
Abrir arquivos de listas. Adicione um mtodo para a ao actionPerformed correspondente (como antes) e use o seguinte cdigo para implementar o mtodo:
private void downloadNewListMenuItemActionPerformed(java.awt.event.ActionEvent
evt) {
String listURL;
String prompt = "Enter the URL to an XML word list:";
String initialValue = "http://";
listURL = (String) javax.swing.JOptionPane.showInputDialog(prompt,
initialValue);
/* Perform some simple validation before attempting to download the new word
list */
if (listURL != null && listURL.length() > 0 && listURL != initialValue)
{
this.loadWordList(listURL);
}
}
Isso tudo que cobriremos neste artigo, mas espero que voc tenha visto quo direto e eficiente desenvolver cdigo de iinterface gficado usurio limpo e correto usando o projetista de formulrio do NetBeans. claro que ns
somente abordamos um pouco do que possvel, mas ns aprimoramos o aplicativo AnagramGame de formas teis e, agora voc tem uma plataforma simples que pode ser usada para testar novos conceitos e aprender mais so
NetBeans. Voc se divertir caso implemente suas prprias idias, mas aqui esto algumas para que possa iniciar:
Primeiros passos com o NetBeans e Java https://netbeans.org/competition/win-with-netbeans/get-started-with-nb_...
9 de 10 9/2/2014 8:02 PM
SiteMap About Us Contact Legal & Licences
Cada palavra na lista poderia ter um atributo de ttulo e o aplicativo poderia exibir o nome da lista atual de palavras no ttulo da janela. 1.
Quando uma lista de palavras no for muito grande, a mesma palavra provalmente apareceria repetidamente dentro de um nmero pequeno de advinhaes, tornando o jogo mais previsvel e menos divertido. Para ender
esta questo, voc poderia implementar um cache de palavras recentemente usadas. A seguir, para cada solicitao de nova palavra, verifique se a nova palavra est no cache. Caso esteja, solicite uma nova palavra at
uma que no esteja no cache. Isso iria assegurar que no haja muita repetio. Acho que o tamanho do cache pode ser bem pequeno para obter uma baixa repetio na perspectiva dos usurios, mas o tamanho do cach
sempre tem de ser menor do que o nmero de palavras na lista, caso contrrio voc acabar com um ciclo indefinido.
2.
Voc poderia criar um carregador de lista de palavras diferente que aceite qualquer documento de texto. Este carregador iria analisar o texto para verificar todos os tokens de sequncia de caracteres e criar uma nova lista
palavras contendo todas as palavras nicas, talvez requerendo um nmero mnimo de caracteres por palavra. Aponte este carregador para um site da Web de notcias estrangeiras para um jogo verdadeiramente desafian
3.
Listagem dos arquivos relacionados
anagrams.jar O aplicativo AnagramGame modificado, como um arquivo JAR executvel. Clique para jogar!
simplelist.xml Uma lista de palavras de exemplo, como um documento XML.
WordListFileLoader.java Uma analisador com base no SAX para listas de palavras XML.
anagrams-src.zip Cdigo-fonte Java completo para o aplicativo AnagramGame modificado.
By use of this website, you agree to the NetBeans Policies and Terms of Use. 2013, Oracle Corporation and/or its affiliates. Sponsored by
Primeiros passos com o NetBeans e Java https://netbeans.org/competition/win-with-netbeans/get-started-with-nb_...
10 de 10 9/2/2014 8:02 PM