"Hola de nuevo."
"¡Hola!"
"Hoy les hablaré sobre la refactorización. Refactorizar es cambiar el código de un proyecto sin cambiar su funcionalidad".
"¿Pero, cómo es posible?"
"Bueno, en los casos más simples, podríamos renombrar variables y/o métodos. Después de todo, cambiar el nombre de una variable no hará que el programa funcione de manera diferente, ¿o sí?"
"Por supuesto que no."
" También puede dividir métodos grandes en varios más pequeños " .
"Puede extraer fragmentos de código repetidos en un método separado " .
"Algunas funciones pueden declararse estáticas y luego trasladarse a clases de utilidad".
"Pero esta es una interpretación estrecha de la refactorización".
"Refactorizar a veces significa reescribir (mejorar) la arquitectura de un proyecto sin agregar una nueva funcionalidad. Esto es refactorizar en el sentido amplio del término".
"IntelliJ IDEA se convirtió en el entorno de desarrollo integrado (IDE) más popular, específicamente porque fue el primero en introducir herramientas de refactorización muy poderosas".
"¿Qué son estas herramientas mágicas?"
Truco de magia #1: Cambia el nombre de un método.
"Imagínese que su código tiene un método que se llama desde 100 a 500 lugares diferentes. Ha decidido cambiar su nombre por uno más comprensible. Digamos que es run(), y quiere que sea runDownloadTaskAsync(). ¿Qué tan rápido ¿puedes hacer eso?"
"Bueno, primero necesita cambiar el nombre del método, luego busque todos los lugares en el programa donde se llama a ese método y cambie el nombre allí también".
"¿Y cómo encontrarías esos lugares?"
"Simplemente ejecutaría el programa e IntelliJ IDEA me mostraría todos los lugares donde se llama a un método inexistente".
"Está bien. Pero ahora supongamos que cada método tiene un comentario explicativo (JavaDoc) que explica lo que hace el método, y el nombre del método anterior está escrito allí".
"Yo también cambiaría los comentarios".
"Pero también puede haber variables cuyos nombres estén asociados con el nombre del método. Sería bueno cambiarlos también:"
| Antes | Después |
|---|---|
|
|
"Sí, sería bueno cambiar los nombres de esas variables también. No estaría de más".
"Bueno, ¡todo esto se puede hacer en solo unos segundos usando IntelliJ IDEA!"
"Coloca el cursor en el nombre del método (o hace clic con el mouse) y luego presiona Shift+F6 y simplemente comienza a escribir el nombre del método deseado".
"Aquí hay un ejemplo de cómo editar el nombre de un método".
"Comenzar a editar:"
"Especifique un nuevo nombre:"
"Simplemente ingrese un nuevo nombre, presione enter, y eso es todo. Este método cambiará de nombre en todas partes en las que se llame en el proyecto".
"IntelliJ IDEA también suele preguntar si desea cambiar el nombre de las variables y los nombres de los métodos en los comentarios. Simplemente haga clic en 'Sí' y cambiará todo".
"Además, si el proyecto se compiló antes de esta operación de refactorización, se garantiza que se compilará después de la refactorización".
"Suena muy prometedor".
"Por cierto, puede cambiar los nombres de las variables de la misma manera. Después de hacer clic en un nombre, simplemente presione Shift+F6 . Luego puede ingresar un nuevo nombre e IntelliJ cambiará el nombre de la variable donde sea que se use " .
"Si la variable es un campo en una clase y tiene un getter y un setter, entonces los nombres de getter y setter también se cambiarán para que coincidan con el nuevo nombre de la variable".
"Lo probé usando variables. Todo funciona tal como dijiste, Ellie. ¡La refactorización es increíble!"
"¿Crees que eso es todo lo que hay que hacer con la refactorización? La refracción es un tema tan amplio que ni siquiera hemos arañado la superficie".
"Guau. ¿Qué más hay?"
Truco de magia #2: Extrae una variable.
"A veces, ciertas expresiones se repiten con tanta frecuencia en el código que querrá moverlas a una variable separada. Por ejemplo:"
public void printInfo(User user)
{
System.out.println(user.getProfile().getName());
System.out.println(user.getProfile().getAddress().getState());
System.out.println(user.getProfile().getAddress().getCity());
System.out.println(user.getProfile().getAddress().getStreet());
System.out.println(user.getProfile().getAddress().getHomeNumber());
}public void printInfo(User user)
{
Address address = user.getProfile().getAddress();
System.out.println(user.getProfile().getName());
System.out.println(address.getState());
System.out.println(address.getCity());
System.out.println(address.getStreet());
System.out.println(address.getHomeNumber());
}"Ah".
"Y el código puede ser mucho más complicado, con muchas partes repetidas".
"Los programadores no lo escriben de esa manera intencionalmente. Pero a menudo necesitará agregar algo a un método, luego algo más, y con el tiempo la cantidad de repeticiones se dispara".
"Al crear una variable separada, podemos darle un nombre propio y mejorar la legibilidad del código".
"Por ejemplo, en el ejemplo anterior, tal vez no estemos hablando de la dirección de una casa. Tal vez estemos hablando de la dirección de un contacto de emergencia. Entonces podría llamar a esta variable dirección de contacto de emergencia, en lugar de solo dirección. Entonces, un programador ver este código por primera vez comprenderá lo que está pasando aquí".
"Sí, estoy de acuerdo. Agregar tales variables tiene sentido".
"¿Entonces, cómo lo haces?"
"Mover una expresión a una variable separada es muy simple".
Paso 1: Use el mouse para seleccionar la expresión.
Paso 2: Presione Ctrl+Alt+V
"Se abre una ventana donde IntelliJ IDEA nos pregunta si queremos reemplazar solo la expresión seleccionada o todas las instancias de la expresión (4 ocurrencias)".
"Seleccione la segunda opción para reemplazar todas las ocurrencias (Reemplazar las 4 ocurrencias)"
Paso 3: Presione Entrar.
"IntelliJ IDEA le pedirá que ingrese un nombre de variable. También hará su propia sugerencia para el nombre. No está mal, ¿eh?"
"Ajá. Justo. También planeábamos nombrar la variable 'dirección'. ¿Cómo lo supo?"
"Al usar el nombre del último método en la expresión, que devuelve una dirección. Por lo tanto, es probable que la variable se use para almacenar una dirección".
"Eso funcionó muy bien. Gran cosa, Ellie".
Truco de magia n.º 3: extraiga el código en un método separado.
"Pero podríamos haber hecho otra cosa. Podríamos haber declarado un nuevo método, por ejemplo, printAddress (), y haber trasladado todo este código a él".
"Intentemos hacer eso".
Paso 1: selecciona las 4 líneas de código que usan la variable de dirección:
Paso 2: presione Ctrl+Alt+M
"IntelliJ IDEA determina qué variables necesitará el método y sugiere cómo debería verse. "Lo único que queda es ingresar un nombre para el método".
Paso 3: Ingrese printAddress como el nombre del método y presione Enter.
"¿Qué le parece eso?"
"Es increíble. IntelliJ IDEA no solo extrajo el código en un método separado, sino que también agregó todas las variables requeridas. Además, adivinó todos los nombres correctamente".
GO TO FULL VERSION