1 / 15

1o DAW - Entornos de Desarrollo

UD 2. IDE Eclipse 2

Tabla de contenidos

Introducción. .................................................................................................................................................... 2

Consulta el siguiente manual para intentar aclarar las siguientes actividades...................................................... 2

Workbench en Eclipse..................................................................................................................................... 2

Documentación oficial de Eclipse ................................................................................................................... 2

Indentación y resaltado. .................................................................................................................................. 3

Preferencias de usuario .................................................................................................................................. 3

Errores y avisos............................................................................................................................................... 7

Corrección de errores...................................................................................................................................... 9

Ejecutar el programa..................................................................................................................................... 11

AYUDA .......................................................................................................................................................... 12

Preguntar por Workspace al arrancar ........................................................................................................... 15

2 / 15

Introducción.

Recordar cómo crear un proyecto y una clase según UD 2. IDE Eclipse 2. Recuerda cómo editar y

cómo ejecutar un código.

http://www.javaya.com.ar/detalleconcepto.php?codigo=76&inicio=

Actividad 1. Crea el siguiente programa. Dentro del mismo proyecto y con el mismo paquete. El

nombre será “ejemploPara”. Una vez que lo hayas creado captura una imagen y guárdala en este

archivo.

Anota un posible enunciado para este código.

Consulta el siguiente manual para intentar aclarar las siguientes actividades.

http://www.comscigate.com/cs/valle/in1.htm

Workbench en Eclipse http://es.wikipedia.org/wiki/Eclipse_%28software%29

Actividad 2 . Define Workbench.

Actividad 3 . Identifica y representa las partes del entorno de trabajo de eclipse.

Actividad 4 . Disponemos de varias perspectivas para poder trabajar de una forma más

adecuada. Determina cuál es la que tenemos por defecto y cuál es la que vamos a utilizar para

editar los programas de Java. Busca cuál es el icono para pasar a la vista de depuración

(debug) y cómo volveremos a la vista de desarrollo de java. ¿Qué icono te muestra todas las

perspectivas disponibles?

Documentación oficial de Eclipse

3 / 15

http://www.eclipse.org/documentation/

http://help.eclipse.org/juno/index.jsp

http://eclipsetutorial.sourceforge.net/workbenchlessons.html

Indentación y resaltado.

Indentación.

Como ya sabrás la indentación es la tabulación que se deja en cada línea de código para

favorecer la legibilidad del código.

for(int i=1 ; i<10; i++){ System.out.println("Numero: " + i); }

Indentar automáticamente el código de la clase “sin indentar”. También se puede probar a indentar

partes de código (no necesariamente toda una clase), para ello solo hay que seleccionar la parte a

indentar.

Averigua para qué sirve Shift+Control+F

Resaltado de código.

Eclipse automáticamente resalta el código, esto quiere decir que asigna colores a las palabras

(tokens) en función de qué función desempeñan en el código. Sin duda alguna este resaltado

facilita enormemente la legibilidad del código.

}

En el ejemplo usa

• Morado para palabras del lenguaje (palabras reservadas): for, if, else, function, class

• Azul para constantes de texto

• Verde para comentarios

Estos colores dependen del IDE que se esté utilizando, pero también se pueden personalizar, tal

como veremos en el siguiente apertado.

Preferencias de usuario En el apartado anterior ya se han descrito dos utilidades para que el código fuente sea más legible.

Más aun, en los IDEs actuales se pueden configurar muchos más parámetros. A continuación

describimos la forma de cambiar algunos de ellos.

Formato de texto

Es posible configurar el formato de cada texto independientemente. Es decir que podemos

seleccionar que fuente, tamaño, color... utilizar para cada texto del IDE (código, aviso, error,

4 / 15

documentación...) y además para cada lenguaje de programación soportado por el entorno.

Por ejemplo a continuación se muestran varias capturas de como cambiar los estilos de fuente

del entorno.

Podemos cambiar el formato del código fuente desde la opción Preferencias del menú Ventana

Eclipse

• General > Apariencia > Colores y Fuentes: Dentro de esta opción están los colores de

distintas fuentes. Por ejemplo Fuente de Texto es el formato por defecto para el para el código.

• General > Editores > Editores de Texto: En el cuado de Apariencia y opciones de color

podemos cambiar, entre otras cosas, el color de fondo del texto, colore de selección..

• Java > Editor > Coloreado de sintaxis: En esta entrada se puede definir un color concreto para el

lenguaje java y cada uno de sus tokens ( palabras reservadas, nombre de clase, números,

constantes, propiedades...) Es decir podemos configurar si queremos que las palabras reservadas se

muestren como public o como public .

Por ejemplo podemos poner el fondo azul :

Windows+Preferences+Text Editors+Backgronwd Color

Y las clases en amarillo:

Windows+Preferences+Java+Syntax Coloring+Java+Classes+Enable+color Amarillo

5 / 15

Una vez activadas se quedan activas hasta que se desactiven. Podemos guardar la

configuración deseada. Observa que la extensión asociada es .epf

(http://en.wikipedia.org/wiki/Eclipse_Process_Framework)

File+Export+General+Preferences+nombre y ubicación (amarillosobreazul.epf)

También podemos importar epf existentes:

File+Import+General+Preferences+nombre y ubicación

Actividad 5 : Cambia el formato por defecto del código de forma, modifica la fuente (arial, verdana,

script...), amplia el tamaño y ponla en negrita.

Prueba a modificar los colores por ejemplo de selecciones, texto buscado...

Formatos claros y formatos oscuros

En la siguiente imagen tienes un ejemplo de formato claro y otro oscuro (alto contraste)

respectivamente.

En principio no hay uno mejor que otro, sino más bien tienen que estar adaptados al entorno de

trabajo. Por ejemplo: en un entorno luminoso (como debería ser el de una oficina) o cuando

estamos leyendo documentación en papel blanco, es más recomendable utilizar formatos claros.

6 / 15

Realmente el formato oscuro cansa menos a la vista, ya que emite menos luminosidad. Pero

también necesita que el entorno sea más oscuro o que únicamente centremos la vista en la

pantalla. De lo contrario nuestro ojo tendría que estar adaptándose continuamente entre

oscuridad/claridad.

En ambos tipos de formato es importante que haya contraste entre el color de fondo utilizado y el

color de las fuentes.

Actividad 6 .Crea un estilo propio con tu nombre e intenta conseguir un formato oscuro similar

al de la imagen anterior

Si el código sale negro (confunde con el fondo) y no cambia el color. Intenta cambiarlo en las

opciones de Java, modificando Otros

Estilo de código Se suele llamar “estilo de código” a los espacios que dejamos a la hora de abrir

y cerrar las llaves {} en el código. El estilo clásico se denomina K&R (Kernighan and Ritchie's book) y es

al que seguramente estarás acostumbrado (o deberás acostumbrarte):

public class Ejemplo {

public static void main(String[] args) {

for (int i = 0; i<10; i++){

system.out.println (“Hola Mundo”);

}

}

}

En este estilo se abren las llaves en la propia línea de la declaración. Pero también se utilizan

otros formatos para lo cual es muy interesante que el IDE se pueda configurar para aquel que

usemos. A continuación se muestran como configurar el entorno para el estilo mostrado a la

derecha.

Para llegar a estas pantallas:

Windows+Preferences+Java+Code Style+Formatter+Editamos el perfil (profile) activo.

7 / 15

¿Qué estilo es mejor? Es una discusión bastante controvertida, cada estilo tienen sus pros y sus

contras. Lo que nos interesa en este momento es saber que, sea cual sea el estilo que escojamos el

IDE se adaptará a él.

Errores y avisos

Errores de código

Son errores que detecta el compilar como fallos en la codificación: uso de variables no definidas,

paréntesis o llaves sin cerrar, asignar un texto a una variable numérica...

Avisos de código.

Una aviso es una especie de aviso que nos da el compilador, no es un error propiamente pero se

detecta “algo raro”. Por ejemplo, tener declarada una variable que no se usa. No causa ningún

error pero tampoco sirve para nada. Es muy recomendable comprobar las avisos que se nos

muestran, ya que pueden estar enmascarando errores reales.

Errores NO detectados

Los errores que detecta un compilador son relativamente sencillos y suelen referirse a aspectos

sintácticos o de tipos del lenguaje de programación. Sin embargo en la mayoría de casos, los

errores de “significado” no pueden ser detectados por el compilador. Por ejemplo, ¿Cuál es el

error que hay en el siguiente código? ¿Crees que Eclipse lo puede detectar?

public int suma(int a, int b){

return a-b; }

Podemos clasificar los errores en dos tipos:

• Errores en fase de compilación: son los detectados por el entorno de desarrollo. Cuando se

8 / 15

detectan el compilador no llega a generar el ejecutable.

• Errores en fase de ejecución: son los que se producen cuando el programa está en

funcionamiento. Solo pueden ser observados cuando se prueba y usa el programa.

Evidentemente estos son más difíciles de detectar.

Números de línea

Muchos mensajes que nos muestran los IDE's o incluso el programa en ejecución llevan

incluido un número de línea del código fuente. Esto es una referencia que puede utilizar el

programador a la hora de buscar dónde está el problema y por tanto la solución.

A la izquierda del número de línea pueden aparecer unos iconos que describen cosas

relacionadas con la línea de código. A continuación se muestra la leyenda de las posibles:

Por tanto se suele mostrar el

número de línea en el código fuente

para evitar que el programador

tenga que estar contando las líneas.

En Eclipse se puede activar esta

funcionalidad Pulsando botón

derecho sobre el margen de la

línea (menú de contexto) y

activando Mostrar números de

línea.

9 / 15

Pantalla de errores de compilación

Actividad 7 . Compila (Ejecuta) la clase Errores y comprueba que el IDE te informa de varios

errores.

Activa la visualización del número de línea y comprueba que coinciden el número de línea de los

errores de compilación con la línea de código.

Corrección de errores Al proceso de corregir los errores de un programa se denomina depuración . Más adelante

veremos las utilidades para depurar de que dispone Eclipse, sin embargo ya podemos utilizar parte

de la información que nos está mostrando.

Eclipse marca automáticamente las líneas donde se ha detectado un error, y marca las clases y

métodos donde se han producido (En el panel de Explorador de paquetes).

Es importante tener en cuenta que en Eclipse los errores de compilación se muestran en tiempo real

subrayando el fragmento de código adecuado con una línea roja. Y además el entorno

automáticamente compila los archivos salvados. Así pues, no será necesario pasar por el tedioso y

lento proceso de compilar - observar los errores - corregir los errores.

Los errores pueden encontrarse fácilmente porque se muestran además como marcas rojas en el

10 / 15

margen derecho del editor de código Java. También los errores y advertencias presentes en

archivos ya guardados se muestran dentro de la vista de tareas (Tasks View), como se detallará

posteriormente. Haciendo click en cualquiera de los dos tipos de marcadores de error llevará

automáticamente hasta la línea en que el error está presente. Las advertencias (warnings) se

muestran de la misma manera, pero con marcas amarillas.

En cada línea marcada con error, al dejar el puntero del ratón encima del error nos muestra una

descripción:

Es fácil que al compilar por primera vez una nueva clase, el compilador nos informe de multitud

de errores (10, 50...). Pero en la mayoría de ocasiones muchos de ellos se han detectado varias

veces. Por ejemplo si se te olvida declarar una variable pero la usas 20 veces, aparecerán 20

errores, cuando en realidad se trata del mismo.

A la hora de corregirlo suele ser recomendable seguir el siguiente orden: empezar por el inicio del

código e ir hacia abajo. Algunos errores pueden hacer que el compilador “no entienda” nada del

programa y marque muchos errores. Por ejemplo:

En el código anterior, no se ha cerrado el paréntesis del if, cuando el compilador llegue al for no

entiende por qué hay uno, si todavía no se ha acabado la condición del if. Esto puede causar

También genera una tabla resumen con los errores que se han producido al compilar el proyecto.

11 / 15

que aparezcan multitud de errores en vez de uno solo. Los siguientes se producen en cascada

ya que el compilador parte de una situación errónea y no comprende las instrucciones a partir de un

punto.

Excepciones

Las excepciones son un mecanismo de los lenguajes de programación modernos, que permite

los programas manejar hechos inesperados o errores que se producen durante la ejecución de un

programa.

No se trata de errores de programación. Por ejemplo una excepción puede indicar que la conexión de

red no funciona, pero no es culpa del programa. Por contra el mecanismo de las excepciones si

puede servir para proteger a los programas frente a errores (de código o no) que surgen

inesperadamente durante el uso del programa.

Veremos las excepciones en más profundidad más adelante.

Actividad 8 . Corrige los errores de la clase “Errores”, guíate por la descripción del error y

siguiendo el orden de aparición.

Ejecutar el programa Desde Eclipse se puede probar el programa que estamos desarrollando y se muestra el resultado

en la pestaña de consola. Evidentemente cuando el programa esté acabado y entre en

funcionamiento podremos ejecutarlo en una máquina sin el IDE (pero si el programa es java, la

máquina si tendrá que tener instalada la máquina virtual java, que es lo normal hoy en día)

Es muy importante resaltar que el mismo compilado (.class) sirve para cualquier sistema

operativo (Windows, Linux, Solaris, Mac...)

Actividad 9 . Explica porqué un mismo fichero .class sirve para cualquier sistema operativo.

Para Ejecutar nuestra aplicación Java Eclipse pulsaremos en la flecha hacia bajo que aparece en

la parte derecha del botón "Ejecutar", nos mostrará un menú emergente, seleccionaremos

"Ejecutar como" y pulsaremos en "Aplicación Java":

Nos advertirá de que los cambios no se han guardado (las clases sin guardar desde la última

compilación). Para guardar siempre antes de compilar marcaremos "Guardar siempre los recursos

antes de lanzar". Pulsaremos "Aceptar" para compilar:

12 / 15

En la parte inferior de la ventana aparecerá el resultado de la compilación de nuestra aplicación

Java con Eclipse:

El código de la aplicación Java "HolaMundo": package holaMundo; public class HolaMundo { /** * @param args */ public static void main(String[] args) { System.out.println("Hola mundo"); } }

AYUDA

CTRL + Espacio = Autocompletar

Una vez que conozca la útil función de autocompletar la usará continuamente. A través de los siguientes ejemplos prácticos aprenderá cuales son las situaciones más comunes en que esta función de ayuda a la programación resultará muy útil.

13 / 15

• Nombres de Clases

Crear referencias a otras clases dentro de la clase actual es una tarea de programación habitual. Sin embargo, algunas clases de Java tienen nombres muy largos que son difíciles de recordar. Además, es necesario añadir declaraciones de importación para poder resolver dichas referencias a clases a la hora de compilar.

Usar "CTRL + Espacio" tras escribir los primeros caracteres del nombre de una clase Java mostrará las posibles alternativas. Puede seleccionar cualquiera de ellas simplemente realizando clic izquierdo del ratón. Nótese que la sentencia de importación correspondiente se añadirá de forma automática. Las clases se marcan con una "C" verde mientras que las interfaces se marcan con una "I" morada. El paquete al que pertenece la clase se muestra también, permitiendo de este modo evitar posibles confusiones.

• Atributos y Variables Locales

Cuando se define una clase es normal dar nombres inventados a sus atributos y a las variables internas de los métodos. Pero en ocasiones resulta difícil recordar el nombre exacto. Tras escribir los primeros caracteres del atributo o de la variable local, pulsar "CTRL + Espacio" mostrará las posibles alternativas. Este proceso es muy similar al de autocompletar el nombre de las clases recientemente expuesto. Las variables locales se marcan con el icono de una "L" gris, mientras que los atributos se marcan con un icono que puede variar según la visibilidad del atributo.

• Métodos y Constructores

Una vez que se ha creado un objeto Java pueden invocarse los métodos correspondientes a su clase. Sin embargo, es bastante habitual olvidar el nombre de un método en concreto, o incluso los tipos de sus parámetros y su orden. Este problema puede solucionarse fácilmente pulsando "CTRL + Espacio" tras escribir el nombre del objeto seguido de un punto, lo cual mostrará una ventana con las posibles alternativas. Pulsar sobre la alternativa escogida añadirá la signatura del método al objeto.

14 / 15

También es posible autocompletar la signatura de los constructores pulsando "CTRL + Espacio" tras escribir (o autocompletar) el nombre de la clase seguido de un signo de apertura de paréntesis, "(".

Escribir las primeras letras del modificador de un método tal como "public" o "private" y pulsar "CTRL + Espacio" le permitirá crear automáticamente una plantilla del método. Pulsar el tabulador permite saltar de un campo de la plantilla a otro, de manera que se pueda completar el tipo de retorno, el nombre del método y sus parámetros.

• Bucles

Los bucles suelen estar presentes en todos los programas. Aunque crear un nuevo bucle puede no ser una tarea muy compleja, Eclipse proporciona algunas funciones de auto completado que pueden acelerar considerablemente el proceso. Basta con escribir "do", "while" o "for" y pulsar "CTRL + Espacio" para mostrar las posibles opciones. Si el bucle ha sido creado con el propósito de iterar sobre un array de elementos, seleccionar esta opción intentará autocompletar incluso el nombre del array.

• Etiquetas de Javadoc

Mientras que los comentarios internos del programador se indican con una "//", los comentarios de Javadoc se inician con un "/**". Tras crear un método, añadir "/** + ENTER" sobre la signatura del método autocompletará información de Javadoc tal como "@param [nombreParámetro] [comentario]", "@return [descripciónDatosDevueltos]" y "@throws [tipoExcepción] [comentario]". Pulsar "CTRL + Espacio" dentro de un bloque "/** ... */" mostrará toda la lista de etiquetas Javadoc posibles.

15 / 15

Preguntar por Workspace al arrancar

Por defecto Eclipse nos pregunta, al arrancar, por la carpeta que contiene el workspace con el que vamos a trabajar.

Pero si no lo hace podemos volver a activar lo anterior:

Windows+preferences+general+startup and shutdown+workspace

Y activamos “prompt for workspace on startup”