Este documento presenta tres entornos de desarrollo para Java: BlueJ, Eclipse y NetBeans. Explica cómo instalar y usar BlueJ, resaltando su simplicidad y facilidad de uso pero también sus limitaciones como la falta de información en los diagramas de clases. También describe la instalación y creación de proyectos en Eclipse, así como la instalación básica de NetBeans y sus ventajas para el desarrollo de aplicaciones Java.

2. 2
Dirección General de Educación Superior Tecnológica
INSTITUTO TECNOLÓGICO DE SALINA CRUZ
MATERIA:
PROGRAMACIÓN ORIENTADA A OBJETOS
FACILITADOR:
SUSANA MONICA ROMAN NAJERA
UNIDAD 1:
FUNDAMENTOS DEL LENGUAJE
ACTIVIDAD:
ENTORNO DE DESARROLLO DE JAVA
GUIA
NOMBRE DE LA ALUMNA:
CRUZ ELENA ALQUISIREZ PÈREZ
SEMESTRE: 2º GRUPO: E2
CARRERA:
ING. EN TIC´S
SALINA CRUZ, OAXACA A 10/02/2014

3. 3
Contenido
INTRODUCCIÓN.............................................................................................................................. 4
ENTORNO DE DESARROLLO BLUEJ ........................................................................................ 5
PUESTA A PUNTO.......................................................................................................................... 5
PRERREQUISITOS................................................................................................................................. 7
DESCARGA .................................................................................................................................... 8
EJECUCIÓN DE ARCHIVO............................................................................................................ 9
INSTALACIÓN................................................................................................................................ 11
SACÁNDOLE PARTIDO .......................................................................................................... 15
VALORACIÓN............................................................................................................................ 23
PUNTOS DÉBILES DE BLUEJ........................................................................................... 24
INSTALACIÓN DE ECLIPSE: ...................................................................................................... 25
PROYECTO ECLIPSE: ................................................................................................................. 28
PASOS PARA PROGRAMAR EN ECLIPSE ........................................................................................... 28
INSTALACION DE NETBEATS .................................................................................................. 34
¿QUÉ ES NETBEANS? ................................................................................................................ 39
¿POR QUÉ USARLO? .................................................................................................................. 39
CREACIÓN DE UN NUEVO PROYECTO ................................................................................. 39
CONCLUSIÓN:............................................................................................................................... 49
OTRAS FUENTES CONSULTADAS: ......................................................................................... 50

4. 4
INTRODUCCIÓN
Este tutorial es una introducción al uso del entorno de programación BlueJ. BlueJ
es un entorno de desarrollo para Java™ diseñado específicamente para la
enseñanza en un curso introductorio. Fue diseñado e implementado por el equipo
de BlueJ en la Universidad de Monash, Melbourne, Australia, y la Universidad de
Southern Denmark, Odense. Este tutorial está hecho para las personas que
desean familiarizarse con las capacidades de este entorno de programación. Aquí
no se explican las decisiones de diseño que subyacen en la construcción del
entorno o la investigación en la cual se basa.
Este tutorial no tiene la intención de enseñar Java. A los principiantes en la
programación en Java se les aconseja estudiar también con un texto introductorio
o tomar un curso de Java.
También se dará a conocer otros entornos de java como es el programa eclipse y
netbeats

5. 5
ENTORNO DE DESARROLLO BLUEJ
BlueJ es un sencillo entorno de programación exclusivamente diseñado para la
enseñanza y el aprendizaje de Java. Se trata de un proyecto nacido en el seno de
un grupo de investigación universitario integrado por miembros británicos y
australianos. Por sus novedosas características, en poco tiempo BlueJ alcanzó
una gran popularidad en entornos docentes.
PUESTA A PUNTO
Lo primero que haremos será descargar el programa de su página web.

6. 6
Como primer resultado tenemos la pagina de descarga

7. 7
BlueJ es distribuido en tres formatos diferentes: uno para sistemas Windows, uno
para
MacOS, y uno para los otros sistemas. La instalación es fácil y rápida.
PRERREQUISITOS
Usted debe tener J2SE v1.3 (o. JDK 1.3) o posterior instalado en sus sistema para
utilizar BlueJ. Si usted no tiene instalado el JDK usted puede descargarlo del sitio
web de Sun en http://java.sun.com/j2se/. En MacOS X, una versión reciente del
JDK está preinstalada – usted no necesita instalarla. Si usted encuentra una
página de descargas que ofrece el “JRE”( Java Runtime Environment ) y el “SDK”
( Software Development Kit ), usted debe descargar el “SDK” – el JRE no es
suficiente.
Dependiendo de los sistemas con el que trabajes será el que descargues,

8. 8
En este caso procederemos la DESCARGA con el de Windows

9. 9
Una vez descargada la versión de Windows procederemos a abrir el archivo,
aparece la siguiente ventada de EJECUCIÓN DE ARCHIVO

10. 10

11. 11
INSTALACIÓN
Luego proceder a instalarlo.

12. 12
La pantalla principal aparecerá en gris hasta que creemos un proyecto. En BlueJ
existe una desafortunada confusión entre el término proyecto, tal y como suele
entenderse en los IDEs, y el concepto de paquete, antes explicado. Así, un
proyecto BlueJ es igual que un paquete, pero en aras de simplificar se eliminan las
líneas de código package, obligatorias según la norma de Java. Si trabajar con
paquetes es prioritario para ti, BlueJ no es definitivamente la mejor opción.
¿Significa esto que no podemos utilizar en BlueJ paquetes de clases programados
en otros entornos? Existe una forma de incluirlos en nuestro proyecto, Project >
Open non BlueJ, pero sin duda no resulta nada intuitivo.
No nos quedemos con este defecto, sin duda uno de los pocos que presenta el
entorno: creemos un nuevo proyecto conProject> New Project y ya podremos
empezar a trabajar.

13. 13
La pantalla se mostrará así:
Como ves, la pantalla principal es tremendamente sencilla. A la izquierda tenemos
los botones de nueva clase y compilar; a la derecha la ventana principal, en la que
veremos el esquema de clases. Abajo está el banco de objetos, similar al de

14. 14
jGrasp, que se estudiará más adelante. Por último, una barra gris cambiará de
color y se pondrá en movimiento cuando haya un programa en ejecución.
Existen dos formas de añadir una clase al proyecto: la primera es crearla nosotros
mismos, mediante el botón New Class.
La segunda es añadir una clase existente, mediante el menú Edit>Addclassfrom
file. Ten en cuenta que esta clase se copiará al directorio del proyecto actual,
mientras que en jGrasp esto no ocurría: simplemente se utilizaba la clase desde
su ubicación original. Por otra parte no hace falta que te preocupes de guardar las
clases, ya que BlueJ lo hará por ti cada vez que compiles o cuando cierres el
programa.
El entorno incluye un sencillo asistente para crear clases, cuya misión es
proporcionarte un modelo o esqueleto de código sobre el que trabajar. Este
borrador será distinto si queremos hacer una clase estándar o, por ejemplo, un
applet (aplicación gráfica de ventana). Sin embargo, y ya que la misión es
aprender, quizá sea mejor borrar la propuesta y comenzar a trabajar con el editor
en blanco.
Las clases que añadimos al proyecto se representan mediante un rectángulo
marrón: en la imagen anterior aparece rayado porque aún no lo hemos compilado.
Para editar el programa debes hacer doble click con el ratón sobre el rectángulo,
apareciendo una nueva ventana de edición.
En BlueJ, cada clase se edita en una ventana independiente, lo que puede ser
realmente engorroso en programas complejos.
Para compilar nuestras clases tenemos dos opciones: el botón de la izquierda
compilará todas las clases del proyecto, mientras que si pulsamos sobre el
rectángulo de una clase con el botón derecho del ratón, podremos compilar por

15. 15
separado dicha clase. Este mismo menú nos permitiría también eliminar la clase
del proyecto.
¿Y la ejecución? Localiza la clase en la que esté el método principal, pulsa sobre
su rectángulo con el botón derecho, y selecciona el método main: verás que la
ejecución provoca la aparición de una ventana independiente (sí, otra más), en la
que aparecerá el resultado de ejecutar tu programa.
Sencillo, ¿verdad? Veamos a continuación opciones algo más avanzadas.
SACÁNDOLE PARTIDO
Retomemos un proyecto completo, que involucre distintas clases:
Observa que los diagramas que ofrece BlueJ no son completos (no muestran los
métodos ni los atributos de cada clase): únicamente se contemplan dos tipos de
flechas para representar las relaciones entre clase, que caen fuera del alcance de
este artículo. Podemos reorganizar los rectángulos en la ventana para que las
flechas se vean con claridad. Observa también esa hoja de papel que aparece en
la esquina superior izquierda: se trata de un archivo Readme.txt que se incluye por
defecto en todos los proyectos. Su misión es únicamente permitir al autor del
programa escribir notas sobre el mismo.

16. 16
Volvamos al proceso de compilación. Cuando sucede un error, BlueJ resaltará la
línea errónea y mostrará un mensaje. En ocasiones, un símbolo de interrogación
nos permitirá obtener una explicación más detallada del problema (en inglés, eso
sí).
Al igual que jGrasp, BlueJ no muestra por defecto los números de línea al editar
un archivo. Si deseas que aparezcan, accede al menú Tools >Preferences y
marca la opción Display line numbers.
A estas alturas ya te habrás dado cuenta de que la sencillez ha guiado el diseño
de este entorno: ahora comprobarás lo intuitivo y fácil que resulta interactuar con
los objetos sin necesidad de un método principal. Haz click con el botón derecho
sobre una clase y tendrás acceso al método constructor (new...). Además del
nombre del objeto, es probable que tengas que introducir algunos valores iniciales:

17. 17
A continuación puedes ver el aspecto del banco de trabajo en la parte inferior de la
pantalla, después de crear algunos objetos:

18. 18
Sin necesidad de escribir un programa principal, puedes interactuar con estos
objetos pulsando sobre ellos con el botón derecho y ejecutando cualquiera de sus
métodos:

19. 19
También puedes examinar sus atributos mediante la opción Inspect:
A través del menú View > Show CodePad accederás a una nueva ventana en la
que puedes ejecutar expresiones sencillas y también referenciar a los objetos
creados en el banco. Recuerda que esta funcionalidad también la ha incorporado
jGrasp, como se vio anteriormente.

20. 20
El banco de objetos es una herramienta muy poderosa y cómoda para probar
clases, pero no está pensada para desarrollar complejas ejecuciones. Imagina que
tu problema requiere crear 10 objetos distintos, dar valores a sus atributos, y luego
interactuar entre ellos: cada vez que detectes un fallo y recompiles, los objetos
desaparecerán y tendrás que crearlos de nuevo. Por tanto, el banco de objetos en
ningún caso sustituye la necesidad de escribir un método principal que guíe la
ejecución del programa.
Una puntualización sobre este método principal: el lenguaje pide que main reciba
un conjunto de cadenas de texto como parámetros, para permitir la recepción de
datos externos al ejecutar el programa. Además, main debe declararse como
método estático (enseguida aclararemos qué es eso). La cabecera del método
main debería ser siempre, por tanto, publicstaticvoidmain(String[] args). Sin
embargo, para aislar al estudiante de ciertas complejidades, BlueJ admite la
siguiente cabecera: publicvoidmain(). Ten muy presente que un código como este
no compilará en otros entornos de programación, por tanto se recomienda
respetar la sintaxis original de Java.
Por ser un método estático, para ejecutar el método main basta (como dijimos
anteriormente) con pulsar con el botón derecho sobre la clase principal y escoger
el método main:

21. 21
Si main fuese un método convencional, tendríamos que crear primero un
objeto miTest de la clase Test, para a continuación invocar el método. Ahí está el
problema: en programación orientada a objetos tiene sentido crear objetos que
representen cuadrados o personas, pero ¿qué representaría un objeto test, o un
objeto matemáticas? ¿Puede haber varias matemáticas? Esta es la razón de ser
de métodos estáticos como el main de Test, o las funciones matemáticas de la
clase Math.
Sólo nos queda repasar las funciones de depuración, que son muy parecidas a las
que ofrece jGrasp. Pulsando en la columna izquierda del editor de una clase,
marcamos uno o varios puntos de ruptura:

22. 22
A continuación ejecutamos el programa y, automáticamente, la ejecución se
detendrá al llegar al primer punto de ruptura. En ese momento aparecerá la
ventana de depuración y podremos inspeccionar el estado de nuestros objetos:

23. 23
Observa que los botones de control de ejecución se han reducido al mínimo:
avanzar una instrucción (step), ejecutar una llamada a un método paso a paso
(stepinto), continuar hasta el siguiente punto de ruptura, y abortar la ejecución.
Ha quedado clara la obsesión de los creadores de BlueJ por simplificar, y en el
caso de la depuración no podemos criticar su elección: están las opciones justas,
y resultan muy intuitivas para el usuario.
Hay una última ventaja de este entorno que aún no hemos comentado: y es que si
bien el manual de referencia está en inglés, el tutorial oficial está traducido al
castellano y es accesible desde la página web del programa. Además, y también
en castellano, existe utilizando precisamente este entorno, lo que puede sin duda
facilitar la tarea al profesor.
VALORACIÓN
Destaquemos para terminar los puntos fuertes y débiles de este entorno:

24. 24
PUNTOS FUERTES DE BLUEJ
Su sencillez y facilidad de manejo resultan simplemente inigualables
 Sus funciones de creación visual de objetos están integradas de forma fácil
e intuitiva para el usuario
 Existe documentación oficial en castellano
PUNTOS DÉBILES DE BLUEJ
 Se oculta al alumno la gestión de paquetes
 Las ventanas independientes resultan algo caóticas cuando se manejan
muchos archivos a la vez
 Los diagramas de clases no aportan ninguna información sobre las mismas,
resultando de escasa utilidad

25. 25
INSTALACIÓN DE ECLIPSE:
Lo primero que tenemos que hacer es descargar el programa eclipse de 32 o 64
bits, lo pueden descargar de este link: http://www.eclipse.org/downloads/ o pueden
descargarlo de otra página que más les gusta.
Descomprimen la carpeta eclipse ya que adentro nos viene el software de dicho
programa.
Una vez extraído entramos a la carpeta e instalamos eclipse.exe
Creamos una carpeta en la unidad (c) del disco dura para guardar los trabajos que
realizaremos con eclipse.

26. 26
Y seguimos las instrucciones que nos aparezcan en la pantalla. Antes de dar click
en ok buscamos la carpeta creada especialmente para los trabajos de eclipse la
seleccionamos y ahora si le damos ok.
Automáticamente se nos abrirá una ventana dándonos la bienvenida a eclipse,
nos aparecerá un logo de eclipse y arriba del logo nos dice welcome y la cerramos
la ventanita de welcome.

27. 27
Y ya está instalado nuestro programa y listo para usarse

28. 28
PROYECTO ECLIPSE:
En el entorno de desarrollo Eclipse todo archivo se almacena dentro de un
proyecto. Esto quiere decir que todo documento, carpeta, archivo de código fuente
(.java) y código compilado (.class) tiene que estar contenido dentro de un
proyecto. Así pues, el primer paso antes de usar Eclipse para programar en Java
es comprender la estructura de proyectos de Eclipse.
PASOS PARA PROGRAMAR EN ECLIPSE
El eclipse es un entorno de trabajo profesional, por lo que en un principio puede
parecer complejo el desarrollo de nuestros primeros programas. Todo programa
en eclipse requiere la creación de un “Proyecto”, para esto debemos seleccionar
desde menú de opciones:
Ahora aparece el dialogo donde debemos definir el nombre de nuestro proyecto
En el campo de texto “Project name” ingresamos como nombre: proyecto x y

29. 29
dejamos todas las otras opciones del dialogo con los valores por defecto.
Presionamos el botón “finish”. Ahora en la ventana de package” aparece el
proyecto de acabamos de crear.
Como segundo paso veremos que todo programa en java requiere como mínimo
una clase. Para crear una clase debemos seleccionar desde menú de opciones.

30. 30
En el dialogo que aparece debemos definir el nombre de la clase (lo llamaremos
clase 1) los otros datos del dialogo lo dejamos con los valores por defecto.
Luego de dar click en finish tenemos el archivo donde podemos codificar nuestro
primer programa.

31. 31
Más adelante veremos los archivos que se crean en un proyecto, ahora nos
dedicaremos a codificar nuestro programa. En la ventana de edición ya tenemos el
esqueleto de una clase de java que el entorno eclipse nos creó automáticamente.
Todo programa en Java debe definir la función main. Esta función la debemos
codificar dentro de la clase: "Clase1".
Procedemos a tipear lo siguiente:

32. 32
Como último paso debemos compilar y ejecutar el programa, esto lo podemos
hacer desde menú de opciones o presionando la tecla F11
Si no hay errores en la codificación debemos ver el resultado de la ejecución en
una ventana del eclipse llamada “console” que aparece en la parte inferior.

33. 33
Lo más importante es que queden claro los pasos que debemos dar para crear un
proyecto java. Como vimos en este pequeño ejemplo más adelante
programaremos un programa con más dificultad.

34. 34
INSTALACION DE NETBEATS

35. 35

36. 36

37. 37

38. 38

39. 39
¿QUÉ ES NETBEANS?
• NB es un entorno integrado de desarrollo o
IDE (Integrated Development ,Environment)
• En él podemos realizar todas las tareas
Asociadas a la programación
– Editar el código
– Compilarlo
– Ejecutarlo
– Depurarlo
¿POR QUÉ USARLO?
• Simplifica alguna de las tareas que, sobretodo
En proyectos grandes, son tediosas
• Nos asiste (parcialmente) en la escritura de
código, aunque no nos libera de aprender el
lenguaje de programación
• Nos ayuda en la navegación de las clases
predefinidas en la plataforma (miles)
• Aunque puede ser costoso su aprendizaje, los
beneficios superan las dificultades
CREACIÓN DE UN NUEVO PROYECTO
Consideraciones previas
• En NB existen muchas maneras de conseguir
Lo mismo
• Lo que mostraremos es una de ellas, que he
Seleccionado por varias razones:
– Los proyectos resultantes no copian los archivos
De la biblioteca de ACM, ya que ocupan bastante
espacio
– Aprendemos funcionalidades de NB que después
Podemos usar para otros usos

40. 40
Seleccionamos Proyecto Nuevo del menú
Archivo

41. 41

42. 42

43. 43

44. 44

45. 45

46. 46

47. 47

48. 48

49. 49
CONCLUSIÓN:
A lo que llegamos durante el proceso de instalación y uso de los programas
mencionados es que son programas fáciles y sencillos de utilizar, no genera
problemas y es muy útil para la enseñanza educativa.
Cualquiera de las personas puede trabajar con estos programas son dinámicos y
divertidos.
Esta investigación fue elaborada con el apoyo de fuentes tomadas de internet.

50. 50
OTRAS FUENTES CONSULTADAS:
Entorno de bluej. (2010). Internet. En línea. Página consultada el 08/02/2014.
Disponibleen:http://www.lab.dit.upm.es/~fprg/20082009/entorno/mipc/bluej/index.ht
ml
BlueJ. (2013).Internet. En línea. Página consulta el 08/02/2014.
Disponibleen:http://recursostic.educacion.es/observatorio/web/ca/software/progra
macion/911-monografico-java?start=2
Entorno de desarrollo BlueJ. (2013). Internet. En línea. Página consultada el
09/02/2014. Disponible en:http://centrodeartigos.com/articulos-
informativos/article_69753.html
Conociendo BlueJ. (2013). Internet. En línea. Página consultada el
09/02/2014.Disponibleen:http://bluejava7if01n.blogspot.mx/2012/07/inicios-de-
bluej.html
Entorno mi pc bluej. (2013)En línea. Página consultada el 09/02/2014.Disponible
en: http://www.lab.dit.upm.es/~lprg/entorno/mipc/bluej/
http://ocw.udl.cat/enginyeria-i-arquitectura/programacio-2/continguts-1/1-
introduccioi81n-a-netbeans.pdf
http://cs.mty.itesm.mx/profesores/raul.perez/DAD/Netbeans-7.1.pdf