Arreglo rápido

El editor Java ofrece correcciones para los problemas que se producen mientras se escribe código y después de la compilación. Para indicar que se dispone de propuestas correctoras de un problema o un aviso, aparece una 'bombilla' en la barra de anotaciones del editor.
Para abrir las propuestas del problema en la posición del cursor, pulse la bombilla con el botón izquierdo del ratón o pulse las teclas Control+1 (Editar / Arreglo rápido) para invocar la función de Arreglo rápido.
Diálogo de selección de arreglo rápido

Los arreglos rápidos disponibles son los siguientes:

Declaración de paquete
  • Añadir una declaración de paquete que falta o corregir una declaración de paquete.
  • Mover la unidad de compilación al paquete que se corresponde con la declaración de paquete.
Importaciones
  • Eliminar las importaciones no utilizadas, irresolubles o no visibles.
  • Invocar 'Organizar importación' cuando se producen problemas en las importaciones.
Tipos
  • Crear una clase nueva o una interfaz nueva para las referencias a los tipos que no se pueden resolver.
  • Cambiar la visibilidad de los tipos a los que se accede, pero que no son visibles.
  • Redenominar con el nombre de un tipo similar para las referencias a los tipos que no se pueden resolver.
  • Añadir una sentencia de importación para los tipos que no se pueden resolver, pero que existen en el proyecto.
  • Añadir una sentencia de importación explícita para las referencias de tipo ambiguas (dos demandas de importación (import-on-demands) para el mismo tipo).
  • Si el nombre del tipo no coincide con el nombre de la unidad de compilación, redenominar el tipo o redenominar la unidad de compilación.
  • Eliminar tipos privados que no se utilizan.
Constructores
  • Crear un constructor nuevo para las referencias a constructores que no se pueden resolver (creación de clase nueva, this o super).
  • Reordenar o eliminar los argumentos de las referencias de constructor que discrepan en los parámetros.
  • Cambiar un método con nombre de constructor por el constructor (eliminar tipo de retorno).
  • Cambiar la visibilidad de los constructores a los que se accede, pero que no son visibles.
  • Eliminar un constructor privado que no se utilice.
  • Crear un constructor cuando la llamada a super del constructor por omisión implícito no está definida, no es visible o lanza una excepción.
  • Si el tipo contiene métodos no implementados, cambiar el modificador del tipo por 'abstract' o añadir el método que debe implementarse.
Métodos
  • Crear un método nuevo para las referencias a los métodos que no se pueden resolver.
  • Redenominar con el nombre de un método similar para las referencias a los métodos que no se pueden resolver.
  • Reordenar o eliminar los argumentos de las referencias de método que discrepan en los parámetros.
  • Corregir el acceso (visibilidad, estático) de los métodos a los que se hace referencia.
  • Eliminar métodos privados que no se utilizan.
  • Corregir el tipo de retorno de métodos a los que les falte un tipo de retorno o cuyo tipo de retorno no coincida con la sentencia de retorno.
  • Añadir una sentencia de retorno, en caso de que falte.
  • En el caso de los métodos no abstractos que no tienen cuerpo, cambiar a 'abstract' o añadir cuerpo.
  • En el caso de un método abstracto de un tipo no abstracto, eliminar el modificador abstracto del método o hacer que el tipo sea abstracto.
  • En el caso de un método abstracto/nativo que tenga cuerpo, eliminar el modificador abstracto o nativo o bien eliminar el cuerpo.
  • Cambiar el acceso del método para que sea 'static', si el método se invoca dentro de una invocación de constructor (super, this).
  • Cambiar el acceso del método para que sea un acceso por omisión con el fin de evitar un acceso de método emulado.
Campos y variables
  • Corregir el acceso (visibilidad, estático) de los campos a los que se hace referencia.
  • Crear campos, parámetros o variables locales nuevas para las referencias a variables que no se pueden resolver.
  • Redenominar en una variable con un nombre similar para las referencias que no se pueden resolver.
  • Eliminar campos privados que no se utilizan.
  • Corregir el acceso no estático de campos estáticos.
  • Añadir el modificador 'final' a las variables locales a las que se accede en tipos externos.
  • Cambiar el acceso del campo para que sea un acceso por omisión con el fin de evitar un acceso de campo emulado.
  • Cambiar el tipo de variable local para arreglar una discrepancia de tipos.
  • Inicializar una variable que no se haya inicializado.
Manejo de excepciones
  • Eliminar un bloque catch que no se necesite.
  • Manejar una excepción no capturada rodeándola con un bloque try/catch o añadiendo un bloque catch a un bloque try circundante.
  • Manejar una excepción no capturada añadiendo una declaración throw al método padre o generalizando una declaración throw existente.
Otros
  • Añadir o cambiar una conversión temporal (cast) para arreglar las discrepancias de tipos.
  • En el caso de las series no NLS, abrir el asistente NLS o marcar como no NLS.

La asistencia rápida dispone de propuestas incluso si no hay ningún problema o aviso: no se muestra una bombilla en estos casos, así que el usuario debe saber cuáles son las asistencias disponibles.

Asistencias rápidas
  • Sustituir la cláusula catch por una declaración throws en el método padre.
  • Transformar una sentencia de expresión en una asignación a un campo nuevo o local nuevo.
  • Eliminar una sentencia 'if', 'for', 'while', 'do' circundante.
  • Eliminar un bloque try circundante con un solo bloque catch o finally.
  • Eliminar un paréntesis, bloque o clase anónima circundante.
  • Redenominar localmente un tipo, método o variable en una modalidad 'template' enlazada.
  • Rodear las líneas seleccionadas con plantillas (''if', 'while'...).

Conceptos relacionados
Editor Java

Consulta relacionada
Acciones de JDT

Copyright (c) 2000, 2003 IBM Corporation y otras empresas. Reservados todos los derechos.