NetBeans IDE refactoring – Parte II
Na primeira parte deste artigo estudamos os conceitos e aplicação de técnicas de refactoring de código através da ferramenta NetBeans IDE. Inicialmente, citamos e começamos a descrever algumas operações suportadas pelo módulo de refactoring da ferramenta, tais como: Rename e Encapsulate Fields, através de um estudo de caso a partir de um conjunto de classes de uma aplicação para manipulação de contas correntes. Dessa forma, daremos continuidade ao texto com a descrição de outras operações de refactoring, tais como: “Extract Method”, “Change Method Parameters”, “Pull Up e Push Down”.
Extract Method
O processo de desenvolvimento de software através da tecnologia de orientação a objetos é concebido pela escrita de classes. As classes por sua vez possuem um conjunto de atributos que caracterizam cada objeto instanciado, assim como uma série de métodos utilizados para manipulação do estado dos atributos. Cada método de uma classe deve possuir o menor código possível, permitindo-se a construção de um código mais simples, seguindo-se dessa forma a técnica de divisão da complexidade provida pela Engenharia de Software. Portanto, de acordo com esse raciocínio, quando o código de um método se tornar muito extenso, convém dividi-lo em porções menores para contornarmos o problema da complexidade. Isso pode ser realizado através da criação de um novo método, a partir de uma porção de código que desejamos excluir do corpo do método que está muito extenso. Essa técnica é realizada através da operação Extract Method. Vejamos como a técnica é aplicada pela NetBeans IDE, seguindo-se os seguintes passos:
- selecione o código que deseja remover para formação de um novo método. No exemplo, iremos excluir a inicialização do atributo “limite” do construtor da classe “Especial”, criando-se um novo método denominado “zeraLimite”;
- clique com o botão direito do mouse sobre a área de código selecionada e no menu de contexto que surgirá selecione a opção Refactor -> Extract method, conforme ilustrado na Figura 9;
Figura 9. Selecionando a operação Extract Method através do menu de contexto.
- Ao aplicar a operação, será apresentada a caixa de diálogo Extract Method, conforme Figura 10;
Figura 10. Caixa de diálogo da operação Extract Method.
- Na caixa de diálogo identifique o nome do método que será criado e o tipo de acesso, que neste caso será público. Caso o programador esteja criando um método estático, deve-se marcar a opção “Declare Static”. A ordem dos parâmetros do método pode ser definida através dos botões apropriados ao lado da tabela apresentando os nomes e tipos dos mesmos;
- Se quiser uma visualização das alterações antes de realizar a operação, selecione “Preview All Changes”;
- Clique no botão Next para realizar a operação;
- Ao confirmar a operação, o método será criado e uma chamada ao mesmo será incluída no método original, onde o código estava contido. Vejamos a Figura 11 onde a ação Extract Method foi aplicada no construtor da classe “Especial”.
Figura 11. Executando Extract Method na classe Especial.
Note que o código de inicialização do valor do atributo “limite” foi removido do construtor da classe “Especial”, sendo colocado no interior de um novo método denominado “zeraLimite”. O método foi criado automaticamente pela operação de refactoring e no ponto original onde o mesmo se encontrava, foi inserida uma chamada ao mesmo.
Change Method Parameters
A operação de refactoring denominada Change Method Parameters permite a manipulação dos parâmetros de um método. Tanto no que se refere a inclusão de novos parâmetros como no que tange a alteração da ordem de passagem dos mesmos para o método. Vejamos como utilizar essa operação através da criação de um novo método na classe Conta, denominado “inicializaSaldo”, o qual irá conter o seguinte código:
public void inicializaSaldo(){
this.saldo = 0.00f;
}
Para exemplificação da operação Change Method Parameters, iremos realizar uma modificação na assinatura do método, inserindo o parâmetro valor do tipo float, o qual será utilizado para definição do valor inicial do atributo saldo de uma conta.
1. Selecione o nome do método através do editor de código-fonte;
2. clique com o botão direito do mouse sobre a área de texto selecionada e no menu de contexto que surgirá selecione a opção Refactor -> Change Method Parameters, veja a Figura 12;
Figura 12. Manipulando os parâmetros de um método.
3. Será apresentada a caixa de diálogo Change Method Parameters, conforme ilustrado na Figura 13;
Figura 13. A caixa de diálogo Change Method Parameters.
4. A tabela apresentada na caixa de diálogo monta uma lista de parâmetros do método “inicializaSaldo”. Para manipulação dos parâmetros, utilize os botões à direita.
5. Iremos adicionar um novo parâmetro para o método “inicializaSaldo”, o qual irá indicar o valor inicial do saldo da conta. Para isso, deve-se clicar no botão “Add”. Uma nova linha será inserida na tabela, com o nome, tipo e valor padrão previamente preenchidos com valores padronizados pela ferramenta; vamos modificar o nome para valor, o tipo para float e o valor padrão para 0.00f. Uma previsão da assinatura do método é apresentada ao desenvolvedor, veja a Figura 14.
Figura 14. Um pré-visualização da operação Change Method Parameters.
6. Ao finalizar as definições do novo parâmetro confirme a operação de refactoring pressionando o botão “Next”. Dessa forma, o código do método será modificado, conforme podemos observar através da Figura 15.
Figura 15. Modificações na assinatura do método refletidas no código.
A ilustração anterior apresenta a assinatura do código modificada pela operação de refactoring e as chamadas ao método com o valor padrão sendo passado. Podemos observar isso através da chamada a “inicializaSaldo” a partir do construtor da classe “Conta”. Basta realizar a modificação da linha de atribuição do valor ao atributo saldo para atribuir o valor passado pelo parâmetro do método.
Pull Up
A operação de refactoring Pull Up permite que o desenvolvedor possa deslocar um atributo ou método do interior de uma classe especializada para o interior de sua superclasse. Vejamos a utilização dessa operação através da inserção de um novo atributo na classe “Poupança”, denominado “dataConta” do tipo Date, o qual será utilizado para definição da data de abertura da poupança. Note que essa característica é comum a todo tipo de conta e não somente a uma conta do tipo poupança, sendo assim, seria interessante mover esse atributo para a classe “Conta”, pois a mesma é a generalização de todos os demais tipos de contas. Vejamos a seguir os passos necessários para esse tipo de operação:
1. Selecione o atributo “dataConta” a partir do código da classe “Poupança”.
2. clique com o botão direito do mouse sobre a área de texto selecionada e no menu de contexto que surgirá selecione a opção Refactor -> Pull Up, conforme podemos observar através da Figura 16.
Figura 16. Acionando a operação de refactoring Pull Up.
3. Será apresentada a caixa de diálogo Pull Up, conforme ilustrado na Figura 17;
Figura 17. A caixa de diálogo da operação Pull Up.
4. A caixa de diálogo de Pull Up apresenta uma lista de membros da classe “Poupança”, onde podemos observar o conjunto de atributos e métodos da mesma. A superclasse de “Poupança” é a classe “Conta”. Iremos mover o atributo “dataConta” para a classe “Conta”, note que o mesmo já aparece marcado na lista de membros.
5. Ao finalizar as definições da operação, clique em “Next” para confirmar a operação. Veja a seguir como fica o código da classe “Conta”
public class Conta {
protected Pessoa titular;
protected int numero;
protected int digito;
protected float saldo;
public Conta() {
titular = null;
numero = 0;
digito = 0;
inicializaSaldo(0.00f);
}
public void inicializaSaldo(float valor){
this.saldo = valor;
}
public void credita(float valor){
saldo += valor;
}
public boolean debita(float valor){
if(saldo - valor < 0)
return false;
saldo -= valor;
return true;
}
protected Date dataConta;
}
Note que a declaração do atributo “dataConta” foi realizada no final da estrutura da classe “Conta”. Esta é uma característica da NetBeans IDE, onde as declarações são realizadas no final da classe.
Quando movemos um método de uma especialização para sua respectiva superclasse, podemos realizar a operação de duas formas:
- Movendo o método simplesmente, dessa forma ele será removido da classe em questão e inserido em sua superclasse;
- Criando um método abstrato na superclasse e mantendo a implementação do método na especialização. Isso é realizado através da opção “Make Abstract” encontrada como uma coluna na lista de métodos de uma classe.
Push Down
A operação de refactoring Push Down realiza uma ação inversa a Pull UP, ou seja, move classes internas, atributos ou métodos para as especializações de uma determinada classe. Para exemplificação desta operação, iremos realizar um deslocamento do método “debita”, encontrado na classe “Conta”, para todas as especializações da mesma. Neste caso, o método será deslocado para as classes “Especial” e “Poupança”. Entretanto, ao movermos o método para as especializações, manteremos a assinatura do mesmo na classe original, mas na forma de um método abstrato. A responsabilidade de implementação do código fica a cargo das especializações. Sendo assim, para realizarmos a operação Push Down, sigamos os seguintes passos:
6. Selecione o método “debita” a partir do código da classe “Conta”;
7. clique com o botão direito do mouse sobre o método selecionado e no menu de contexto que surgirá selecione a opção Refactor -> Push Down, conforme podemos observar através da Figura 18;
Figura 18. Acionando a operação Push Down.
8. então será apresentada a caixa de diálogo Push Down, conforme podemos observar através da Figura 19;
Figura 19. A caixa de diálogo da operação Push Down.
9. Uma lista dos membros da classe será apresentada, com o método “debita” devidamente marcado. A coluna “Keep Abstract” é utilizada quando desejarmos manter a assinatura do método como abstrata na superclasse, neste caso é isso que iremos fazer. A implementação do código será realizada pelas especializações. Para confirmar a operação clique em “Next”.
Ao término da operação a NetBeans irá tornar o método original abstrato e mover o código de implementação para as classes especializadas. Devemos realizar uma modificação na classe “Conta”, tornando-a asbtrata. Vejamos como fica o novo código da classe “Conta”.
public abstract class Conta {
protected Pessoa titular;
protected int numero;
protected int digito;
protected float saldo;
protected int teste;
public Conta() {
titular = null;
numero = 0;
digito = 0;
inicializaSaldo(0.00f);
}
public void inicializaSaldo(float valor){
this.saldo = valor;
}
public void credita(float valor){
saldo += valor;
}
public abstract boolean debita(float valor);
protected Date dataConta;
}
No próximo artigo finalizaremos o estudo sobre operações de refactoring através da NetBeans IDE, abordando as técnicas restantes providas pela ferramenta.
Referências
[1] SEVERO, C. E. P. NetBeans IDE, para desenvolvedores que utilizam a tecnologia Java, Rio de Janeiro: Brasport, 2005.
[2] NetBeans.org Group, NetBeans IDE project. Disponível em: www.netbeans.org.
[3] NetBeans.org Group, Refactoring project. Disponível em: refactoring.netbeans.org.
[4] NetBeans.org Group, Metadata Repository project (MDR). Disponível em: mdr.netbeans.org.
