Editando Elementos Java

Nesta seção, você editará elementos Java no workbench.

Utilizando a Exibição Contorno

  1. Para abrir o arquivo junit.samples.VectorTest.java no editor Java, dê um clique duplo no arquivo na exibição Package Explorer.

  2. Observe a sintaxe se destacando. A seguir, exemplos de partes da origem java que são processadas de maneira diferente:

    • Comentários regulares
    • Comentários do Javadoc
    • Palavras-chave
    • Cadeias.
    Destaque da sintaxe
  3. Veja a exibição Contorno. Ela exibe uma descrição do arquivo Java incluindo a declaração do pacote, as declarações de importação, os campos, os tipos e os métodos. A exibição Contorno também indica se um elemento Java é estático, abstrato, final, etc, e também mostra se um método é substituído a partir de uma categoria de base (substituído) ou quando implementa um método a partir de uma interface (implementações).

    Exibição Contorno
  4. Alterne os botões Ocultar Campos, Ocultar Membros Estáticos e Membros Não Públicos na barra de ferramentas da exibição Contorno para filtrar a exibição.

    Barra de ferramentas da exibição Contorno
  5. Alterne o botão Ordenar na exibição Contorno para ordenar os elementos Java em ordem alfabética, em vez da ordem em que aparecem no arquivo Java.

  6. Você pode editar o código fonte exibindo o arquivo Java completo ou pode restringir a exibição a um único elemento Java. Clique no botão Mostrar Origem Apenas do Elemento Selecionado na barra de ferramentas.

    Em seguida, na exibição Contorno, selecione qualquer elemento e observe que apenas o elemento selecionado é exibido no editor Java.

    Botão da barra de ferramentas Mostrar apenas elemento selecionado
  7. Pressione novamente o botão Mostrar Origem Apenas do Elemento Selecionado para ver o arquivo Java completo.

    Na exibição Contorno, selecione vários elementos e observe que eles são apresentados mais uma vez em uma exibição de arquivo inteiro no editor. Agora, a seleção da exibição Contorno está sinalizada com um indicador de intervalo na régua vertical da moldura esquerda do editor Java.

    Indicador de intervalo

Adicionando Métodos e Utilizando a Assistência ao Conteúdo

  1. Verifique se o botão Classificar em ordem alfabética na barra de ferramentas da exibição Contorno está com a alternância desativada.

  2. Comece a incluir um método digitando o seguinte no final do arquivo VectorTest.java (mas antes dos colchetes de fechamento do tipo) no editor Java:

    public void testSizeIsThree() {

    Assim que você digitar o nome do método na área do editor, o novo método aparecerá na parte inferior da exibição Contorno.

    Novo método na exibição contorno
  3. Clique no botão Salvar.

    A unidade de compilação é compilada automaticamente e os erros aparecem na exibição Package Explorer, exibição Tarefas e na régua vertical. Na exibição Package Explorer, os erros são propagados até o projeto da unidade de compilação que contém o erro.

    Propagação do erro no package explorer
  4. Complete o novo método, digitando o seguinte:

        assertTrue(fFull.size() == 3);
    }
  5. Salve o arquivo.

    Observe que os indicadores de erro desaparecem.

Excluindo e Substituindo um Método do Histórico Local

Nesta seção, você utilizará o recurso de histórico local para alternar para uma versão de um elemento Java individual salva anteriormente.

  1. Exclua o método recém-criado selecionando-o na exibição Contorno e clicando em Excluir no menu de contexto.

  2. Inclua uma nova versão do método digitando o seguinte no final do arquivo VectorTest.java no editor Java:

    public void testSizeIsThree() {
        fFull.add(0, new Integer(0));
        fFull.remove(new Integer(3));
        assertTrue(fFull.size() == 3);
    }

    Salve o arquivo.

  3. Na exibição Contorno, selecione o método testSizeIsThree() e, em seu menu de contexto, selecione Substituir a Partir do Histórico Local.

  4. No diálogo Substituir Elemento Java a partir do Histórico Local, a lista de Histórico Local mostra os vários estados salvos desse elemento. O painel Comparação de Origem Java mostra detalhes das diferenças entre o recurso de histórico selecionado e o recurso existente do workbench.

    Substituir a partir do histórico local
  5. No painel Histórico Local, selecione a versão que você excluiu e clique no botão Substituir.

    No editor Java, o método é substituído pela versão de histórico selecionada.

  6. Salve o arquivo.

Utilizando a Assistência ao Conteúdo

  1. Abra o arquivo junit.samples.VectorTest.java no editor Java.

  2. Vá para o método testSizeIsThree() selecionando-o na exibição Contorno.

  3. Inclua as seguintes linhas no final do método:

    Vector v = new Vector();
    for (int i=0; i<3; i++)
        v.addElement(new Object());
    assert
  4. Com o cursor no final da palavra assert, pressione Ctrl+Espaço para ativar a assistência ao conteúdo.

    Aparecerá a janela da assistência ao conteúdo com uma lista de sugestões. Role a lista para ver as opções disponíveis.

    Assistência ao conteúdo
  5. Com a janela de assistência ao conteúdo ainda ativa, digite a letra 't' depois de assert (sem espaços). A lista é restrita mostrando apenas as entradas que comecem com 'assert'.

    Selecione e, em seguida, focalize vários itens na lista para exibir qualquer ajuda do Javadoc disponível para cada item.

    Assistência ao conteúdo filtrada
  6. Selecione assertTrue(boolean) na lista e pressione Enter.

    O código do método assertTrue(boolean) é inserido.

  7. Complete a linha para que informe o seguinte:

    assertTrue(v.size() == fFull.size());
  8. Salve o arquivo.

Utilizando Modelos

  1. Abra o arquivo junit.samples.VectorTest.java no editor Java.

  2. Comece incluindo um novo método digitando o seguinte:

    public void testValues() {
        Integer[] expected= new Integer[3];
        for
  3. Com o cursor no final de for, digite Ctrl+Espaço para ativar a assistência ao conteúdo.

    Assistência ao conteúdo para
  4. Escolha a entrada para - iterar sobre matriz.

    O modelo é inserido no editor e i é destacado. O nome da matriz local é obtido automaticamente.

    Inserido no modelo
  5. Pressione Enter para confirmar o modelo.

  6. Conclua o loop for para:

    public void testValues() {
        Integer[] expected= new Integer[3];
        for (int i= 0; i < expected.length; i++) {
            expected[i]= i + 1;
        }
        
        Integer[] actual= to
  7. Com o cursor no final de to, digite Ctrl+Espaço para ativar a assistência ao conteúdo. Selecione toarray - converter coleção em matriz.

    Inserido no modelo

    O modelo é inserido no editor e type é destacado e selecionado.

    Inserido no modelo
  8. Sobreponha a seleção digitando Integer. O tipo de construtor da matriz é alterado sincronicamente.

  9. Digite Tab para destacar e selecione collection e sobreponha a seleção digitando fFull.

    Inserido no modelo
  10. Digite Enter para confirmar o modelo.

  11. Inclua as seguintes linhas de código para completar o método:

            assertEquals(expected.length, actual.length);
            for (int i= 0; i < actual.length; i++)
                assertEquals(expected[i], actual[i]);
        }
  12. Salve o arquivo.

Organizando Importações

  1. Abra o arquivo junit.samples.VectorTest.java no editor Java.

  2. Exclua as declarações de importação selecionando-as na exibição Contorno e selecionando Excluir no menu de contexto.

    Menu de contexto da exibição Contorno
  3. No menu de contexto no editor, selecione Organizar Importações.

    As instruções de importação necessárias estão incluídas no início do código, abaixo da declaração do pacote.

    Organizar Importações

    Alternativamente, Organizar Importações pode ser chamado diretamente do menu de contexto das declarações de importação na exibição Contorno.

    Nota: Você pode especificar a ordem das declarações de importação em Preferências (Janela > Preferências > Java > Organizar Importações).

  4. Salve o arquivo.

Extrair um Método

Nesta seção, você aprimorará o código do construtor de junit.framework.TestSuite. Para tornar mais clara a intenção do código, você extrairá o código que coleta etapas de teste das categorias de base para um novo método chamado collectTestMethods.

  1. No arquivo junit.framework.TestSuite.java, selecione o seguinte intervalo de código:

    Class superClass= theClass;
    Vector names= new Vector();
    while (Test.class.isAssignableFrom(superClass)) {
        Method[] methods= superClass.getDeclaredMethods();
        for (int i= 0; i < methods.length; i++) {
            addTestMethod(methods[i], names, constructor);
        }
        superClass= superClass.getSuperclass();
    }

    Selecione o intervalo de códigos utilizando o recurso Expandir Seleção para:

    1. Navegue para o construtor TestSuite(Class).
    2. Posicione o cursor bem antes de while.
    3. Pressione Alt+Shift+Seta para Cima.
    4. Pressione Alt+Shift+Seta para a Esquerda duas vezes.
  2. No menu de contexto da seleção no editor, selecione Reformular > Extrair Método....

    Menu de contexto - Extrair método
  3. No campo Nome do Método, digite collectInheritedTests, em seguida, clique em Avançar.

    Página 1 do assistente para extrair método
  4. A página de pré-visualização de reformulação exibe as alterações que serão feitas.

    Pressione Concluir para extrair o método.

    Página 2 do assistente para extrair método
  5. Vá para o método extraído selecionando-o na exibição Contorno.

    Método extraído

Utilizando Abrir Declaração e Abrir Hierarquia de Tipo

  1. Abra o arquivo junit.samples.money.MoneyTest.java no editor Java.

  2. Na primeira linha da declaração da classe MoneyTest, selecione a especificação da superclasse TestCase e

    • selecione na barra de menus Navegar > Abrir Declaração ou
    • pressione F3.

    Nota: Esse comando também funciona em métodos e campos.

    Menu - Abrir declaração

    A superclasse TestCase abre na área do editor e também é representada na exibição Contorno.

    Declaração aberta
  3. Clique na guia do editor TestCase.java para torná-lo o editor ativo. Assegure-se de que a declaração de classe ainda esteja selecionada e:

    • selecione, na barra de menus, Navegar > Abrir Hierarquia de Tipo ou
    • pressione F4.
    Menu - Abrir hierarquia de tipo
  4. A exibição Hierarquia abre com a classe TestCase exibida.

    Exibição Hierarquia de tipo

    Nota: Os editores também podem ser abertos em tipos e métodos na exibição Hierarquia.

Conceitos Relacionados

Exibições Java
Editor Java
Suporte de Reformulação
Modelos

Tarefas Relacionadas

Utilizando o Editor Java
Mostrando e Ocultando Elementos
Mostrando Elementos Simples ou Arquivos Java Completos
Ordenando Elementos em Exibições Java
Utilizando o Histórico Local
Utilizando a Assistência ao Conteúdo
Utilizando Modelos
Gerenciando Instruções de Importação
Reformulando
Reformulando com Visualização
Utilizando a Exibição Hierarquia
Abrindo uma Hierarquia de Tipo em um Elemento Java
Abrindo uma Hierarquia de Tipo na Seleção de Texto Atual
Abrindo um Editor para um Elemento Selecionado

Referência Relacionada

Exibição Contorno Java
Assistência ao Conteúdo Java
Preferências de Modelos
Organizar Preferências de Importações
Preferências do Editor Java
Erros de Extração de Método
Exibição Hierarquia de Tipo