NetBeans IDE refactoring – Parte Final

NetBeans IDE refactoring – Parte Final

Este artigo apresenta a parte final da série de matérias sobre técnicas de refactoring de código providas pelo módulo da ferramenta NetBeans IDE. Em artigos anteriores foram tratados aspectos sobre algumas funcionalidades do processo de transformação de código implementados na NetBeans IDE, portanto, encerrando a série de textos sobre o tema refactoring, neste artigo serão apresentadas as seguintes operações: “Move Class”, “Move Inner to Outer Level”, “Convert Anonymous Class to Inner” e “Safely Delete”. As próximas seções detalham cada uma das operações citadas.

Move Class

Muitas vezes, quando um projetista de software elabora uma API, ou uma biblioteca de classes, ele tem a preocupação de organizar os recursos utilizados pela biblioteca, hierarquizando elementos e criando pacotes dentro da estrutura para melhor contextualizar classes e interfaces que serão disponibilizadas aos demais desenvolvedores de software. Tais características de organização de elementos de software em pacotes podem ser facilmente observadas através do próprio JDK (Java Development Kit), visto que o mesmo disponibiliza uma API de desenvolvimento de software organizada em pacotes.

Entretanto, quando alguma alteração se torne necessária no conteúdo de um determinado pacote, como, a movimentação de uma classe de um pacote para outro, torna-se necessária a alteração de todas as referências a mesma nos demais componentes da biblioteca.

Sendo assim, para que os problemas de gerenciamento de elementos em um pacote sejam contornados, foi criada a operação Move Class, a qual deverá ser utilizada sempre que uma classe ou interface tenha que ser movida para outro pacote. A operação atualiza, automaticamente, todas as referências ao elemento movido.

Para exemplificação da operação Move Class iremos mover todas as classes que compõem a hierarquia de contas correntes, apresentadas em módulos anteriores deste artigo, para um pacote de classes denominado “contas”. Desta forma, para realização da operação, primeiramente crie o pacote e, após, selecione as classes “Conta”, “Especial” e “Poupança” através da caixa Projects, conforme ilustrado na Figura 20.

Figura 20. Selecionando as classes a serem movidas.

Após selecionar as classes, clique com o botão direito do mouse sobre as mesmas, e então, no menu de contexto que surge, selecione “Refactor -> Move Class”, ou se preferir pressione a tecla de atalho associada a esta ação. Dessa forma, irá surgir a caixa de diálogo da operação de refactoring, bastando ao desenvolvedor selecionar o pacote de destino das classes, conforme pode ser observado através da Figura 21.

Figura 21. Definindo o pacote de destino das classes a serem movidas.

Ao informar o pacote de destino e finalizar a operação, as classes constituintes da hierarquia serão movidas para o novo pacote denominado “contas”.

Move Inner to Outer Level

Esta operação permite que uma determinada classe interna (Inner Class) seja movida para fora da classe onde a mesma foi definida, ou seja, faz com que a classe interna seja movida para uma classe independente.

Tal operação também pode ser realizada em uma classe interna que é parte de outra classe interna, dessa forma, a classe torna-se uma outra classe interna no mesmo nível que se encontra a classe da qual a mesma fazia parte.

Note que esta operação somente poderá ser realizada sobre classes internas residentes em um código de programa editável, portanto, classes anônimas não poderão sofrer tal operação.

Convert Anonymous Class to Inner

A utilização de classes anônimas pode tornar um código bastante confuso a primeira vista, principalmente, para desenvolvedores que estão migrando para tecnologia Java. O aspecto visual de construções de código que adotam o conceito de classes anônimas não é muito animador para programadores iniciantes. A operação de conversão de classes anônimas em classes internas é uma funcionalidade que tenta tornar o código mais claro.

Para tanto, a operação de conversão extrai o código da classe anônima, substituindo-o por uma referência a uma instância da classe interna que será gerada. Dessa forma, a operação de refactoring cria uma nova classe contendo um construtor e um nome definido pelo desenvolvedor.

Um exemplo típico do processo de conversão de classes anônimas em classes internas pode ser verificado na manipulação da interface Comparator, provida pela API de coleções em Java para realização da classificação de objetos segundo algum critério. A chamada básica a uma rotina de classificação de listas dinâmicas, utilizando-se o método sort( ) provido pela classe Collections é demonstrada no código ilustrado através da Figura 22.

Figura 22. O método de ordenação de coleções de objetos, utilizando uma instância de Comparator.

O programa apresentado anteriormente realiza a criação de uma coleção de objetos do tipo Contato e adiciona dois elementos na lista. Os elementos são adicionados sem alguma classificação prévia, logo a seguir, os elementos são apresentados ao usuário, onde podemos observar que eles se encontram desordenados na lista, só então, os mesmos são classificados pela utilização do método estático sort( ), definido na estrutura da classe Collections – provida pela API de manipulação de coleções do JDK.

Observe que o método sort( ) recebe dois argumentos: o primeiro é a lista de objetos que serão ordenados e o segundo é uma instância de uma classe anônima que implementa a interface Comparator, também provida pela API de coleções e utilizada para escrita de métodos de comparação de objetos baseados em atributos dos objetos contidos na lista. Veja que a comparação é realizada através do atributo nome do contato, o qual será utilizado para ordenação dos elementos da lista.

O código apresentado é um pouco confuso para programadores iniciantes, pois apresenta alguns princípios pouco usuais em linguagens que não abordam o paradigma da orientação a objetos. Entretanto, para tornar o código mais claro, podemos extrair o código da classe anônima, formando uma classe interna. A Figura 23 apresenta como tal operação de refactoring é realizada pela NetBeans IDE.

Figura 23. Aplicando a operação Convert Anonymous Class to Inner.

Para executar a operação de refactoring, selecione a chamada ao construtor Comparator( ) e, logo a seguir, clique com o botão direito do mouse sobre a área selecionada, no menu de contexto que surge selecione a opção “Refactor -> Convert Anonymous Class to Inner”. A caixa de diálogo ilustrada na figura acima será apresentada, informe o nome da classe interna que será gerada, no exemplo foi informada a denominação “Comparadora”. Para confirmar a operação pressione o botão “Next”. O código gerado é apresentado na Figura 24.

Figura 24. Classe interna gerada na operação.

A Figura 25 apresenta o código da classe “Contato”, utilizada para criação de objetos que são inseridos na lista de contatos manipulada nos exemplos anteriores.

Figura 25. Estrutura da classe Contato.

Safely Delete

A operação “Safely Delete” permite uma verificação prévia do código fonte de uma aplicação, na busca de referências a um determinado código de programa que se pretende remover. Caso a operação encontre tais referências o desenvolvedor é notificado através de uma caixa de diálogo, alertando ao mesmo que tais referências deverão ser removidas.

Esta operação de refactoring é bastante útil e pode ser aplicada a classes, atributos e métodos de uma determinada classe. A Figura 26 apresenta um exemplo de utilização de tal operação, onde pretendemos remover o método getNome( ) da classe “Contato”. Para que o código seja executado, selecione o método getNome( ) a partir do código fonte da classe “Contato”, logo após, clique com o botão direito do mouse sobre a área selecionada, então selecione a opção de menu “Refactor -> Safely Delete”. Na caixa de diálogo apresentada, clique no botão “Next” para que a operação seja finalmente realizada.

Figura 26. Aplicando Safely Delete.

Note que a operação não permitiu a remoção do código e emitiu uma mensagem de alerta ao desenvolvedor em uma caixa de diálogo, conforme podemos observar através da Figura 27.

Figura 27. Alerta emitido pela operação Safely Delete.

Para que possamos analisar o código que realiza referência ao método que pretendemos excluir, clique no botão “Show Usages”, dessa forma, será apresentada uma lista de chamadas ao método em toda a aplicação, veja tal conceito através da Figura 28.

Figura 28. Lista de referências ao código a ser excluído.

Considerações finais

Como podemos observar, através da série de artigos apresentados sobre refactoring de código com uso da ferramenta NetBeans IDE, o processo de transformação de código realizado e gerenciado por software permite um controle sobre alterações em uma aplicação e, também, na estrutura de classes utilizadas por uma aplicação, realizando consistências e mantendo o código original íntegro.

Tal processo de transformação de código permite uma maior produtividade junto à equipe de desenvolvedores, bem como, uma forma de controle e prevenção de possíveis falhas que venham a ocorrer no produto final.

Referências 

SEVERO, C. E. P. NetBeans IDE, para desenvolvedores que utilizam a tecnologia Java, Rio de Janeiro: Brasport, 2005.

NetBeans.org Group, NetBeans IDE project. Disponível em: www.netbeans.org.

NetBeans.org Group, Refactoring project. Disponível em: refactoring.netbeans.org.

NetBeans.org Group, Metadata Repository project (MDR). Disponível em: mdr.netbeans.org.

Leia também

• NetBeans IDE refactoring – Parte I
• NetBeans IDE refactoring – Parte II