Parâmetros de comparação para um IDE

Dependendo da quantia de tempo empregada usando um IDE, é provável que você tenha opiniões fortes sobre qual IDE é o melhor. Alguns operadores podem considerar o Emacs uma relíquia estranha do último milênio, ao passo que outros o abandonarão somente quando seus dedos paralisados forem arrancados do teclado. Um IDE é melhor que outro somente na extensão do que o torna mais produtivo, e para um programador que nos últimos 20 anos usou o Emacs para codificar em C, este é um ambiente produtivo.

Como a linguagem Java é relativamente nova, não existe um grande legado de código em nenhum ambiente de desenvolvimento específico (pelo menos, não ainda).. A popularidade de cada um dos vários IDEs Java tende a variar na corrida para fornecer novos recursos, melhorar o desempenho e simplificar o uso. O novo desenvolvimento mais interessante foi a apresentação de dois IDEs extensíveis de software livre, gratuitos: Netbeans e Eclipse. Esses estão se aproximando rapidamente dos recursos oferecidos pelas ofertas comerciais. A maioria dos desenvolvedores não precisará mais do que essas duas plataformas de desenvolvimento excelente fornece.

Voltar para parte superior

Comparando o Netbeans com o Eclipse

As duas versões mais recentes desses dois IDEs, Netbeans 3.6 e Eclipse 3.0, contêm muito mais similaridades do que diferenças. Ambos têm verificação de sintaxe, conclusão de código e compactação de código. Ambos permitem que você compile, execute e depure seu código. Ambos suportam Ant, CVS e JUnit. Além disso, os dois ambientes têm construtores de GUI integrados, embora no Eclipse, esse seja um componente separado, o Visual Editor, que deve ser transferido por download separadamente. Para obter mais informações sobre o Eclipse Visual Editor, consulte o artigo "Desenvolvendo GUIs com o Eclipse Visual Editor", listado na seção Recursos, posteriormente neste artigo.

As principais diferenças entre os dois IDEs são que o Netbeans tem suporte de desenvolvimento para web, e o Eclipse não; e o Eclipse tem refatoração automatizada, e o Netbeans não. Mas mesmo que isso seja importante para você, a ausência de um recurso específico não deve ser um fator decisivo. Como ambos os IDEs são extensíveis com o uso de plug-ins, você encontrará plug-ins gratuitos ou de baixo custo disponíveis para preencher essas lacunas. Artigos que mostram como obter, instalar e usar plug-ins para desenvolvimento de Struts e aplicativos da web com Tomcat estão listados na seção Recursos.

Muitos programadores preferem o Eclipse devido sua facilidade de uso; o design geral do Eclipse mantém as ferramentas que você precisa imediatamente ao alcance dos dedos. Muitos programadores também consideram o Eclipse mais rápido e estável. Como tais atributos são difíceis de quantificar, no entanto, é necessário experimentar para julgar por si mesmo se o Eclipse torna a programação em Java mais rápida e fácil.

Voltar para parte superior

Uma questão de perspectiva

Quando você vai nadar, a etapa mais difícil pode ser decidir saltar. Você sabe que a água estará fria, mas sabe também que essa sensação passará rapidamente e em pouco tempo se sentirá confortável. De modo similar, ao começar trabalhar com o Eclipse pela primeira vez, talvez ache a interface com o usuário intimidadora, com um conjunto limitado de opções. Como você começou? A interface com o usuário do Eclipse, ou o ambiente de trabalho, baseia-se no conceito de uma perspectiva, e será necessário compreender esse conceito antes de poder usar o Eclipse de modo efetivo.

O Netbeans, como muitos aplicativos grandes de computador, usa um número de janelas para permitir a execução de diferentes tarefas. Ao iniciar, uma janela Filesystems, na parte superior esquerda da tela, permite que você inclua e abra recursos para seus projetos, e uma janela principal, à direita, destina-se à edição. Mais janelas (por exemplo, uma janela de saída) são abertas quanto necessário, automaticamente ou porque decidiu abri-las para executar tarefas diferentes.

O Eclipse foi desenvolvido sobre o conceito básico de permitir vários arranjos de janelas. À medida que você executa tarefas diferentes, como codificação, depuração ou mesclagem das alterações do código com as tarefas em um repositório de código centralizado, é possível usar um arranjo de janelas escolhido especificamente para essa tarefa. Esses arranjos de janelas específicos de tarefa são chamados perspectivas. Em adição às visualizações, cada perspectiva pode ter diferentes botões de ferramentas e seleções de menus, como apropriado.

A perspectiva básica, aquela que o Eclipse inicia quando você fecha a tela de boas-vindas inicial, é denominada perspectiva Resource, como mostrado na Figura 1:

Como o Netbeans, a perspectiva Resource tem uma janela orientada em árvore na parte superior esquerda que permite navegar e gerenciar recursos, denominada Navigator. Essa janela, como a maioria das janelas no Eclipse, é denominada visualização. Inicialmente, há duas outras visualizações na perspectiva Resource, uma visualização Outline abaixo do Navigator e uma visualização Task abaixo da área do editor principal.

O Eclipse distingue entre visualizações e editores. A perspectiva pode ter muitas visualizações, mas pode ter apenas um editor que é o ponto focal do ambiente de trabalho. Em termos gerais, se você tiver um arquivo aberto no editor, as outras visualizações refletirão aspectos diferentes desse arquivo. Se for um arquivo Java e você estiver na perspectiva Java, a visualização Package Explorer mostrará onde ele está localizado fisicamente na hierarquia de arquivos e pacotes, e a visualização Outline mostrará (entre outras coisas) os métodos e atributos da classe. Se você tiver vários arquivos Java, essas visualizações mudarão à medida que você alternar entre os diferentes arquivos no editor.

Embora seja fácil abrir novas perspectivas e alternar entre elas, não é geralmente necessário porque, à medida que você trabalha, a perspectiva muda automaticamente quando é apropriado. (O Eclipse solicitará sua permissão primeiro, evidentemente.) Você verá isso em um minuto, quando criarmos um projeto Java e, posteriormente, ao depurarmos um programa Java. Depois que estiver acostumado com as perspectivas, você provavelmente descobrirá que elas são um modo de trabalho suave e natural porque eliminam da ferramenta UI quaisquer botões, menus ou visualizações que não sejam apropriadas para a tarefa em questão. Isso torna muito mais fácil localizar as ferramentas relevantes.

Voltar para parte superior

Criando um novo projeto no Eclipse

Para iniciar o trabalho no Eclipse, primeiro, é necessário criar um projeto. Tanto o Eclipse quanto o Netbeans usam a palavra "projeto" para descrever um dos modos principais em que organizam seus arquivos e outros recursos, mas se referem a coisas fundamentalmente diferentes.

Para compreender o uso do Eclipse da palavra "projeto", é importante compreender primeiro que o Eclipse está associado a um diretório denominado área de trabalho. Ao iniciar o Eclipse pela primeira vez, você será solicitado a informar a localização desse diretório (presumindo que você não o tenha especificado como uma opção da linha de comando) e o Eclipse criará tal diretório para você, se ele não existir. Por padrão, todas as suas informações ― algumas informações específicas do Eclipse, os arquivos de origem e de classe Java, as imagens, e assim por diante ― estão armazenadas em subdiretórios ou pastas, neste diretório. Cada pasta nesse diretório corresponde a um projeto e, normalmente, contém um aplicativo independente, um aplicativo da web ou um componente de algum tipo.

Embora usar a área de trabalho seja recomendado, pois mantém as coisas melhor organizadas, o Eclipse 3.0 introduz a capacidade de criar ou especificar diretórios existentes fora da área de trabalho que será usada como pasta do projeto. Isso pode ser especialmente útil se você estiver migrando de outro IDE que não encoraje uma estrutura de diretório estritamente organizada.

Voltar para parte superior

É hora de codificar!

Se quiser acompanhar as instruções e ainda não tiver iniciado o Eclipse, inicie-o agora. Caso ainda não tenha instalado o Eclipse, consulte o artigo "Introdução à Plataforma Eclipse" listado em Recursos. A primeira vez que executar o Eclipse, você obterá uma tela de boas-vindas. Essa leva a tutoriais e a outras informações interessantes, mas ignore isso no momento clicando no "X" na guia superior; para chamar novamente essa tela mais tarde, selecione Help > Welcome no menu principal.

Como mostrado na Figura 1, você estará na perspectiva Resource. Há sempre mais de um modo de se fazer as coisas no Eclipse ― usando atalhos, barras de ferramenta ou seleções de menu ― mas, neste artigo, usaremos menus no geral. Criaremos aqui um projeto usando um menu de contexto, como segue:

• Na perspectiva Resource, clique com o botão direito do mouse na visualização Navigator e selecione New > Project.
• Selecione Java Project no assistente New Project.
• Insira um nome de projeto, por exemplo, "Hello".
• Observe que na seção Location, você tem a opção de criar o projeto em um local externo, mas aceite o padrão, "Create project in workspace".
• Além disso, na seção Project Layout, aceite a seleção padrão, "Use project folder as root for sources and class files". Geralmente, é melhor usar diretórios separados (normalmente, src e bin), mas manteremos as coisas simples por agora, assim aceite o padrão.
• Clicar em Next permitirá que você configure bibliotecas e inclua outros projetos no caminho de classe do qual este projeto depende, mas não precisamos fazer isso. Em vez disso, clique em Finish.
• Depois de um momento, o Eclipse pergunta: "This kind of project is associated with the Java Perspective. Do you want to switch to this perspective now?" Marque a caixa denominada "Remember my decision" e clique em Yes.

Agora que temos um projeto, poderemos criar uma classe. Criaremos uma variação do programa padrão "Hello, world".

• Clique com o botão direito do mouse no projeto Hello e selecione New > Class. Isso abrirá o assistente New Class.
• Insira com.example.hello como o nome do pacote.
• Insira HelloObject como o nome da classe.
• Deixe java.lang.Object como a superclasse.
• Assegure que a opção para criar um stub para um método main() esteja marcada.
• Pressione Finish. (Veja a Figura 2.)

Você observará diversas coisas diferentes depois da criação da classe. Primeiro, alguns itens "TODO" aparecem no arquivo para indicar a necessidade de customizar os modelos que geram comentários. Como outras anotações como marcadores, pontos de interrupção e problemas de sintaxe, esses são indicados por um símbolo na margem esquerda do editor. Posteriormente, você deverá modificar o modelo do código para esse comentário de acordo com as orientações, mas deixe como está por enquanto.

Observe também que correspondendo a cada símbolo na coluna esquerda, há uma caixa pequena, da mesma cor, na coluna direita. Ao passo que a margem esquerda marca somente coisas atualmente visíveis no editor, a margem direita mostra coisas marcadas no arquivo. Se você tiver um arquivo longo com um erro no final, haverá uma pequena caixa vermelha na parte inferior da margem direita independentemente da parte do arquivo que está sendo mostrada no editor; clicar nessa caixa levará ao erro.

Em adição aos símbolos de marca de verificação na margem mais à esquerda, há pequenos triângulos em uma coluna à direita de tais símbolos. Esses correspondem aos sinais de mais e de menos que controlam a compactação do código. Clicar no primeiro triângulo ao lado do comentário que precede a definição da classe exclui o comentário, substituindo-o por reticências, como mostrado na Figura 3:

Observação: À medida que trabalhar com o código no Eclipse, observará ainda outra coluna na margem esquerda entre as anotações e os controles de compactação do código. Essa contém barras coloridas que permitem a comparação do código atual no editor com as versões anteriores do código. Esse recurso é denominado QuickDiff; talvez você deseje explorar isso por conta própria posteriormente.

Agora, incluiremos algum código de modo que tenhamos algo com que trabalhar. Inclua uma linha no método main() criando um Vetor denominado names. Como você não importou o tipo de Vetor, haverá um símbolo na margem esquerda, uma caixa vermelha com um "X" combinado com uma lâmpada amarela, como mostrado na Figura 4:

O "X", evidentemente, significa que há um problema, mas a lâmpada significa que o Eclipse tem uma QuickFix: uma ou mais sugestões para resolver o problema. Clique na lâmpada ou no Vetor e pressione Ctrl-1 (o atalho para a QuickFix). Um pop-up aparecerá listando possíveis correções incluindo: "Import Vector," "Rename in File" e "Create Class Vector". É possível clicar duas vezes na primeira sugestão para que o Eclipse inclua uma instrução de importação para você.

Uma coisa interessante sobre o Eclipse é que ele usa um compilador incremental para compilar seu código à medida que digitar. Se tiver erros de sintaxe, não será possível interpretar o código corretamente e fornecer uma QuickFix. Por exemplo, se não corrigir o problema de importação acima, mas continuar digitando nomes na próxima linha, os nomes serão sublinhados por um rabisco vermelho indicando um erro de sintaxe, mas não haverá mais nenhuma indicação de que há um problema com a linha anterior onde o mapa está definido.

Manter o ponteiro do mouse sobre um erro de sintaxe como esse abre uma dica instantânea descrevendo o problema; neste caso, ele indica que é uma instrução incompleta que necessita de um ponto-e-vírgula. (Isso não é tudo que está faltando, evidentemente, mas é um começo.) Talvez você considere isso um recurso: ele o encoraja a corrigir seus erros à medida que avança. Você não tem de fazer isso, é claro, mas se não fizer, não estará usando o Eclipse tão eficazmente quanto possível.

Depois de assegurar que o Vetor seja devidamente importado, inicie a próxima linha novamente digitando os nomes. É possível usar a conclusão do código para localizar o método apropriado para incluir itens no Vetor names. A conclusão do código no Eclipse funciona do mesmo modo que no Netbeans: depois de digitar a primeira parte de um tipo ou identificador, pressione Ctrl-Space e verá uma lista de opções. Aqui é especialmente útil caso você tenha esquecido o nome do método de que necessita ― é put() ouadd()?

Evidentemente, é add() que você deseja, e depois de selecionar a versão do parâmetro individual na lista, você observará que o Eclipse não apenas completa o nome do método, mas inclui os parêntesis de abertura e fechamento, coloca o cursor regular dentro do parêntesis e desenha uma linha verde (parecendo um cursor) depois do parêntesis de fechamento. Você verá essa linha verde muitas vezes sempre que inserir o código no Eclipse e, embora seja possível ignorá-la sem nenhum efeito aparente, provavelmente é melhor explicá-lo agora. Se você gravar seus próprios modelos de conclusão de código posteriormente (algo que é muito fácil fazer no Eclipse), provavelmente desejará tirar proveito desse recurso.

A linha verde é um ponto de inserção, e é possível mover o cursor para sua localização pressionando a tecla Tab. Isso é informado aqui porque depois de incluir um argumento para add(), presumivelmente, desejará mover além dos parêntesis para incluir mais código ou um ponto-e-vírgula.

Inclua a cadeia de caractere codificada permanentemente "Moe" no Vetor names. Quando digitar o sinal de aspas de abertura, o Eclipse prontamente fornecerá o sinal de aspas de fechamento, moverá o cursor para dentro dos sinais de aspas e fornecerá um novo ponto de inserção depois do sinal de aspas de fechamento. Depois de digitar Moe, pressione Tab para mover além do sinal de aspas de fechamento. O primeiro ponto de inserção depois do parêntesis de fechamento reaparece agora. Pressione Tab novamente para mover para o final da instrução, e digite um ponto-e-vírgula.

Similarmente, inclua dois nomes no vetor names, Curly e Larry. O código deve se parecer agora com este:

			
    public static void main(String[] args) {
        Vector names = new Vector();
        names.add("Moe");
        names.add("Curly");
        names.add("Larry");
        }
    }

Uma das coisas positivas sobre as conclusões de código no Eclipse é que elas levam em conta seu contexto. Aqui, se você digitar for e pressionar Ctrl-Space, várias opções estarão disponíveis e, entre elas, iterar por uma coleção. Selecione essa opção e o código será inserido como mostrado na Figura 5:

Observe que a primeira instância de cada identificador que o Eclipse incluiu está encerrada em caixas. Se você alterar esses identificadores, o Eclipse mudará o identificador em todos os lugares em que ele aparecer. Se você renomear iter para i, as outras instâncias também mudarão automaticamente. A única coisa que você deve mudar aqui é o tipo para String, mas talvez você queira mudar também element para name. É possível pressionar Tab e Shift-Tab para mover entre cada um desses itens. É assim que o código se parece depois de fazer essas alterações e da inclusão de uma chamada para um método greet() que não existe ainda:

			
        for (Iterator i = names.iterator(); i.hasNext();) {
                String name = (String) i.next();
                greet(name);
        }

Em seguida, use a QuickFix do Eclipse (clicando em greet e pressionando Ctrl-1, por exemplo) para gerar um método stub para greet(), e inclua código para o stub como segue:

			
    private static void greet(String name) {
          System.out.println("Hello, " + name);
    }

A esta altura, o código não deve ter nenhum erro. Clique com o botão direito do mouse no editor e selecione Save no menu de contexto.

Voltar para parte superior

Executando e depurando seu programa

Como já foi mencionado, o Eclipse usa um compilador incremental, assim não é necessário compilar explicitamente seus arquivos Java. Os arquivos de classe compilados são salvos quando você salva seus arquivos Java. Para executar seu programa, selecione o arquivo Java no editor ou no Package Explorer e selecione Run > Run As > Java Application no menu principal do Eclipse. (Observe que isso é diferente da opção de menu Run > Run..., que veremos mais tarde.) Isso deve produzir a seguinte saída na visualização Console abaixo do Editor:

			
Hello, Moe
Hello, Curly
Hello, Larry

Executar um programa simples no depurador é similar. Primeiro, defina um ponto de interrupção na chamada para greet() no método main() clicando duas vezes (não um clique único como no Netbeans) na margem esquerda. Se quiser um ponto de interrupção condicional ― um que pare quando uma expressão específica, como i==2 é verdadeira, ou um que pare depois de um número específico de ocorrências ― é possível clicar com o botão direito do mouse no ponto de interrupção e selecione as propriedades Breakpoint no menu de contexto.

Para iniciar a depuração, selecione Run > Debug As > Java Application no menu principal. Como o Eclipse tem uma perspectiva Debug que é mais adequada para depurar do que a perspectiva Java, você será consultado se deseja alterar para tal perspectiva. Marque a caixa "Remember my decision" e clique em Yes como mostrado na Figura 6:

A maioria das visualizações na perspectiva Debug deve ser mais ou menos familiar para você devido às janelas no Netbeans, embora possa ter nomes diferentes. A visualização Debug (não confundir com a perspectiva Debug) mostra a pilha de chamadas, a visualização Variables mostra o estado atual das variáveis do programa, e a visualização Console mostra o programa.

Você observará também que há botões de ferramentas (Step over, Step into, e assim por diante) que controlam a execução na barra de ferramentas da visualização Debug. O motivo que esses controles estão localizados aqui, junto com a pilha de chamada, é que se estiver depurando mais de um programa (ou a instância de um programa), ou um programa com vários encadeamentos, poderá selecionar o programa ou encadeamento a ser controlado clicando nele na pilha de chamada. Se desejar, poderá brincar com isso ativando esse programa de exemplo novamente, sem terminar a primeira instância.

Algumas vezes, você não deseja (ou não pode) executar um programa usando a seleção de menus simples Run > Run As > Java Application. Se for necessário informar argumentos para o programa ou a VM na qual ele executa, você precisará usar a opção de menu Run > Run.... Isso abrirá um diálogo que você pode usar para configurar essas e outras opções como mostrado na Figura 7:

Voltar para parte superior

Perspectiva Resource revisitada

Uma das coisas boas sobre perspectivas é que elas mantêm sua tela livre de interferência. Você pode ter observado, por exemplo, que arquivos de classe não aparecem no Package Explorer, nas perspectiva Java. Presumindo que o Eclipse seja capaz de compilar seus arquivos Java (e ele informará quando não for capaz), não será realmente necessário fazer nada com elas para desenvolver, executar e depurar um programa. Mas quando estiver pronto, você desejará copiar o arquivo de classe para outro diretório ou compactá-lo para enviar a alguém por email.

Um modo de fazer isso é sair do Eclipse, visto que você sabe onde o diretório workspace está ― não há nada especial sobre esse diretório ou o subdiretório Hello onde seus arquivos de projeto são mantidos. Mas também é possível fazer isso de dentro do Eclipse selecionando File > Export no menu principal. Mas, primeiro, será necessário retornar à perspectiva Resource para ver todos os seus arquivos. É possível fazer isso facilmente clicando no botão da perspectiva Resource, no canto superior direito do ambiente de trabalho, como mostrado na Figura 8:

Aqui você verá vários arquivos que foram ocultos na perspectiva Java: seu arquivo de classe, HelloObject.obj, e dois arquivos de metadados que o Eclipse usa para armazenar as informações do seu projeto (.project e .classfile). Para compactar seu arquivo de classe:

• Clique em HelloObject.class para selecioná-la.
• Selecione File > Export no menu principal.
• Selecione o arquivo Zip como destino de exportação e clique em Next.
• O arquivo a ser compactado deve estar selecionado na tela a seguir; no campo denominado "To zip file:", busque ou insira um caminho e nome de arquivo para o arquivo zip que você deseja criar e clique em Finish.

Voltar para parte superior

Refatorar

O Netbeans tem alguns recursos de geração de código que são similares para refatoração, como a capacidade de gerar getters e setters para atributos de classe. No entanto, esses diferem da refatoração porque incluem a nova funcionalidade. A refatoração difere da geração de código automatizada porque reestrutura o código sem alterar a funcionalidade.

Se tiver um conjunto abrangente de testes JUnit passados pelo seu código, o código deverá continuar a passar os mesmos testes depois da refatoração. (Em alguns casos, os testes de unidade propriamente ditos podem ser alterados pela refatoração, mas o ponto é que isso também deve acontecer automaticamente.) Para obter mais informações sobre refatoração e uma introdução às diversas refatorações disponíveis no Eclipse, consulte o artigo "Refatorando para todos" listado em Recursos.

Olharemos rapidamente uma refatoração relativamente simples: Change Method Signature. Usaremos essa para alterar o tipo do parâmetro String no método greet() do programa de exemplo para o Object e incluiremos um parâmetro adicional do tipo String na saudação que ele imprime. Para fazer isso:

• Selecione o método greet() clicando com o botão direito do mouse no nome no editor ou na visualização Outline.
• Selecione Refactor > Change Method Signature... no menu de contexto. (Veja a Figura 9 abaixo.)
• Na tabela denominada Parameters, clique no tipo String e o altere para Object.
• Altere o nome do parâmetro para o Object.
• Clique no botão Add à direita; esse incluirá uma nova entrada abaixo do parâmetro existente. Mude o tipo para String, seu nome para greeting e o valor padrão para "Welcome,".
• Queremos que o novo parâmetro de saudação seja o primeiro parâmetro; assegure que ele ainda seja o parâmetro selecionado e clique no botão Up. (Ou selecione o parâmetro original e clique no botão Down.)

Como com todas as refatorações, você tem duas opções. A primeira é a opção "Just Do It". Normalmente, o Eclipse obtém suas refatorações certas e, no caso raro quando isso não acontece, sempre é possível desfazê-las usando a seleção de menus Refactor > Undo. (Embora essa oferta seja boa apenas por um tempo limitado depois da refatoração. Se você alterar qualquer um dos arquivos envolvidos, não será mais capaz de desfazer a refatoração.) Se estiver confortável com isso, poderá simplesmente clicar em OK. Normalmente, essa é a coisa mais fácil a fazer, mas não faça isso agora.

A segunda opção, "I want to micromanage", é interessante de ver, pelo menos uma vez. Ao clicar em Preview, o Eclipse mostrará uma caixa de diálogo que permite selecionar mudanças específicas em todos os arquivos afetados no alto e numa comparação lado a lado, antes e depois do arquivo selecionado abaixo desse. (Neste caso, é claro, há apenas um arquivo.) Aqui é possível examinar a refatoração proposta arquivo por arquivo, alteração por alteração, e aprovar ou rejeitar cada alteração individualmente (veja a Figura 10). Deixe todas as alterações marcadas e clique em OK.

É assim que o código se parece depois da refatoração:

			
    public static void main(String[] args) {
        int x = 100;

        Vector names = new Vector();
        names.add("Moe");
        names.add("Curly");
        names.add("Larry");
        for (Iterator i = names.iterator(); i.hasNext();) {
            String name = (String) i.next();
            greet("Welcome, ", name);
        }
    }

    /**
     * @param greeting TODO
     * @param object
     */
    private static void greet(String greeting, Object object) {
            System.out.println("Hello, " + object);
    }
	

Observe que a refatoração atualizou a chamada do método greet() no método main() e usou para o valor padrão ("Welcome, " para o primeiro parâmetro), além de alterar o método em si. Se houver outros arquivos no projeto e eles também forem chamados em greet(), eles serão alterados do mesmo modo.

Se executar o programa agora, ele produzirá exatamente o mesmo resultado que antes, como qualquer refatoração apropriada deve fazer. O que ganhamos foi a capacidade de imprimir e usar uma saudação diferente cada vez que chamarmos o método greet(), mas essa é uma alteração de código funcional que fizemos por conta própria, alterando a chamada System.out.println(), como segue:

System.out.println(greeting + Object);

Voltar para parte superior

Usando CVS

Embora tanto o Netbeans quanto o Eclipse tenham suporte para CVS e outros sistemas de controle de versão, o Eclipse fornece uma interface muito mais elaborada usando duas perspectivas separadas. A primeira é a perspectiva CVS Repository Exploring para escolha dos repositórios e módulos do CVS a que se conectar, e para explorar os arquivos que eles contêm. A segunda é uma perspectiva Team Synchronizing para mesclagem das alterações no repositório. Embora isso possa dificultar um pouco o uso do CVS inicialmente, essa abordagem encoraja um fluxo de trabalho disciplinado e estruturado. Além disso, o Eclipse suporta mais tipos de conexão cliente-servidor que o Netbeans. Em especial, o Netbeans somente tem suporte integrado para o protocolo pserver, que é inerentemente inseguro porque transmite senhas sem criptografia. O Eclipse suporta pserver e ssh, o que veremos a seguir.

Para começar, você precisará acessar a um repositório CVS e as informações necessárias para se conectar a ele. Abra a perspectiva CVS Repository Exploring selecionando Window > Open Perspective > Other no menu principal e selecionando CVS Repository Exploring. Essa perspectiva tem várias visualizações interessantes, mas a principal é uma na parte superior esquerda, CVS Repositories. Clicar com o botão direito do mouse aqui e selecionar New > Repository Location permitirá que você insira as informações necessárias para se conectar a um servidor CVS (veja a Figura 11). Observe que para usar ssh, é necessário selecionar o tipo de conexão extssh do Eclipse.

Para criar um novo módulo CVS de um projeto Eclipse:

• Alterne para a perspectiva Java ou Resource.
• Clique com o botão direito do mouse no nome do projeto e selecione Team > Share Project... no menu de contexto.
• Uma caixa de diálogo aparece, com a opção "Use existing repository location selection" marcada. Abaixo de tal caixa, o repositório que você inseriu antes está selecionado. Clique em Next.
• Na caixa de diálogo a seguir, aceite a opção para usar o nome do projeto como o nome do módulo, e clique em Next.
• A próxima caixa de diálogo permite que você reveja o que está prestes a efetuar o registro de entrada; se não houver problemas, clique em Finish.
• Uma caixa de diálogo final o notifica que você ainda não confirmou suas alterações e perguntará se deseja confirmá-las. Clique em Yes.

Agora, você é notificado que há seis recursos que não estão ainda sob controle de versão. É possível simplesmente responder Sim, se desejar, mas se for curioso, descubra que recursos são esses, clicando em Details primeiro. Você descobrirá que esses são os dois arquivos metadados do Eclipse: .project e .classpath, o arquivo de origem Java, HelloObject.java, e as pastas aninhadas em que o arquivo de origem Java está armazenado (correspondendo ao seu pacote): /Hello/com, /Hello/com/example e na Hello/com/example/hello.

• Clique em Yes, se ainda não tiver feito.
• Você recebe uma solicitação para um comentário; insira "Initial version".

Depois de ter efetuado o registro de entrada e de saída dos arquivos do CVS e ter trabalhado neles um pouco mais, será necessário assegurar que suas alterações não estejam em conflito com as de outra pessoa antes de registrá-las. De fato, em face de mudanças conflitantes, o CVS não permitirá que você efetue o registro de entrada.

É possível resolver e mesclar seu código com o repositório de dois modos. O modo mais simples, e mais perigoso, é atualizar simplesmente seus arquivos locais com alterações do repositório CVS clicando com o botão direito do mouse no projeto e selecionando Team > Update no menu de contexto. Se houver alterações, elas serão automaticamente mescladas nos arquivos usando o formato diff (muitos sinais de maior e menor marcando que linhas estão no código, mas não no repositório, e vice-versa). Tentar arrumar isso pode ser tedioso e propenso a erro.

É melhor usar a perspectiva Team Synchronizing do Eclipse, que apresenta os arquivos alterados lado a lado, para viabilizar a revisão, aceitação ou rejeição das alterações em cada arquivo. Para fazer isso:

• Clique com o botão direito do mouse no nome do projeto e selecione Team > Synchronize with Repository no menu de contexto.
• Você é notificado de que essa tarefa está associada à perspectiva Team Synchronizing, e perguntado se deseja alterar para essa perspectiva. Marque "Remember my decision" e clique em Yes.

Como a maioria das outras perspectivas, a visualização que você deseja examinar primeiro é aquela na parte superior esquerda do ambiente de trabalho, neste caso, a visualização Synchronize. No alto são vários botões de ferramentas, incluindo Incoming Mode, Outgoing Mode, Incoming/Outgoing Mode e Conflicts Mode. Que modo estará selecionado inicialmente dependerá de se há alterações no repositório, no código local ou em ambos (ou se as alterações em ambos estão ou não em conflito). O modo determina quais arquivos são mostrados nesta visualização: arquivos locais alterados, arquivos de repositório alterados ou ambos. Isso pode soar confuso, mas, na prática, você não precisa se preocupar com os detalhes; o importante é que este atua para filtrar informações desnecessárias. Você verá apenas os arquivos que precisa revisar para trazer o código de origem atualizado com o repositório.

Suponha que você inclua algum código em HelloObject (de forma que ele manipule String de modo diferente que outros objetos) e, nesse meio tempo, alguém também registre a saída do código e faça outra alteração ( para o método main(), por exemplo). Você não precisa necessariamente estar ciente disso, mas antes de registrar a entrada do seu arquivo, poderá clicar com o botão direito do mouse e selecionar Team > Synchronize with Repository.... Isso abrirá a perspectiva Repository Synchronizing (com sua permissão, evidentemente) e mostrará uma comparação lado a lado do arquivo local e do arquivo no Repositório (veja a Figura 12)

Aqui, é possível revisar cada alteração em cada arquivo, e copiá-lo para sua origem clicando no botão de ferramenta Copy Right to Left na visualização Java Source Compare ou editando o arquivo local manualmente, como apropriado. Quando estiver satisfeito com a sua mesclagem, marque o arquivo como mesclado, clicando com o botão direito do mouse no nome do arquivo na visualização Synchronize e selecionando "Mark as Merged" no menu de contexto.

Assim que tiver resolvido qualquer conflito e mesclado todos os arquivos na visualização Synchronize, retorne à visualização java e verifique se o projeto compila e executa corretamente antes de efetuar o registro de entrada do seu código, como segue:

• Clique com o botão direito do mouse no nome do projeto (ou em um nome de arquivo para confirmar um único arquivo) e selecione Team > Commit no menu do projeto.
• Insira um comentário quando consultado. (Observe que se estiver efetuando o registro de entrada no projeto e vários arquivos tiverem sido alterados, esse comentário será aplicado a todos os arquivos. Para inserir comentários para arquivos individuais, precisará efetuar o registro de entrada dos arquivos individualmente.)

Voltar para parte superior

Resumo

Recurso por recurso, o Eclipse e o Netbeans são bem compatíveis. De fato, como ambos são extensíveis, quaisquer lacunas entre os dois podem ser preenchidas por plug-ins de terceiros. A diferença importante entre eles reside no modo como a interface com o usuário está projetada. O Eclipse está organizado em torno do conceito de uma perspectiva que torna mais fácil realizar o trabalho, porque as ferramentas apropriadas (e apenas as ferramentas apropriadas) estão à mão. Um número de recursos adicionais no Eclipse o torna uma ferramenta mais efetiva para programadores Java, como a QuickFix, a QuickDiff e a facilidade de navegação dentro do código de origem usando marcadores ou as estruturas de tópicos de classe. Você também encontrará suporte robusto para CVS e refatoração no Eclipse 3.0, coisas que não tem no Netbeans. Isso deve compor um caso convincente para qualquer programador, incluindo os atualmente aficcionados no Netbeans, para testar e dominar o Eclipse.

Recursos

• Saiba mais no Website do Eclipse e obtenha uma lista abrangente de plug-ins do Eclipse.
  
  
• A última versão do Netbeans está no website do Netbeans.
  
  
• O artigo Getting started with the Eclipse Platform (developerWorks, novembro de 2002) de David fornece um histórico e visão geral do Eclipse, incluindo detalhes sobre como instalar o Eclipse e plug-ins. Também no seu livro, Eclipse In Action: A Guide for Java Developers (Independent Pub Group, 2003), é leitura obrigatória para desenvolvedores Java usando Eclipse.
  
  
• Para obter uma visão geral do Visual Editor e da tecnologia por detrás dele, junto com uma breve demonstração dos recursos do Visual Editor 0.5 para desenvolver aplicativos AWT/Swing e uma visualização do suporte SWT no Visual Editor 1.0, consulte Desenvolver GUIs com o Projeto Visual Editor do Eclipse (developerWorks, maio de 2004).
  
  
• Refactoring for everyone (developerWorks, setembro de 2003) mostra como e porque usar os recursos de refatoração automatizados do Eclipse com exemplos de todos os recursos de refatoração no Eclipse 2.1.x e a maioria dos recursos de refatoração no Eclipse 3.0.
  
  
• Using Eclipse as development environment with Jakarta Tomcat (developerWorks, maio de 2004) mostra como desenvolver aplicativos Tomcat usando o Eclipse e o plug-in Sysdeo Tomcat. Instruções são incluídas para instalar Tomcat e o plug-in.
  
  
• Debugging with the Eclipse Platform (developerWorks, maio de 2003) fornece uma visão geral de depuração no Eclipse.
  
  
• Developing Struts with Easy Struts for Eclipse (developerWorks, abril de 2004), mostra como desenvolver aplicativos Struts no Eclipse usando o plugin Easy Struts. Instruções são incluídas para instalar Struts e o plug-in.
  
  
• David escreveu artigos de instruções similares para ajudar usuários do IntelligJ IDEA e JBuilder a migrar para o Eclipse: Migrating from IntelliJ IDEA to Eclipse (developerWorks, setembro de 2004) e Migrating from JBuilder to Eclipse (developerWorks, setembro de 2004).
  
  
• Visite o Estação de migração do developerWorks para diversos outros caminhos de migração para desenvolvimento baseado em padrões abertos.
  
  
• Em adição a todos os artigos do Eclipse no developerWorks, localize mais recursos para desenvolver com o Eclipse na Zona de software livre do developerWorks e Zona Java do developerWorks.
  
  
• Participe da comunidade do developerWorks participando dos blogs do developerWorks .
  
  
• Busque por livros sobre esses e outros tópicos técnicos.
  
  

Sobre o autor

Classificar este artigo

Comentários

Voltar para parte superior

Índice

• Parâmetros de comparação para um IDE
• Comparando o Netbeans com o Eclipse
• Uma questão de perspectiva
• Criando um novo projeto no Eclipse
• É hora de codificar!
• Executando e depurando seu programa
• Perspectiva Resource revisitada
• Refatorar
• Usando CVS
• Resumo
• Recursos
• Sobre o autor
• Comentários

Conheça a IBM da sua cidade

A IBM está mais perto do que você imagina!

---

Saiba mais