Download Curso de Java con Bluej. Cursosindustriales.net Página 1

Curso de Java con Bluej.
Cursosindustriales.net
Página 1
CURSO DE JAVA CON
BLUEJ.
Bienvenidos a este nuevo curso de programación en JAVA usando el entorno
de desarrollo BLUEJ.
BlueJ es un entorno de desarrollo de JAVA que está siendo mantenido por la
universidad de Kent, en Reino Unido.
El IDE, se basa en un entorno de programación orientada a objetos, por lo que
es ideal para el aprendizaje y la enseñanza.
Entre las características principales cabe destacar:




La sencillísima interfaz de usuario. La mayoría de las personas pueden
utilizar BlueJ después de una sencilla presentación.
BlueJ implementa la visualización de estructuras de clases, mediante la
cual puedes ver las clases del proyecto y sus relaciones, herramienta
que te permitirá aprender y visualizar estos conceptos en forma de
diagrama esquemático.
El entorno de BlueJ permite al usuario crear directamente objetos de las
clases y manipular sus métodos. De ésta manera se experimenta con
los objetos probando y “tocándolos” para desarrollar su aprendizaje.
Se ejecuta sobre el Java Devolopment Kit (JDK), de Oracle haciendo
uso del compilador y de su máquina virtual; esto hace que se adapte a la
especificación oficial y más actualizada de Java.
Este curso está compilado, redactado y escrito por PASCUAL GÓMEZ DEL
PINO siguiendo el curso de Introducción a la informática de primero de
ingeniería electrónica y automatismos de la UNED.
Todos los ejemplos, prácticas, comentarios y ejercicios son los realizados en
clase siguiendo el libro de la asignatura y que puedes conseguir en diferentes
medios.
Puedes enviar tus dudas o comentarios al correo:
[email protected]
Curso de Java con Bluej.
Cursosindustriales.net
Página 2
UNIDAD 1. OBJETOS Y CLASES.
Objetos y clases.
Un objeto es una unidad dentro de un programa que consta de un estado y de
un comportamiento, que a su vez constan respectivamente de datos
almacenados y de tareas realizables durante el tiempo de ejecución.
Una clase sirve para describir, de manera abstracta, todos los objetos de un
tipo concreto.
La imagen anterior nos sirve para entender éstos conceptos.
Cuando hablamos de clase, estamos haciendo referencia abstracta a un tipo de
elemento, objeto, éter, etc., etc. En nuestro ejemplo elcocherojo es un objeto
específico que como puedes ver tiene atributos como ruedas, motor, velocidad
y color; también dispone de métodos como frenar(), arrancar() o doblar().
Pero también existen otros objeto que sea elcocheazul, u otro que sea
elcochepequeño, u otro llamado elcamionamarillo, etc., etc.
Curso de Java con Bluej.
Cursosindustriales.net
Página 3
Cada uno de los objetos pueden tener los mismos atributos o atributos
diferentes como retrovisores, luces, bocinas, etc.; o métodos como
revoluciones(), apagado(),…, etc., etc.
Por lo tanto hablar de una clase coche no es adecuado ya que podemos tener
de muy diferentes tipos. Pero si en vez de coche, hablamos de Vehículo, esta
clase si podría contener todos los objetos que hemos definido y más aún
(camiones, furgonetas, tractores, bicicletas, etc., etc.).
Esto es lo que significa ABSTRACIÓN de una clase; una clase general puede
ser Vehículo y tener objetos como coches, camiones, bicicletas, autobuses y
todos los vehículos automóviles que existan.
La abstracción por tanto designa la clase y los objetos son las peculiaridades
de dicha clase.
A partir de ahora designaremos las instancias de las clases como sus objetos,
es decir:
Objeto = instancia (clase)
Por ejemplo elcocherojo es una instancia de Vehículo.
Curso de Java con Bluej.
Cursosindustriales.net
Página 4
Como funciona BlueJ.
BlueJ es un IDE muy intuitivo. A partir de una clase puedes crear tantas
instancias como necesites simplemente pulsando doble clic sobre el objeto
principal. Y como estás empezando vamos a crear un nuevo proyecto en el
cual aprenderás más sobre las clases y objetos usados en BlueJ.
Crea un Nuevo Proyecto desde el menú Proyecto. Llámalo Instancias.
Cuando pulsas sobre Crear se abre una ventana nueva en la cual tienes un
archivo de texto en el más tarde describirás tu proyecto.
A la derecha de la ventana tienes un menú formado por cuatro botones en los
cuales puedes crear una Nueva Clase, insertar una relación “USA”, insertar
una relación de herencia o Compilar el proyecto.
Como actualmente no tienes nada en el código si pulsas sobre Compilar no te
iba a compilar nada en absoluto.
Así que pulsa sobre Nueva Clase para empezar a programar una nueva clase.
Curso de Java con Bluej.
Cursosindustriales.net
Página 5
Se te abre la ventana de configuración de clase para que escribas un nombre
de la nueva clase y el tipo de clase que crearás.
De momento no me voy a enrollar sobre los
demás tipos de clases que puedes crear para
no engorrar el aprendizaje del lenguaje. Solo
debes de saber que utilizaremos el CheckBox
Class para crear la clase, así que ponle el
nombre de Autómata
Al pulsar sobre Aceptar se te creará en la
ventana principal la clase Autómata.
Observa que dicha clase tiene una franja
rayada que indica que el proyecto no ha sido
compilado.
Pues ahora pulsa sobre Compilar para que desaparezca esa franja rayada.
Curso de Java con Bluej.
Cursosindustriales.net
Página 6
El resultado al compilar:
Curso de Java con Bluej.
Cursosindustriales.net
Página 7
Ya has creado una clase con existo. ¿Te ha parecido difícil? Pues verás que
sencillo es crear instancias de la clase a continuación.
Sitúate sobre la clase y pincha clic derecho del ratón. Te aparecerá el menú
desplegable siguiente:
Selecciona new Autómata() y aparecerá otra ventana.
La cual te indica que introduzcas un nombre para la instancia (objeto).
Curso de Java con Bluej.
Cursosindustriales.net
Página 8
Al dejarla por defecto, cuando pulsas sobre Aceptar en la parte interior de la
ventana principal se ha creado un objeto llamado autómata1.
¿A que no ha sido difícil crear una clase y un objeto de esa clase? Y es que
BlueJ proporciona una programación orientada a objetos que nos permite
realizar las tareas complicadas de manera rápida y visual.
Si bien, cuando compilas el programa no realiza ninguna acción debido a que
no hemos establecido ningún tipo de programación en la clase ni el objeto,
ahora es fácil incluir contenido a la clase y al programa mediante el editor
interno de BlueJ que podrás abrir si pulsas clic derecho del ratón sobre la clase
Abrir Editor, o haciendo doble clic.
Curso de Java con Bluej.
Cursosindustriales.net
Página 9
Se te abre la ventana de código de la clase seleccionada.
En la que podemos diferenciar tres partes importantes:
Los campos, el constructor y los métodos.
Puedes ver que la clase se designa como public class más identificador y todo
el contenido de ésta clase está entre llaves. Y como he dicho, los campos se
introducen en primer lugar, es decir las variables de instancias que usarás en
el programa. Observa que dichas variables son privadas en su forma general, y
eso se debe a que solo las usarán las instancias (objetos) que designaremos
más adelante en el constructor.
El constructor siempre tendrá el mismo identificador que la clase principal pero
con la diferencia que tendrá paréntesis en lo que poder introducir parámetros.
De todas formas en el constructor se inicializan los objetos a usar en los
programas.
Curso de Java con Bluej.
Cursosindustriales.net
Página 10
Los métodos servirán para complementar las instancias de la clase. Declarar
un método implica designar un tipo de dato en cuestión y podemos utilizar
también en parámetros otras variables.
Tu primer programa en BlueJ.
Para que pilles rápidamente el hilo del curso, vamos a complementar el
programa anterior para que nos muestre una circunferencia (instancia), la cual
podremos asignar unos valores mediantes métodos.
Este programa te lo puedes descargar desde el menú de descargas de CI.NET.
De momento solo vamos a crear un objeto y asignaremos un método que
permita cambiarle el tamaño.
Abre el editor y el campo de variables de instancias, cambia el nombre del x al
de diámetro. También crea otra variable llamada isVisible. Después en el
constructor asígnale un valor de 40 a diámetro y un false a isVisible.
Ahora solo nos queda crear el método que nos haga visible el objeto al tamaño
establecido.
Observa que, de momento hasta nuevo aviso, declararemos como public void
los métodos que usaremos. Así pues nuestro método llamado
visualizarCirculo() se configurará llamando a otro método (privado) que dibujará
el objeto en un canvas de Java.
El resultado del programa hasta ahora es:
Curso de Java con Bluej.
Cursosindustriales.net
Página 11
Por lo que ahora nos centramos en crear el método draw():
Canvas es una clase de otra librería del programa y que se encargará de
dibujar un recuadro de un tamaño específico en el que dibujar un objeto.
Observa la situación Canvas
canvas = Canvas.getCanvas();
Ese espacio entre clase e identificador lo veremos mucho en Java y hablaré
más delante de ello en éste completo curso.
Curso de Java con Bluej.
Cursosindustriales.net
Página 12
La siguiente línea, asignamos el identificador al método draw asignándole la
palabra clave this (que hace referencia al objeto en cuestión, es decir canvas),
un color para el objeto y la creación del propio objeto que en este caso es un
objeto especificado en librería de Java.
La clase Canvas requiere como parámetros 4 valores Integer que designan la
posición del objeto a dibujar en su interior en cuanto los valores de la abscisa y
la ordenada, y los valores de su tamaño inicial y final.
Para finalizar definimos un tiempo de 10 segundos para la aparición del objeto.
Si compilas el programa te va a dar un error. Es normal.
Eso es debido a que la clase Canvas no está definida. Además tenemos que
usar otra librería de Java, por lo que tendré que importar esa librería.
Curso de Java con Bluej.
Cursosindustriales.net
Página 13
Importar librerías externas al proyecto.
Al igual que en otros lenguajes, Java permite la importación de librerías
utilizando la palabra clave import. Para ello, en la cabecera del programa has
de poner dicha palabra clave y, por supuesto el nombre de la librería que
quieres importar desde Javasoft.
Necesitamos dos librearías. La general awt que se encarga del desarrollo de
interfaces gráficas del usuario.
La estructura básica del AWT se basa en Componentes y Contenedores.
Estos últimos contienen componentes posicionados a su respecto y son
componentes a su vez, de forma que los eventos pueden tratarse tanto en
contenedores como en componentes, corriendo por cuenta del programador
(todavía no hay herramientas de composición visual) el encaje de todas las
piezas, así como la seguridad de tratamiento de los eventos adecuados.
Si quieres saber más sobre ésta librería visita:
http://dis.um.es/~bmoros/Tutorial/parte13/cap13-1.html
La cuestión es que necesitamos ésta librearía y su parcial de geom, para hacer
funcionar la aplicación y dibujar nuestro programa.
NOTA: Observa que la llamada a la librería termina con el símbolo * y los dos
puntos ( ; ).
Ahora crearemos una nueva librería en nuestro proyecto que llamaremos
Canvas.
Curso de Java con Bluej.
Cursosindustriales.net
Página 14
Borra todo el código de la clase creada y copia el siguiente código (recuerda
que te puedes descargar el proyecto desde el menú de descargas de
cursosindustriales.net para evitar realizar el paso a paso):
import javax.swing.*;
import java.awt.*;
import java.util.List;
import java.util.*;
/**
* Canvas is a class to allow for simple graphical drawing on a canvas.
* This is a modification of the general purpose Canvas, specially made for
* the BlueJ "shapes" example.
*
* @author: Bruce Quig
* @author: Michael Kölling (mik)
*
* @version: 1.6 (shapes)
*/
public class Canvas
Curso de Java con Bluej.
Cursosindustriales.net
Página 15
{
// Note: The implementation of this class (specifically the handling of
// shape identity and colors) is slightly more complex than necessary. This
// is done on purpose to keep the interface and instance fields of the
// shape objects in this project clean and simple for educational purposes.
private static Canvas canvasSingleton;
/**
* Factory method to get the canvas singleton object.
*/
public static Canvas getCanvas()
{
if(canvasSingleton == null) {
canvasSingleton = new Canvas("BlueJ Shapes Demo", 300, 300,
Color.white);
}
canvasSingleton.setVisible(true);
return canvasSingleton;
}
//
----- instance part -----
private JFrame frame;
private CanvasPane canvas;
private Graphics2D graphic;
private Color backgroundColour;
private Image canvasImage;
private List objects;
private HashMap shapes;
Curso de Java con Bluej.
Cursosindustriales.net
Página 16
/**
* Create a Canvas.
* @param title
title to appear in Canvas Frame
* @param width
the desired width for the canvas
* @param height
* @param bgClour
the desired height for the canvas
the desired background colour of the canvas
*/
private Canvas(String title, int width, int height, Color bgColour)
{
frame = new JFrame();
canvas = new CanvasPane();
frame.setContentPane(canvas);
frame.setTitle(title);
canvas.setPreferredSize(new Dimension(width, height));
backgroundColour = bgColour;
frame.pack();
objects = new ArrayList();
shapes = new HashMap();
}
/**
* Set the canvas visibility and brings canvas to the front of screen
* when made visible. This method can also be used to bring an already
* visible canvas to the front of other windows.
* @param visible
boolean value representing the desired visibility of
* the canvas (true or false)
*/
public void setVisible(boolean visible)
{
Curso de Java con Bluej.
Cursosindustriales.net
Página 17
if(graphic == null) {
// first time: instantiate the offscreen image and fill it with
// the background colour
Dimension size = canvas.getSize();
canvasImage = canvas.createImage(size.width, size.height);
graphic = (Graphics2D)canvasImage.getGraphics();
graphic.setColor(backgroundColour);
graphic.fillRect(0, 0, size.width, size.height);
graphic.setColor(Color.black);
}
frame.setVisible(visible);
}
/**
* Draw a given shape onto the canvas.
* @param
referenceObject
an object to define identity for this shape
* @param
color
the color of the shape
* @param
shape
the shape object to be drawn on the canvas
*/
// Note: this is a slightly backwards way of maintaining the shape
// objects. It is carefully designed to keep the visible shape interfaces
// in this project clean and simple for educational purposes.
public void draw(Object referenceObject, String color, Shape shape)
{
objects.remove(referenceObject);
// just in case it was already there
objects.add(referenceObject);
// add at the end
shapes.put(referenceObject, new ShapeDescription(shape, color));
redraw();
}
Curso de Java con Bluej.
Cursosindustriales.net
Página 18
/**
* Erase a given shape's from the screen.
* @param
referenceObject
the shape object to be erased
*/
public void erase(Object referenceObject)
{
objects.remove(referenceObject);
// just in case it was already there
shapes.remove(referenceObject);
redraw();
}
/**
* Set the foreground colour of the Canvas.
* @param
newColour
the new colour for the foreground of the Canvas
*/
public void setForegroundColor(String colorString)
{
if(colorString.equals("red"))
graphic.setColor(Color.red);
else if(colorString.equals("black"))
graphic.setColor(Color.black);
else if(colorString.equals("blue"))
graphic.setColor(Color.blue);
else if(colorString.equals("yellow"))
graphic.setColor(Color.yellow);
else if(colorString.equals("green"))
graphic.setColor(Color.green);
else if(colorString.equals("magenta"))
graphic.setColor(Color.magenta);
else if(colorString.equals("white"))
Curso de Java con Bluej.
Cursosindustriales.net
Página 19
graphic.setColor(Color.white);
else
graphic.setColor(Color.black);
}
/**
* Wait for a specified number of milliseconds before finishing.
* This provides an easy way to specify a small delay which can be
* used when producing animations.
* @param
milliseconds
the number
*/
public void wait(int milliseconds)
{
try
{
Thread.sleep(milliseconds);
}
catch (Exception e)
{
// ignoring exception at the moment
}
}
/**
* Redraw ell shapes currently on the Canvas.
*/
private void redraw()
{
erase();
for(Iterator i=objects.iterator(); i.hasNext(); ) {
Curso de Java con Bluej.
Cursosindustriales.net
Página 20
((ShapeDescription)shapes.get(i.next())).draw(graphic);
}
canvas.repaint();
}
/**
* Erase the whole canvas. (Does not repaint.)
*/
private void erase()
{
Color original = graphic.getColor();
graphic.setColor(backgroundColour);
Dimension size = canvas.getSize();
graphic.fill(new Rectangle(0, 0, size.width, size.height));
graphic.setColor(original);
}
/************************************************************************
* Inner class CanvasPane - the actual canvas component contained in the
* Canvas frame. This is essentially a JPanel with added capability to
* refresh the image drawn on it.
*/
private class CanvasPane extends JPanel
{
public void paint(Graphics g)
{
g.drawImage(canvasImage, 0, 0, null);
}
}
Curso de Java con Bluej.
Cursosindustriales.net
Página 21
/************************************************************************
* Inner class CanvasPane - the actual canvas component contained in the
* Canvas frame. This is essentially a JPanel with added capability to
* refresh the image drawn on it.
*/
private class ShapeDescription
{
private Shape shape;
private String colorString;
public ShapeDescription(Shape shape, String color)
{
this.shape = shape;
colorString = color;
}
public void draw(Graphics2D graphic)
{
setForegroundColor(colorString);
graphic.fill(shape);
}
}
}
Curso de Java con Bluej.
Cursosindustriales.net
Página 22
Ahora el programa te queda de la siguiente forma:
Pulsa sobre Compilar y automáticamente BlueJ te realizará las conexiones de
las clases y librerías compartidas.
Cuando damos clic derecho sobre la clase Autómata, nos aparece esta
ventana:
Al pulsar sobre new Autómata, se crea una instancia de Autómata que por
defecto se llamará autómata1.
Y si ahora pulsas clic derecho sobre la nueva instancia:
Curso de Java con Bluej.
Cursosindustriales.net
Página 23
Y pulsas sobre el método visualizarCirculo(), entonces se mostrará un canvas
con un círculo rojo en su interior y un tamaño de 40 pixeles.
Curso de Java con Bluej.
Cursosindustriales.net
Página 24