Desde la versión 21 de Java se pueden crear métodos main() no estáticos para ejecutar nuestros programas. El objetivo principal es mejorar el protocolo de lanzamiento de programas Java para permitir métodos main() de instancia: métodos que no son static, no necesitan ser public, ni la clase ni el método y no necesitan el parámetro String[].

Esta característica fue introducida como preview en Java 21 y finalizada en Java 25.

En su forma mínima, podemos crear un método main() sin static ni public y sin pedir el parámetro String[].

class Saludo {
    void main() {
        System.out.println("Hola desde un método de instancia");
    }
}

Guarda el código anterior en un fichero llamado Saludo.java. Observa que la clase no la hemos declarado public. Tampoco hemos declarado public ni static el método main(), ni hemos puesto argumentos String[].

Para compilar:

javac Saludo.java

Para ejecutar, si utilizas Java 21, tendrás que indicar a la JVM que utilice las características en preview:

java --enable-preview Saludo

En cambio, si utilizas Java 25, no será necesario hacer ninguna indicación:

java Saludo

Esta ha sido la salida en mi ordenador utilizando Java 21:

Utilizando Java 25:

¿Por qué se introdujo esto?

La motivación principal es pedagógica: static no solo es misterioso para los principiantes, sino perjudicial. Para añadir más métodos que main() pueda llamar, el estudiante debe declarar todo como static (propagando un idioma poco habitual) o enfrentarse a la diferencia entre miembros estáticos y de instancia antes de haber aprendido variables y flujo de control.

Clase con miembros de instancia

Observa que, al no ser estático el método main(), puede utilizar atributos y métodos de instancia, sin necesidad de que sean static. Los podremos utilizar desde dentro de main() con total normalidad. Prueba con el siguiente código:

class Calculadora {
    int base = 10;   // campo de instancia, accesible desde main

    void main() {
        System.out.println("Base: " + base);
        System.out.println("Doble: " + doble(base));
    }

    int doble(int n) {
        return n * 2;
    }
}

Puedes compilar con normalidad pero, para ejecutar, tendrás que tomar las mismas precauciones que en el caso anterior si utilizas Java 21. La salida en mi ordenador con Java 25:

Clase con parámetros de entrada

También podrías utilizar parámetros de entrada. Prueba el siguiente código:

class App {
    void main(String[] args) {
        System.out.println("Argumentos: " + args.length);
    }
}

Como en los ejemplos anteriores, si ejecutas en Java 21 tendrías que añadir –enable-preview. En Java 25, no sería necesario:

Método main(), sin clase (clases implícitas)

Podemos ir un paso más allá. Podemos utilizar directamente el método main(), sin necesitad de que esté incluido en ninguna clase. Esta característica se denomina unnamed classes o también clases implícitas. Prueba el siguiente código dentro de un fichero llamado, por ejemplo, MiClaseImplicita.java :

// Sin declaración de clase. Requiere --enable-preview en javac 21
void main() {
    System.out.println("Hola");
}

Una diferencia con los ejemplos anteriores es que ahora, si compilas con Java 21, también tendrás que añadir el parámetro –enable-preview. En Java 25 no es necesario:

Como puedes ver, las nuevas versiones de Java ofrecen opciones interesantes que merece la pena explorar. Eso sí, ¡no utilices estas opciones en los exámenes de la asignatura, pues podrías suspender! 🤣

Santiago Higuera, 26 de marzo de 2026

1. Introducción

Eclipse IDE es la herramientas elegida en la ETSIST para el desarrollo de aplicaciones Java. Vas a tener que utilizarla, no solo en Programación II, sino en asignaturas posteriores, como Programación Avanzada de Aplicaciones o Software de Comunicaciones. Si en tu futura actividad profesional tienes que programar en Java, Eclipse es una buena opción para desarrollar los programas. Conocer bien sus funcionalidades puede marcar una gran diferencia en tu productividad como programador.

Este documento recoge los atajos de teclado más útiles, así como opciones de configuración y características del entorno que te permitirán trabajar de forma más ágil y eficiente durante las prácticas de la asignatura y en tu futuro profesional.

💡 Consejo: en general, todos los atajos de teclado están asociados a una opción que se puede seleccionar en algún menú o mediante alguna acción de ratón, pero es mucho más eficiente aprender a utilizar atajos de teclado. Dedica unos días a practicar estos atajos conscientemente. Al principio puede parecer lento, pero en poco tiempo serán automáticos y ahorrarás mucho tiempo en cada sesión de trabajo.

📋Nota: puedes descargar la versión pdf de este artículo desde el siguiente enlace:
https://github.com/shiguera/Apuntes_C_Java/raw/master/ManualEclipse.pdf

2. Gestión de vistas y perspectivas

Eclipse organiza su interfaz (workbench, banco de trabajo) en perspectivas. Cada perspectiva es un conjunto de vistas y cada vista permite visualizar determinados contenidos. Por ejemplo, el explorador de paquetes que se muestra a la izquierda de la ventana de Eclipse es una vista. Además, Eclipse muestra en la parte central el área de ecditores, que es donde visualizaremos el contenido de los archivos.

Eclipse tiene una serie de perspectivas predefinidas. La perspectiva Java, que es la que usaremos normalmente al hacer los programas, muestra la vista del explorador de paquetes a la izquierda, el editor de código en el centro, las vistas outline y Task list a la derecha y las vistas de problemas, javadoc y otras en la parte inferior. La figura siguiente muestra la perspectiva Java original, con indicación de las vistas que utiliza:

Hay otras perspectivas. Cuando depuremos programas, por ejemplo, se puede activar la perspectiva de depuración, que muestra otra serie de vistas ordenadas de cierta forma.

Desde el menú “Window -> Show View“, podemos abrir nuevas vistas. Cada vista la podemos situar en el panel que elijamos, pichando en su pestaña y arrastrándola al lugar deseado. También podemos separarlas de la ventana principal, pichando con el botón derecho en su pestaña y seleccionando detach. Para volver a llevarla a la ventana principal, podemos pinchar en la pestaña y arrastrarla.

Podemos seleccionar la perspectiva que queremos activar en la opción de menú “Window -> Perspective -> Open Perspective“.

Además de las perspectivas que trae el programa definidas por defecto, podemos crear nuestras propias perspectivas para autilizar en nuestros proyectos. El menú “Window -> Perspective” ofrece opciones para ello.

También podemos restaurar la disposición original de una perspectiva seleccionando “Window -> Perspective -> Reset Perspective“.

2.1 Vistas recomendadas

• Package Explorer: navegación por la estructura del proyecto. Actívalo siempre.
• Project Explorer: es similar a la anterior, pero permite ver todas las carpetas del proyecto, por ejemplo la carpeta bin con los archivos compilados. En un artículo anterior en este mismo blog expliqué cómo hacer para ver la carpeta bin.
• Outline: muestra la estructura del archivo actual (métodos, atributos). Muy útil en clases largas.
• Console: salida del programa y mensajes de error. Imprescindible en todo momento.
• Problems: lista de errores y advertencias. Haz clic en cada problema para ir directo a la línea.
• Javadoc: muestra la documentación de la clase o método bajo el cursor automáticamente.
• Call Hierarchy (Ctrl + Alt + H): muestra quién llama a un método y a quién llama él.
• Type Hierarchy (F4): muestra la jerarquía de herencia de una clase.

2.2 Gestión de ventanas en el editor

Sabemos que se pueden tener varias pestañas abiertas en el editor, cada una correspondiente a una clase o fichero diferente. Pero también podemos partir la ventana del editor en horizontal o en vertical, para visualizar simultáneamente varios ficheros, como se ha hecho en la imagen siguiente:

Seguramente, la forma más cómoda de hacerlo sea arrastrando con el ratón una de las pestañas hacia el borde de la ventana. En la imagen anterior se ha hecho además otro ajuste: pulsando Ctrl + M se maximiza la ventana del editor, ocultando otros paneles, como el panel del explorador de paquetes u otros que hubiera abiertos. Para restituir la vista de dichos paneles solo hay que volver a pulsar Ctrl + M .

Podemos mostrar en una de las subventanas cualquier otra vista que tengamos abierta, por ejemplo el terminal u otra. El procedimiento es el mismo: pinchar en la pestaña de la vista que queremos mover y arrastrarla hasta el punto donde queremos visualizarla.

También es posiible mostrar en dos paneles el mismo fichero, situado en diferentes posiciones de dición (split). Esto puede facilitar la edición del código en ficheros de gran tamaño. Para mostrar un mismo fichero en dos paneles en horizontal hay que teclear Ctrl + AltGr + {. Una nueva pulsación del atajo de teclado indicado, desactivará la opción. Para colocar los dos paneles uno encima del otro hay que pulsar Ctrl + Shift + -.

2.3 Atajos de vistas y perspectivas

Atajo	Descripción
Ctrl + M	Maximizar o restaurar el editor o vista actual
Ctrl + F8	Cambiar entre perspectivas (Java, Debug, Git…)
F12	Volver el foco al editor de código
Ctrl + AltGr + {	Split horizontal
Ctrl + Shift + -	Split vertical

3. Atajos para gestión de ficheros

Atajo	Descripción
Ctrl + N	New: abre el diálogo File ->New
Ctrl + S	Guardar

4. Atajos Esenciales de Edición de Código

Estos son los atajos que usarás a diario al escribir código Java. Merece la pena aprenderlos desde el primer día.

4.1 Escritura y formato

Atajo	Descripción
Ctrl + Espacio	Autocompletado de código: completa nombres de clases, métodos, variables y genera plantillas (sysout, for, if, try…)
Ctrl + Shift + F	Formatea automáticamente todo el archivo según las convenciones de Java
Ctrl + D	Elimina la línea actual completa sin necesidad de seleccionarla
Alt + ↑ / Alt + ↓	Mueve la línea actual (o selección) hacia arriba o hacia abajo
Ctrl + Alt + ↑ / ↓	Duplica la línea actual hacia arriba o hacia abajo
Ctrl + Shift + 7	Comenta o descomenta la línea actual con // (en teclado español, / equivale a Shift + 7)
Ctrl + Shift + 7 (bloque)	En teclado español, este mismo atajo sobre una selección comenta las líneas individualmente con //. Para comentario de bloque /* ... */ no hay atajo directo: usad el menú Source → Toggle Block Comment
Tab / Shift + Tab	Aumenta o reduce la indentación del bloque seleccionado
Ctrl + Z / Ctrl + Y	Deshacer / Rehacer última acción
Ctrl + C	Copy
Ctrl + V	Paste
Ctrl + X	Cut

💡 Consejo: Ctrl + Espacio es el atajo más poderoso de Eclipse. Úsalo constantemente: no solo completa palabras, también genera estructuras completas como bucles for-each, bloques try-catch, el método main, etc.

Por ejemplo, para escribir System.out.println(), solo tendrás que teclear sysout seguido de Ctrl + espacio. Más adelante, en el apartado sobre Generación automática de código ampliamos información sobre este tema.

4.2 Navegación dentro del código

Atajo	Descripción
Ctrl + Clic / F3	Ir a la definición de la clase, método o variable bajo el cursor
Alt + ← / Alt + →	Retroceder / avanzar en el historial de navegación
Ctrl + L	Ir a una línea concreta del archivo por número
Ctrl + Q	Volver a la última posición editada
Ctrl + E	Mostrar lista de editores abiertos para cambiar rápidamente entre archivos
Ctrl + F6	Alternar entre los editores abiertos (como Alt+Tab del sistema)
Ctrl + Shift + G	Buscar todas las referencias a un método o variable en el proyecto

4.3 Selección de texto

Atajo	Descripción
Shift + Alt + ↑	Ampliar la selección al elemento sintáctico superior (seleccionar bloques completos)
Shift + Alt + ↓	Reducir la selección al elemento sintáctico inferior
Ctrl + A	Seleccionar todo el contenido del archivo
Alt + Shift + A	Activar modo de selección por columnas (selección rectangular)

---

5. Búsqueda y Reemplazo

Atajo	Descripción
Ctrl + F	Abrir el panel de búsqueda en el archivo actual
Ctrl + H	Búsqueda avanzada en todo el proyecto (por archivos, expresiones regulares…)
Ctrl + K	Buscar la siguiente ocurrencia del texto seleccionado
Ctrl + Shift + K	Buscar la ocurrencia anterior del texto seleccionado
Ctrl + J	Búsqueda incremental: encuentra resultados en tiempo real mientras escribes
Ctrl + Shift + R	Abrir un recurso (archivo) del proyecto buscando por nombre
Ctrl + Shift + T	Buscar y abrir un tipo (clase, interfaz, enum) de todo el workspace
Ctrl + O	Mostrar el esquema del archivo actual: métodos, atributos, constructores

💡 Consejo: Ctrl + Shift + T y Ctrl + Shift + R son imprescindibles en proyectos grandes. Permiten localizar cualquier clase o archivo instantáneamente sin navegar por el Package Explorer.

---

6. Refactorización de Código

Eclipse ofrece potentes herramientas de refactorización que modifican el código de forma segura, actualizando automáticamente todas las referencias en el proyecto.

🗒️ Nota: se denomina refactorizar a modificar el código de un programa sin afectar a su funcionamiento. Por ejemplo, cambiar el nombre a una variable o método es una refactorización frecuente.

Atajo	Descripción
Alt + Shift + R	Renombrar una clase, método, variable o paquete actualizando todas las referencias
Alt + Shift + M	Extraer el código seleccionado a un nuevo método
Alt + Shift + L	Extraer la expresión seleccionada a una variable local
Alt + Shift + I	Hacer inline: sustituir el uso de una variable por su valor directamente
Alt + Shift + C	Cambiar la firma de un método (parámetros, nombre, visibilidad)
Alt + Shift + T	Abrir el menú de refactorización completo sobre el elemento seleccionado
Alt + Shift + S	Abrir el menú Source: generar getters/setters, constructores, toString…

💡 Consejo: Usa siempre Alt + Shift + R para renombrar, nunca lo hagas manualmente con buscar y reemplazar. Eclipse actualiza todas las referencias del proyecto de forma segura y no os perderéis ninguna ocurrencia.

---

7. Generación Automática de Código

Eclipse puede generar por ti mucho código repetitivo. Accede al menú Source (Alt + Shift + S) para ver todas las opciones disponibles:

Atajo	Descripción
Alt + Shift + S, R	Generar métodos getter y setter para los atributos de la clase
Alt + Shift + S, O	Generar constructores usando campos de la clase
Alt + Shift + S, H	Generar los métodos hashCode() y equals()
Alt + Shift + S, S	Generar el método toString()
Alt + Shift + S, V	Implementar métodos abstractos no implementados de interfaces o clases abstractas
Alt + Shift + S, U	Generar métodos de superclase no implementados
Ctrl + 1	Correcciones rápidas: resolver imports, crear métodos, capturar excepciones, etc.

💡 Consejo: Ctrl + 1 (Quick Fix) es uno de los atajos más valiosos. Si Eclipse marca un error en rojo, pulsad Ctrl + 1 y os ofrecerá soluciones automáticas: añadir imports, crear métodos que faltan, encapsular en try-catch…

7.1 Plantillas de código (Templates)

Eclipse tiene plantillas de código que se activan escribiendo la abreviatura y pulsando Ctrl + Espacio. Por ejemplo, si tecleas main, seguido de Ctrl + espacio, se escribirá el método main()completo.

Abreviatura	Genera
sysout	System.out.println();
syserr	System.err.println();
for	Bucle for clásico con índice
foreach	Bucle for-each sobre una colección
try	Bloque try-catch-finally
main	public static void main(String[] args)
ifelse	Estructura if-else completa

Puedes crear tus propias plantillas en: Window → Preferences → Java → Editor → Templates.

8. Depuración (Debug)

El depurador de Eclipse es una herramienta fundamental para entender el comportamiento de tus programas y localizar errores lógicos de forma eficiente.

Atajo	Descripción
F11	Ejecutar en modo Debug (lanza la última configuración usada)
Ctrl + Shift + B	Añadir o quitar un Breakpoint en la línea actual
F8	Continue: continuar la ejecución hasta el siguiente breakpoint
F6	Step Over: ejecutar la línea actual sin entrar en el método llamado
F5	Step Into: entrar dentro del método llamado en la línea actual
F7	Step Return: salir del método actual y volver al llamador
Ctrl + Shift + I	Inspect: evaluar una expresión o variable en el contexto actual
Ctrl + F2	Terminar la sesión de depuración

💡 Consejo: Para depurar eficientemente: pon breakpoints estratégicos al inicio de métodos sospechosos, usa la vista Variables para inspeccionar el estado, y añade Watch Expressions para evaluar expresiones complejas en tiempo real.

---

9. Opciones de Configuración Útiles

9.1 Compilación automática

Window → Preferences → General → Workspace: activad Build automatically para que Eclipse compile y detecte errores al instante.

9.2 Acciones al guardar (Save Actions)

Window → Preferences → Java → Editor → Save Actions: configurad que al guardar (Ctrl + S) Eclipse formatee el código y organice los imports automáticamente.

💡 Consejo: Activar el formateo automático al guardar es una de las mejores decisiones que puedes tomar. Tu código siempre estará bien indentado sin ningún esfuerzo extra.

9.3 Otros ajustes recomendados

• Números de línea: clic derecho en el margen izquierdo del editor → Show Line Numbers.
• Tema oscuro: Window → Preferences → General → Appearance → Theme 'Dark'. Reduce la fatiga visual en sesiones largas.
• Organizar imports: Ctrl + Shift + O completa imports pendientes y elimina imports innecesarios del archivo actual.

---

10. Abrir Archivos en el Explorador del Sistema y el Terminal

En ocasiones necesitarás acceder a los archivos del proyecto desde fuera de Eclipse: para compartir ficheros, abrirlos con otra aplicación o lanzar un terminal en esa ubicación. Eclipse facilita esto directamente desde el Package Explorer.

10.1 Abrir la ubicación en el explorador de archivos del sistema

Haz clic derecho sobre el fichero o carpeta en el Package Explorer y selecciona:

Show In → System Explorer

Esto abrirá el explorador de archivos del sistema operativo (Explorador de Windows, Finder en macOS o el gestor de archivos en Linux) con el fichero o carpeta ya seleccionado en su ubicación real en el disco.

💡 Consejo: Esta opción es especialmente útil para localizar rápidamente dónde está guardado tu proyecto en el disco, sin tener que buscar manualmente la carpeta del workspace de Eclipse.

10.2 Abrir un terminal externo desde esa ubicación

Una vez en el explorador de archivos del sistema operativo, puedes abrir un terminal situado directamente en esa carpeta sin necesidad de navegar manualmente hasta ella:

• Windows: haz clic derecho sobre la carpeta (o sobre el fondo de la ventana si ya estás dentro) y selecciona Abrir en Terminal.
• macOS: clic derecho sobre la carpeta → Servicios → Nuevo Terminal en la Carpeta (puede requerir activarlo en Preferencias del Sistema → Teclado → Servicios).
• Linux: clic derecho sobre la carpeta → Abrir en Terminal (el nombre exacto depende del gestor de archivos).

De esta forma puedes ejecutar comandos directamente en el directorio del proyecto, por ejemplo para compilar con javac o ejecutar con java.

---

11. Personalización de Atajos de Teclado

Eclipse permite consultar y modificar todos los atajos desde un único panel, lo que resulta especialmente útil para resolver conflictos o asignar atajos a comandos que no los tienen (como ocurre con Toggle Block Comment en teclado español).

11.1 Cómo acceder al panel de atajos

Window → Preferences → General → Keys

O directamente pulsando Ctrl + Shift + L dos veces seguidas.

11.2 Consultar combinaciones en uso

En el panel de Keys encontrarás una tabla con todos los comandos del IDE. Puedes filtrarla de dos formas:

• Por nombre de comando: escribe parte del nombre en el campo Filter para ver si ya tiene atajo asignado y cuál es.
• Por combinación de teclas: haz clic en el campo Binding y pulsa la combinación que quieres comprobar. Eclipse mostrará si ya está asignada a algún comando.

Ten en cuenta que un mismo atajo puede estar libre en un contexto (Context) aunque esté siendo utilizado en otro. Por ejemplo, un atajo de teclado puede funcionar cuando estás en el editor de código y no funcionar en otras vistas.

11.3 Asignar o modificar un atajo

1. Busca el comando deseado en el campo Filter (por ejemplo, Toggle Block Comment).
2. Selecciona el comando en la tabla.
3. Haz clic en el campo Binding y pulsa la combinación de teclas que quieras asignar.
4. Comprueba que el campo Conflicts no muestre ningún conflicto.
5. Pulsa Apply and Close.

💡 Consejo: Si al pulsar la combinación Eclipse detecta un conflicto, aparecerá resaltado en la sección Conflicts. En ese caso puedes eliminar el atajo del comando conflictivo (si no lo usas) o elegir otra combinación libre.

11.4 Ejemplo: asignar un atajo a Toggle Block Comment en teclado español

El comando Toggle Block Comment (comentario de bloque /* ... */) no tiene atajo funcional en teclado español. Para asignárselo:

1. Abrid Window → Preferences → General → Keys.
2. En Filter, escribe Toggle Block Comment.
3. Selecciona el comando y haz clic en Binding.
4. Pulsa la combinación que quieras, por ejemplo Ctrl + Shift + 8 (comprueba que no haya conflictos).
5. Pulsa Apply and Close.

Atajo	Descripción
Ctrl + Shift + L	Mostrar la lista completa de todos los atajos disponibles
Ctrl + Shift + L (x2)	Abrir las preferencias de atajos de teclado para personalizarlos

---

12. Productividad en el Editor

12.1 Múltiples cursores y edición en bloque

Eclipse permite editar varias líneas simultáneamente mediante la selección por columnas, también llamada selección rectangular. Es muy útil para modificar código repetitivo en varias líneas a la vez.

Para activarla, pulsa Alt + Shift + A y luego selecciona con el ratón (o con las teclas de dirección) el bloque de líneas que quieres editar. Todo lo que escribas se aplicará en todas las líneas seleccionadas al mismo tiempo.

💡 Consejo: Es especialmente útil para añadir o eliminar un prefijo o sufijo en varias líneas a la vez, como comentar un bloque de declaraciones o alinear asignaciones.

12.2 Comparar dos archivos entre sí

Eclipse permite comparar el contenido de dos archivos directamente desde el Package Explorer, sin necesidad de herramientas externas. Selecciona los dos archivos manteniendo Ctrl pulsado, haz clic derecho y elige:

Compare With → Each Other

Se abrirá una vista de diferencias que muestra lado a lado el contenido de ambos archivos, resaltando las líneas que difieren. Es muy útil para comparar versiones de una práctica o revisar cambios entre dos implementaciones.

---

13. Comprensión del Código

13.1 Call Hierarchy y Type Hierarchy

Estas dos vistas ayudan a entender la estructura y el flujo de un programa, especialmente cuando se trabaja con herencia y polimorfismo.

Call Hierarchy (Ctrl + Alt + H sobre un método): muestra un árbol con todos los métodos que llaman al método seleccionado (Caller Hierarchy) y todos los métodos a los que él llama (Callee Hierarchy). Es muy útil para entender el impacto de un cambio o seguir el flujo de ejecución.

Type Hierarchy (F4 sobre una clase o interfaz): muestra la jerarquía completa de herencia, tanto hacia arriba (superclases e interfaces implementadas) como hacia abajo (subclases). Imprescindible cuando trabajéis con herencia para tener una visión global de la jerarquía de clases.

13.2 Javadoc emergente al pasar el ratón

Simplemente dejando el cursor del ratón sobre el nombre de una clase, método o variable durante un momento, Eclipse muestra automáticamente una ventana emergente con su documentación Javadoc: descripción, parámetros, valor de retorno y excepciones.

No es necesario ningún atajo: basta con sobrevolar con el ratón. Si quieres verlo de forma fija en una vista permanente, activa la vista Javadoc desde Window → Show View → Javadoc, que se actualiza automáticamente según el elemento bajo el cursor.

💡 Consejo: Aprovecha esta función constantemente al usar las clases de la API de Java (listas, colecciones, String, etc.). Es mucho más rápido que buscar en la documentación oficial.

---

14. Gestión del Proyecto

14.1 Exportar el proyecto como archivo .jar

Cuando quieras entregar una práctica como ejecutable, o reutilizar tu código en otro proyecto, puedes empaquetarlo como un archivo .jar:

1. Clic derecho sobre el proyecto en el Package Explorer → Export...
2. Selecciona Java → Runnable JAR file (si quieres un JAR ejecutable) o Java → JAR file (si es una librería).
3. Elige la clase que contiene el método main como punto de entrada (solo para JAR ejecutable).
4. Indica la ruta de destino y pulsa Finish.

💡 Consejo: Un Runnable JAR puede ejecutarse directamente con java -jar archivo.jar desde el terminal, sin necesidad de tener Eclipse instalado.

14.2 Incorporar un archivo .jar externo al classpath del proyecto

Cuando necesites usar una librería externa (por ejemplo, una proporcionada por el profesor o descargada de Internet), debes añadir su .jar al classpath del proyecto para que Eclipse la reconozca:

1. Copia el archivo .jar en una carpeta dentro del proyecto (por convenio, se suele llamar lib/).
2. Clic derecho sobre el archivo .jar en el Package Explorer → Build Path → Add to Build Path.

A partir de ese momento Eclipse reconocerá las clases de esa librería y ofrecerá autocompletado y Javadoc para ellas (si el .jar incluye documentación).

💡 Consejo: Si el .jar no aparece en el Package Explorer, comprobad que está dentro de la carpeta del proyecto. Si lo tenéis en otra ubicación del disco, usad Build Path → Configure Build Path → Libraries → Add External JARs... en su lugar.

14.3 Importar y exportar preferencias

Si trabajas en varios equipos (por ejemplo, en casa y en el laboratorio), puedes exportar toda tu configuración de Eclipse —atajos personalizados, plantillas, formato de código— y recuperarla en otro equipo.

• Exportar: File → Export → General → Preferences. Guardad el archivo .epf resultante.
• Importar: File → Import → General → Preferences. Seleccionad el archivo .epf.

💡 Consejo: Guardad tu archivo .epf en la nube o en el mismo repositorio Git del proyecto para tenerlo siempre disponible.

14.4 Working Sets

Cuando tengas varios proyectos abiertos a la vez en el workspace, el Package Explorer puede volverse difícil de manejar. Los Working Sets permiten agrupar proyectos relacionados y mostrar solo los que os interesan en cada momento.

Para crearlos: haz clic en el menú desplegable del Package Explorer (icono de flecha en la esquina superior derecha) → Select Working Set... → New....

---

15. Calidad del Código

15.1 Warnings y nivel de severidad

Eclipse no solo detecta errores de compilación (marcados en rojo), sino también advertencias (warnings, marcadas en amarillo) que señalan código potencialmente problemático: variables declaradas pero no usadas, conversiones implícitas entre tipos, comparaciones innecesarias, etc.

Es recomendable prestarles atención aunque no impidan compilar. Puedes configurar qué situaciones generan error, warning o se ignoran en:

Window → Preferences → Java → Compiler → Errors/Warnings

💡 Consejo: Un código sin warnings es señal de mayor calidad y rigor. Acostúmbrate a mantener la vista Problems limpia, no solo de errores sino también de advertencias.

15.2 Task Tags: TODO, FIXME y XXX

Eclipse reconoce automáticamente ciertos comentarios especiales en el código y los muestra como tareas pendientes en la vista Tasks (Window → Show View → Tasks):

Etiqueta	Uso habitual
// TODO	Funcionalidad pendiente de implementar
// FIXME	Código que funciona pero necesita ser corregido
// XXX	Código problemático o cuestionable que requiere atención

Por ejemplo:

// TODO implementar el manejo de excepciones
// FIXME este cálculo falla con valores negativos

Estas etiquetas aparecerán listadas en la vista Tasks, lo que permite llevar un registro de las partes del código que aún necesitan trabajo sin perder el hilo.

💡 Consejo: Usa // TODO mientras desarrollas para marcar partes incompletas, y eliminalos antes de entregar la práctica. Un TODO en el código entregado indica que sabes que algo falta.

---

16. Tabla Resumen — Cheat Sheet

Los 20 atajos que debes conocer sí o sí:

Atajo	Descripción
Ctrl + Espacio	Autocompletar código
Ctrl + 1	Corrección rápida (Quick Fix)
Ctrl + Shift + F	Formatear código
Ctrl + Shift + O	Organizar imports
Ctrl + D	Eliminar línea actual
Ctrl + S	Guardar (Save)
Ctrl + /	Comentar / descomentar línea
Ctrl + Z / Y	Deshacer / Rehacer
F3 / Ctrl + Clic	Ir a definición
Alt + ← / →	Navegar historial de edición
Ctrl + Shift + T	Buscar tipo (clase)
Ctrl + Shift + R	Buscar recurso (archivo)
Ctrl + O	Esquema del archivo actual
Alt + Shift + R	Renombrar (refactoring)
Alt + Shift + M	Extraer método
Alt + Shift + S	Menú Source (generar código)
Ctrl + Shift + B	Añadir / quitar breakpoint
F5 / F6 / F7 / F8	Debug: Step Into / Over / Return / Continue
Ctrl + M	Maximizar editor
Ctrl + Shift + L	Ver todos los atajos disponibles

---

¡La práctica hace al maestro! Cuanto más uses estos atajos, más naturales te resultarán.

Santiago Higuera, 26 de marzo de 2026

El modelo de ejecución de Java se inicia con el código fuente del programa escrito en lenguaje Java y almacenado en ficheros .java. Dicho código fuente se compila a un código intermedio llamado bytecode, que se guarda en ficheros .class. Finalmente, la máquina virtual de Java (JVM, Java Virtual Machine) ejecuta dicho código. La figura siguiente esquematiza este modelo de ejecución.

La utilización de Eclipse facilita la tarea de compilar y ejecutar nuestros programas Java, aunque hace perder un poco la perspectiva del proceso de compilación y ejecución. En otro artículo anterior ya comente cómo configurar Eclipse para sortear, al menos en parte, este inconveniente.

Creo que es bueno practicar la compilación y ejecución de programas escritos en Java utilizando el terminal. Además de redundar en el dominio de las herramientas, cuando hay que ejecutar un programa con parámetros de entrada, resulta más sencillo hacerlo desde el terminal que desde Eclipse.

En este artículo voy a explicar cómo hacerlo en distintas circunstancias, desde un programa sencillo compuesto de una única clase, hasta programas complejos con varias clases distribuidas en paquetes y que utilizan bibliotecas externas .jar.

Programa con una única clase

El caso más sencillo es cuando tenemos una única clase, Main.java, dentro del directorio del proyecto. La estructura sería la de la siguiente figura:

Para compilar el programa, tendremos que abrir un terminal situado en la carpeta del proyecto y teclear la siguiente instrucción:

javac Main.java

Si todo va bien y el programa no tiene errores, el resultado será que el compilador de Java (javac) creará el fichero Main.class, que es el compilado bytecode de Main.java. La estructura de la carpeta del proyecto quedará:

Puedes comprobarlo tú mismo listando los archivos de la carpeta con la orden dir.

Para ejecutar el programa, hay que utilizar la máquina virtual de Java (JVM) de nuestro sistema, que es el programa java. A la JVM hay que decirle el nombre de la clase que contiene el método main() ejecutable, en este caso:

java Main

Observa que se indica el nombre de la clase, sin extensiones.

Programa con varias clases

Podría suceder que el programa tuviera más de una clase, pero todas en el mismo directorio del proyecto. Por ejemplo, supón que nuestro programa, además de la clase Main.java, utiliza una clase auxiliar llamada Punto.java y que las dos clases están en el directorio del proyecto:

Para compilar, tendremos que indicar a javac el nombre de todas las clases que queramos compilar:

javac Main.java Punto.java

Cuando queremos compilar todos los ficheros .java de una carpeta también se puede usar el comodín * (asterisco), que se puede leer como “todos“:

javac *.java

Esta instrucción compilaría todos los ficheros .java que haya en el directorio. En ambos casos, el resultado será que se crearán los ficheros .class correspondientes:

Para ejecutar el programa, la instrucción sería la misma que antes. Aunque haya varios .class, al invocar la JVM solo hay que pasarle el nombre de la clase que contiene el método main():

java Main

Esta estructura, con los ficheros .java y los ficheros .class en el mismo directorio, es la que resulta al crear el proyecto con Eclipse y seleccionar la opción “Use project folder as root for sources and class files”, como muestra la siguiente figura:

Redirigir los .class al directorio bin

En el apartado anterior, el fichero .class que se genera al compilar, lo hemos guardado en el mismo directorio del proyecto donde teníamos los ficheros .java. Es habitual que los ficheros compilados de un proyecto se guarden en un directorio diferente, por ejemplo en el directorio bin.

Podemos indicar al compilador de Java en qué directorio queremos que ponga los ficheros .class compilados, utilizando el parámetro -d. La orden que habría que teclear en el terminal sería:

javac -d bin *.java

Con esta orden, se compilarán todos los ficheros .java que haya en la carpeta del proyecto y los ficheros .class resultantes se pondrán en el directorio bin. La estructura de carpetas y ficheros, despues de compilar, quedaría:

Para ejecutar el programa resultante, hay que indicar a la JVM el nombre de la clase que contiene el método main(). Además, hay que indicar a la JVM la ruta donde tiene que buscar las clases compiladas, utilizando el parámetro -classpath o su forma abreviada -cp. Si ejecutamos la instrucción desde el directorio del proyecto, la orden que hay que teclear es:

java -cp bin Main

La instrucción anterior le dice a la máquina virtual: “Las clases compiladas están en la carpeta bin y tienes que ejecutar la clase Main”.

Caso general: directorios src y bin

El caso general sería el de un proyecto que tiene los ficheros fuente .java en el directorio src, repartidos en distintos paquetes. Además, queremos que los ficheros .class de las clases compiladas se guarden en el directorio bin. La estructura de ficheros antes de la compilación podría ser la siguiente:

Por supuesto, los ficheros .java de las clases tendrán que tener indicadas las instrucciones package que les corresponda en cada caso.

Con el terminal situado en la carpeta del proyecto, la orden para compilar todo y hacer la salida de los .class al directorio bin es la siguiente:

javac -d bin src\geometria\*.java src\principal\*.java 

En este caso, le estamos pidiendo al compilador que compile todos los ficheros .java que haya en las carpetas src\geometria y src\principal y coloque los ficheros compilados en la carpeta bin.

El resultado sería el siguiente:

Observa que los ficheros compilados .class quedan dentro de la carpeta bin, organizados con la misma estructura de paquetes que tienen en la carpeta src del código fuente.

Para ejecutar el programa, habrá utilizar el parámetro -cp, para indicar a la JVM la ruta donde tiene que buscar las clases compiladas y decirle el nombre de la clase que queremos ejecutar:

java -cp bin principal.Main

Fíjate en que el nombre de la clase que queremos ejecutar tiene que llevar como prefijo el paquete en el que se encuentre dicha clase. Lo que le decimos a la máquina virtual de Java es: “busca las clases compiladas en la carpeta bin y ejecuta la clase principal.Main”.

Esta estructura de carpetas es la que crea Eclipse al crear un proyecto cuando elegimos la opción “Create separate folders for sources and class files“.

Ejecutar programas con parámetros de entrada

La primera vez que queramos ejecutar desde Eclipse un programa que requiere parámetros de entrada, habrá que crear una configuración de ejecución (Run configuration). Se accede a través de la opción de menú “Run -> Run configurations” o pichando sobre la clase que tiene el método main() con el botón derecho del ratón y seleccionando “Run as -> Run configurations“.

Dentro del diálogo que aparece, habrá que seleccionar la pestaña “Arguments” y poner el valor de los argumentos que queramos pasar al programa dentro del recuadro “Program arguments“, como muestra la figura siguiente:

Cada vez que queramos ejecutar el programa, cambiando el valor de los argumentos, habrá que abrir la configuración de ejecución y modificar el valor de los mismos. Es un proceso ineficiente y tedioso.

Si ejecutamos el programa desde el terminal, es mucho más sencillo. Refiriéndonos al ejemplo utilizado anteriormente, si quisiéramos ejecutar Main y pasarle dos argumentos, la orden que habría que teclear en el terminal sería:

java -cp bin principal.Main argumento1 argumento2

Queda claro que el proceso es más sencillo. Ademas, no necesitaríamos compilar desde la consola. Podemos estar usando Eclipse, que se encargará de compilar automáticamente nuestros ficheros fuente y utilizar el terminal simplemente para ejecutar el programa.

Utilización de bibliotecas .jar

Algunos programas utilizan bibliotecas externas .jar que contienen clases compiladas. Imagina que la estructura de nuestro proyecto es la de la siguiente figura:

El proyecto, además de las clases propias, utiliza clases de biblioteca.jar. Para compilar este proyecto tendremos que decir al compilador:

• En qué directorio queremos poner las clases compiladas: parámetro -d.
• Dónde puede encontrar las clases compiladas que necesite: parámetro -cp.
• Qué ficheros .java queremos que compile.

La orden que habría que teclear en la consola sería:

javac -d bin -cp lib\biblioteca.jar src\principal\*.java src\geometria\*.java

Como resultado, el compilador creará el directorio bin con las clases compiladas dentro de él, organizadas en los paquetes que corresponda, como muestra la figura siguiente:

Para ejecutar el programa, será necesario indicar a la JVM que hay clases compiladas que las tiene que buscar en el directorio bin y otras que están en biblioteca.jar. La orden sería la siguiente:

java -cp bin;lib\biblioteca.jar principal.Main

Observa que en el parámetro -cp se han puesto dos rutas para clases compiladas, separadas por punto y coma.

En Eclipse, para incorporar una biblioteca externa a nuestro proyecto hay que utilizar la opción de menú “Project -> Properties -> Java Build Path“. En la pestaña Libraries, habrá que añadir el fichero biblioteca.jar al classpath, como muestra la siguiente figura:

Nota: en todas las instrucciones de consola se ha supuesto que se está trabajando en un ordenador Windows. En el caso de trabajar en Linux o Mac, habría que usar como separador de carpetas la barra inclinada normal / y como separador de rutas en el parámetro -cp los dos puntos, en vez del punto y coma.

Santiago Higuera, 19 de marzo de 2026

JShell es una herramienta que se instala con el Java Development Kit (JDK) y es muy útil para probar código Java, sin necesidad de hacer un programa completo y tener que compilarlo.

Para arrancar JShell tendrás que abrir un terminal y teclear:

jshell

Si todo va bien, deberías ver una pantalla similar a la de la siguiente figura:

Si quieres salir de la aplicación, tienes que teclear:

/exit

Nota: si al teclear jshell, no aparece el prompt de la aplicación, puede significar que no tienes instalado el JDK o que no tienes configurada correctamente la variable PATH del sistema.

Utilización como calculadora

Un posibilidad que ofrece JShell y que puede ser útil en determinadas circunstancias es utilizarlo como calculadora. Puedes realizar operaciones matemáticas y tendrás acceso a los métodos de la clase Math y al uso de variables.

Por ejemplo, trata de hacer en tu consola las operaciones que aparecen en la siguiente figura u otras similares:

Observa que, tras cada operación, aparece el signo del dólar ($) seguido de un número. Son variables que quedan guardadas en la memoria y pueden ser invocadas a posteriori. Observa la siguiente serie de operaciones, en la que se reutiliza uno de los resultados obtenidos:

Variables Java

También podemos definir y utilizar variables Java, pero en ese caso habrá que declarar y asignar las variables con su tipo de dato, como lo haríamos dentro de un programa:

Como detalle, puedes ver que estas instrucciones Java no las terminamos en punto y coma. En jshell no es necesario terminar las instrucciones sueltas en punto y coma (Cuando definamos clases, sí que hay que respetar la sintaxis Java).

En cualquier momento puedes consultar la lista de variables que hay en memoria tecleando la orden /vars:

Si quieres borrar totalmente el contenido de la memoria puedes teclear la orden /reset.

Probar código

Es cómodo probar código sin tener que teclear una clase completa, compilarla y ejecutarla. Además, para ver la salida por pantalla de las instrucciones, no necesitamos usar métodos System.out.println():

Probar funciones

Puedes teclear el código de una función y utilizar la función posteriormente.

Las funciones que hayas definido quedan guardadas en memoria. Puedes obtener el listado de las funciones que hayas definido en la sesión utilizando la orden /methods. Si tecleas /reset se borrará la memoria completa, incluyendo variables y funciones.

Clases y objetos

Puedes crear clases y objetos:

Podrías crear también, no solo clases, sino interfaces o enumeraciones. Para listar los tipos de datos que hayas definido en la sesión tienes que teclear la orden /types.

Una vez definido un tipo de datos, puedes crear funciones que lo utilicen, sin necesidad de incluir la función como método del tipo:

Guardar el trabajo

La orden /list sirve para ver las instrucciones que has tecleado. La orden /save, seguida de un nombre de fichero, sirve para guardar dichas órdenes en un fichero y poderlas reutilizar a posteriori. Podrías cargar el fichero en JShell al abrirlo o utilizando la orden /open.

Cargar ficheros

Podemos cargar ficheros existentes utilizando la orden /open. Imagina que tienes un fichero llamado Punto.java, en el directorio en el que has abierto JShell, con el siguiente contenido:

public class Punto {
   public int x, y;

   public Punto(int x, int y) {
      this.x = x;
      this.y = y;
   }   
   public double dist(Punto p) {
      return Math.sqrt(x*p.x + y*p.y);
   }
   public double distOrigen() {
      return Math.sqrt(x*x + y*y);
   }
}

Puedes abrir el fichero y utilizar sus definiciones:

Puedes cargar un fichero en memoria en el momento de abrir JShell tecleando su nombre a continuación de jshell:

jshell Punto.java

El fichero puede ser una clase .java o un fichero de órdenes guardadas previamente con /save. En ambos casos, las ordenes contenidas en el fichero se ejecutarán como si las tecleases dentro del terminal.

Edición en consola

Puedes usar las teclas de flecha arriba/abajo, para editar instrucciones anteriores y moverte dentro de ellas para cambiar su contenido. Esto permite modificar instrucciones anteriores que hayamos utilizado para definir tipos de datos o funciones.

Las instrucciones multilínea aparecerán de una sola vez y podrás moverte dentro de ellas para editarlas.

Cuando se necesita modificar un método ya definido, JShell ofrece el comando /edit seguido del nombre del método. Este comando abre una pequeña ventana de edición gráfica integrada en la que puede modificarse el código y confirmar los cambios con el botón Accept:

 /edit grad2rad

El editor integrado de JShell es una ventana gráfica propia de la herramienta, independiente del editor del sistema operativo. Funciona sin ninguna configuración adicional en Windows, macOS y en Linux con entorno gráfico de escritorio.

💡El editor de JShell se puede utilizar también para editar clases o interfaces. La condición para editar una función o una clase es que tienen que estar definidas previamente.

Un truco útil para crear una clase es definirla vacía en JShell y luego editarla en el editor para completar atributos y métodos de manera más cómoda. Algo parecido se puede hacer con las funciones y los interfaces.

Resumen de órdenes

La tabla siguiente muestra un resumen de las órdenes que hemos mostrado en el artículo.

Instrucción	Explicación
/exit	Cierra la consola JSHELL
CTRL + L	Limpia la pantalla
/vars	Lista las variables en memoria
/methods	Lista las funciones en memoria
/types	Lista los tipos de datos definidos
/list	Lista las órdenes tecleadas con anterioridad
/reset	Limpia la memoria de la sesión actual
/open nombre_fichero	Abre un fichero y carga sus definiciones
/save nombre_fichero	Guarda las ordenes en un fichero
/edit identificador	Abre un editor para editar el contenido de una función, un método o un interface

Santiago Higuera, 12 de marzo de 2026