Entendiendo y Dominando Eclipse

Introducción

Eclipse es varias cosas:

  • Un IDE: entorno integrado de desarrollo/programación
    • inicialmente para aplicaciones Java, pero...
    • con soporte para varios lenguajes: C/C++, PHP, Python, etc.
  • Un proyecto opensource:
    • es decir de código abierto
  • Una fundación:
    • que agrupa varios proyectos y familia de tecnologías relacionadas con el entorno de programación.
    • más allá de que luego muchas empresas como IBM, Oracle, etc. soportan varios de sus proyectos.

Lo que vamos a ver acá es más bien eclipse como IDE.

Lo primero a notar, aunque no vamos a entrar en demasiado detalle, es que la arquitectura del eclipse es bastante especial, basada en lo que se llaman "plugins", es decir módulos, que se pueden agregar/sacar y que dependen unos de otros para ciertas funciones.

Para el que le interesa profundizar un poco más, tiramos la punta de que la tecnología de sistemas de módulos que usa es el estandar llamado OSGi.

Una cosa particular del eclipse, es que define "Puntos de extensión", de modo que nuevos plugins pueden aportar funcionalidad a, por ejemplo pantallas ya existentes.

Así, si le instalamos un plugin para versionar código con SVN, vamos a ver que al clickear botón derecho sobre un archivo tendremos un nuevo menú para realizar operaciones con el SVN.

Este es solo un ejemplo.

Ya vamos a ver cómo instalar plugins, pero primero lo primero...

Conceptos Generales del IDE

El Workbench

La ventana en sí del eclipse tiene cierta estructura estandar que se llama workbench. Éste consta de:

  • una o más perspectivas, que a su vez tienen...
  • vistas
  • una zona para el editor de código
  • barra de menu
  • barra de herramientas
  • etc.

Acá vemos unas partes remarcadas:

Perspectivas

Durante el desarrollo de software, se dan diferentes "momentos", donde en cada uno realizamos distintas actividades, o estamos enfocados en diversos aspectos. Eclipse identifica esto, y permite manejar esos momentos de forma más eficiente, mediante perspectivas.

Son, básicamente diferentes configuraciones del workbench (de la ventana), con ciertas vistas, menues, etc. específicas para una tarea.

Por ejemplo, cuando codificamos, nos es útil tener la vista de "Problems" para visualizar errores de compilación. En cambio cuando debuggeamos un programa, necesitamos poder ver los breakpoints actuales, así como también una traza de ejecución (stacktrace) y los valores de las variables, al frenar en un breakpoint.

Así es que, por ejemplo, existe la perspectiva de "Debug", que contiene todas estas vistas específicas para el momento de "debug".

            Shortcut:

CTRL + F8: Para cambiar entre perspectivas


Si se quiere abrir una perspectiva manualmente: Window->Open Perspective->Other...

Vistas

Son las diferentes sub-ventanitas, o componentes que vemos dentro de la ventana principal del IDE (workbench). Pueden mostrar cualquier tipo de información, por lo que pueden tener cualquier tipo de control. Pero generalmente los más comunes son: listas de items (como la vista "Problems"), y arbol de elementos (como la vista "Package Explorer").

Por ejemplo "Outline" es de tipo arbol:


Y "Problems" de tipo lista:


Lo interesante de las vistas y del workbench en sí (el diseño del IDE en general) es que las vistas son elementos "vivos" que, normalmente, están escuchando por eventos que sucedan dentro del workbench, por ejemplo, lo que selecciona el usuario, o en qué elemento está trabajando activamente en este momento. Así, las vistas son "listeners" (u observers) de la actividad del usuario. Y pueden, responder a estos eventos, cambiando su contenido.

Así, por ejemplo, la vista "Javadoc" muestra el javadoc de la clase seleccionada. Si abrimos una nueva clase, va a actualizarse automáticamente.

Así, todas las vistas terminan "conectadas", incluso sin conocerse diréctamente.

  Shortcut:

CTRL + F7: Para cambiar entre vistas

Para abrir manualmente una vista: Window -> Show View -> Other...


Workspaces

Vimos entonces qué era el workbench y cuales eran sus partes. Todo esto sirve para, trabajar sobre proyectos de software, son más bien las "herramientas" que provee el IDE.

Este IDE lo vamos a utilizar entonces para trabajar sobre diferentes proyectos. A este entorno sobre el cual trabajamos se le denomina "workspace". Y tiene la raíz en un directorio del filesystem.

El eclipse entonces se puede abrir en diferentes momentos para trabajar sobre diferentes workspaces. Por ejemplo, podrían tener un workspace para cada materia, y sin embargo utilizar el mismo eclipse.

Y hasta pueden ejecutar el mismo eclipse simultáneamente sobre distintos workspaces.

El workspace entonces contiene proyectos. Que pueden ser proyectos java, o de cualquier tipo que esté soportado por su eclipse (recordar que decíamos que el eclipse se puede extender para soportar otros lenguajes)

Trabajando con código java

Hay muchísimos shortcuts que servirán para poder trabajar con proyectos Java de forma más "eficiente". Ya sea escribiendo menos código, o bien ayudando a detectar problemas o encontrar cosas más fácil y rápidamente.

Navegando

Buscar tipo (clase/interface/annotation/enum): CTRL+SHIFT+T

"T" de tipo.

Sirve para abrir la declaración de una clase sin necesidad de browsear manualmente por carpetas o jars. Es uno de los shortcuts más usados.


Este diálogo permite buscar por el nombre completo (incluido package), o bien por expresiones regulares como "*Controller" presentaría todas las clases con sufijo "Controller". O también permite agilizar la búsqueda de un nombre largo, al ingresar solo las mayúsculas, ej: queremos buscar la clase "EstrategiaPagoDiferidoConDescuento", podemos escribir sólamente "EPDCD"

Buscar Recurso (cualquier tipo de archivo): CTRL+SHIFT+R

"R" de "recurso"

Es similar al CTRL+SHIFT+T pero permite buscar cualquier archivo.

Abrir declaración de Tipo (F3)

Desde una porción de código podemos abrir la declaración de otro tipo, ubicando el cursor en el nombre del tipo (por ejemplo, en un parámetro de un método, o en un extends, declaración de variable, etc) y apretando F3.

Esa forma no requiere del mouse. La otra opción es pasar por arriba con el cursor del mouse y teniendo apretada la tecla CTRL aparecerá el nombre como un hyperlink y podrán ir a la declaración con un click del mouse.

Obviamente el F3 es mucho más agil.

Ver Jerarquía para el tipo actual (F4)

Si queremos ver la jerarquía de clases/interfaces para una clase/interface, debemos abrirla en el editor y símplemente apretar F4.

Buscar Referencias (CTRL+SHIFT+G)

Podemos ver desde qué puntos de código se está referenciando ya sea una clase/interface, o bien un método o field con CTRL+SHIFT+G parados sobre él.

Ver Sobre-escrituras de métodos (CTRL+T)

Dado un método, podemos ver qué clases lo sobrescriben, parándonos en su declaración y apretando: CTRL+T

Por ejemplo en esta imagen estamos viendo quienes implementan el método "isEmpty" de collection. Las clases con ícono blanco significan que no lo están sobrescribiendo pero estan en el camino de la jerarquía.



Editando Código

Veamos algunos shortcuts útiles en la edición de código:

Autocomplete

El autocomplete es quizás el feature más importante para escribir la menor cantidad de código y así hacerlo más rápidamente. En cualquier parte del código, mientras tipeamos podemos apretar CTRL+BARRA para que eclipse nos sugiera una lista de tipos (clases, interfaces, etc) o bien modificadores (public, private, etc), según lo que estábamos escribiendo.

Como dice en el pie del menú, si siguen apretando CTRL+BARRA ira rotando entre las diferentes "categorías" de sugerencias (proposals). Esto es porque el autocomplete es una parte extensible de eclipse. Diferentes plugins pueden agregar diferentes tipos o categorías de propuestas, y dentro de éstas, agregar propuestas específicas. Por ejemplo, podemos tener una lista de sugerencias para código scala.

El autocomplete se configura desde "Windows->Preferences", "Java->Editor->Content Assist->Advanced". Ahí verán las categorías y el orden en el que aparecen en la rotación.

En particular, algo interesante son los Template Proposals. Son pedacitos de código (o texto para comentarios) para tareas repetitivas, como por ejemplo iterar una colección, o hacer un main, etc. Así, nos evitan escribir el código completo.

Ejemplo: en una clase (que no tenga un main), dentro del cuerpo de la clase en un lugar "vació" escriban main y hagan CTRL+BARRA

Si dan "enter" automáticamente esto va a escribir todo el código de la firma del método "main". Y uds solo tipearon 4 letras ! :)

De la misma forma hay templates para:

  • try: escribir un bloque try-catch
  • for: iterar un array o colección
  • etc

Además, ustedes pueden hacer sus propios templates yendo a "Windows->Preferences", "Java->Editor->Templates"

Sus templates pueden tener variables que serán las partes que luego el usuario podrá editar del template. Por ejemplo la variable para iterar en un for. Aparecen encuadradas y uno puede pasar de una a otra con la tecla TAB.

Algunos templates útiles:

  • sysout: genera una linea "System.out.println("");"
  • syserr: idem para error
  • main: como vimos antes
  • etc.

Quick Fix

Ante un error de compilación aparecerá subrayada en rojo la porción de código que tiene el problema. Podemos pararnos encima con el mouse para ver qué sucede, pero más fácil es usar el shortcut CTRL+1 que desplegará un menú con opciones para solucionar el problema.

A esto se lo llama Quick Fix. Y dependiendo del problema aparecerán diversas opciones. Veamos algunos ejemplos

El tipo de la variable no existe, entonces, queremos crear una clase/interface.

Crear método si no existe:


Ejecutando

Acá vamos a ver algunos shortcuts para poder ejecutar programas/tests, etc, sin necesidad de usar el mouse.

Re-lanzar el programa que se ejecutó por última vez en modo "debug": CTRL+F11 (solo F11 para hacerlo en modo "run" y no "debug")

Por ejemplo, tenemos un main que ejecutamos por primera vez yendo al menú "Run->Run". Si queremos ejecutarlo nuevamente, símplemente apretamos "F11". O si queremos ejecutarlo en modo debug, CTRL+F11.

Menú de Shortcuts "Run"

Parados sobre una clase que quieran ejecutar pueden presionar: ALT+SHIFT+X

Luego de un segundo aparecerá un menú abajo a la derecha con las múltiples opciones de ejecución y el shortcut completo.

En general las más usadas son:
  • ALT+SHIFT+X, J: que se lee como "apretar ALT SHIFT X todo junto, luego soltar, y apretar la J". Sirve para ejectuar la clase actual como un main java. Se pueden acordar por la "J" de "Java".
  • ALT+SHIFT+X , T: para ejecutarla como un test case.

Refactorizando

//TODO

Debuggeando

//TODO: inspect, variables, watch, stack.

CTRL+SHIFT+B para poner un breakpoint en una linea.

Una vez que se frenó la ejecución en una linea:

  • F5: Step-in, ingresa a la método que ejecuta la línea. Por ejemplo si nuestra línea es System.out.println(persona.getNombre()), entraría al getNombre(). Al salir del getter, vuelve a la misma linea. Si volvemos a hacer F5, entraría al println(). En general lo usamos para "entrar" hasta cierto nivel.
  • F6: Se utilizar para pasar a la siguiente linea, sin inmiscuirse en los detalles como sería con F5.
  • F7: sale el método actual (obviamente habiéndo ejecutado lo que faltaba del código). En general se usa cuando, por ejemplo entramos demasiado con F5, y luego nos dimos cuenta, entonces "salimos" con F7.
  • F8: Cuando queremos dejar de debuggear esta ejecución. Es un "seguí nomás!". La ejecución va a continuar, hasta que frene nuevamente en un breakpoint, que podría ser el mismo u otro.

Extendiendo eclipse

instalando plugins, p2, update-sites


Links

Acá va una lista de enlaces a tutoriales más completos relacionados con shortcuts de eclipse y otras yerbas:



Comments