Computadores y Redes

Prctica 3:
Introduccin a Java y Eclipse

Mster Universitario en Automtica e Informtica Industrial

Asignatura: Computadores y Redes
Gabriela Andreu Garca
Francisco Blanes Nogueras

1 Objetivos
1. Presentar el entorno de desarrollo integrado Eclipse (IDE Eclipse o Eclipse Intregated
Development Enviroment) para desarrollar aplicaciones en Java.
2. Introducir la programacin bsica en Java as como el mtodo de trabajo a seguir en las
prcticas de esta asignatura.

2 Entorno de Desarrollo Eclipse

El IDE Eclipse es una herramienta de software libre para el desarrollo de programas en
Java, disponible en http://www.eclipse.org para plataformas Linux, MacOs X y Windows XP.
Las capacidades de este entorno se pueden ampliar mediante plug-in, dotndole as de
nuevas funcionalidades. Eclipse proporciona un marco y un conjunto de servicios para
construir un entorno de desarrollo a partir de componentes conectados (plug-in).

3 Material y modo de Trabajo de Practicas

En el PoliformaT de la asignatura se encuentra el material para realizar esta prctica:
enunciados, archivos .java y documentacin sobre Java, incluyendo el manual Aprenda Java
como si estuviera en primero.
AVISO! El laboratorio no garantiza que se preserve el contenido de los
directorios de discos locales de una sesin a otra. Por tanto, es su
responsabilidad almacenar sus programas en la unidad que se desee, para
tenerlo disponible en sucesivas sesiones.
Las prcticas se deben desarrollar completando lneas de cdigo sobre los archivos que se
proporciona con cdigo fuente en java. Los enunciados, de los desarrollos a realizar, se
encuentran como comentarios en los propios archivos fuente.

3.1 Directorio de trabajo

Para trabajar con comodidad en el laboratorio cree una carpeta denominada cmyr en
el escritorio de su maquina y una subcarpeta denominada cmyr/ws. Estas carpetas
contendrn toda la informacin desarrollada en prcticas para salvarlas y recuperarlas con
facilidad.

Cree en el escritorio de su mquina una carpeta cmyr que contenga otra carpeta
ws.

Cree un directorio cmyr/practica1, acceda al PoliformaT y descargue en l el

fichero prac1.zip

y descomprmalo. Aparecern los archivos Objetos.java,

CountFile.java CopyFile.java, EntradaSalida.java y DataIOTest.java.

Cada ejercicio propuesto se puede trabajar como un proyecto Java (Java project) diferente.

3.2 Subdirectorios src y bin

Cada proyecto en Eclipse debe tener dos subdirectorios: src para ubicar el cdigo fuente y
bin para el cdigo objeto (.class). A su vez, cada proyecto constar de varios paquetes (o
packages). Cada uno de estos packages constituye, a su vez, un subdirectorio de los
directorios src y bin.
Un proyecto prj-sockets, con dos paquetes client y server tendr la siguiente estructura:
Esta estructura de directorios es la que utilizan la mayora de los IDEs para desarrollo de
. Java, incluyendo Eclipse y JBuilder

$ ws/prj-sockets
$ ws/prj-sockets/src
$ ws/prj-sockets/src/client
$ ws/prj-sockets/src/server
$ ws/prj-sockets/bin/client
$ ws/prj-sockets/bin/server

AVISO! Es necesario tener idea clara de la estructura de una directorios de la

aplicacin. Aunque parezca simple, esta es una de las mayores fuentes de
problemas en todas las prcticas.

4 Trabajando con Eclipse

La interfaz de usuario de Eclipse consta de dos tipos de elementos: vistas y editores. Una

perspectiva de Eclipse es una agrupacin de vistas y editores de manera que den apoyo a
una actividad completa del proceso de desarrollo software. Eclipse contiene una serie de
perspectivas. Cada perspectiva proporciona un conjunto de funcionalidades para el
desarrollo de un tipo especfico de tarea. Por ejemplo la perspectiva Java combina un
conjunto de views que permiten ver informacin til cuando se est escribiendo cdigo
fuente. Mientras que la perspectiva de depuracin contiene vistas que muestran
informacin til para la depuracin de los programas Java.
La perspectiva activa se muestra en la barra del ttulo en la parte superior de la ventana.

4.1 El Directorio de Trabajo o workspace

Eclipse requiere utilizar un directorio de trabajo base o workspace referido como ws,
cuyo PATH o nombre es requerido al ejecutarlo.

Eclipse
e
indique
Ejecute
C:\Users\login\Desktop\cmyr\ws

como

directorio

workspace

En el entorno Eclipse todo archivo se almacena dentro de un proyecto. Esto quiere decir
que todo documento, carpeta, archivo de cdigo fuente (.java) y cdigo 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.
Para recuperar un proyecto almacenado en una unidad externa al directorio de trabajo
actual, debe hacerlo con la opcin del menu File >Import de Eclipse.

4.2 Creacin del proyecto: Hola mundo!

En Eclipse es necesario crear un proyecto tanto para desarrollar un nuevo programa de
Java, como para editar archivos ya existentes, como por ejemplo,un programa ".java"
almacenado en un disco USB. Para crear un nuevo proyecto, debe seleccionar en la lnea de
mens principal "File > New > Java Project...". Tambin es posible seleccionar estas
opciones haciendo clic con el botn derecho en la vista Package Explorer o el Resource
Navigator de Eclipse.

Cree un proyecto Java denominado project_hola para la en el IDE Eclipse.

Especifique con la opcin Create separate source and output folders que se creen
subdirectorios separados para cdigo fuente (src) y cdigo objeto (bin). Active la
opcin Java SE-1.6. Las siguientes figuras le ayudan a realizar estos pasos correctamente.

Una vez que se ha creado un nuevo proyecto, debemos aprender cmo crear los diversos
elementos de Java. Para seguir los pasos que se exponen a continuacin es necesario estar en
la "Perspectiva Java" seleccionando "Window > Perspectives > Java". La perspectiva de Java
contiene las vistas y editores ms tiles a la hora de crear nuevos programas en Java

Package: Los paquetes se declaran para almacenar y organizar los archivos de Java. Las clases
que se creen dentro de un paquete determinado en Eclipse llevarn aadida automticamente
la declaracin "package" en su cdigo fuente.

Cree en el proyecto project_hola un paquete denominado hola, para ello

seleccione en el men principal "File > New > Package.".
Clases: Las clases de Java son los archivos ".java" que contienen el cdigo fuente y que

sern posteriormente compilados en archivos ".class". Los archivos .java tienen que estar
almacenados dentro de la carpeta fuente "src".

Cree un archivo HolaMundo.java, en el paquete hola. Para ello seleccione New

> Class, se abrir la ventana de creacin de clases, rellene el nombre de la clase
HolaMundo (por convenio los nombres de la clase en Java empiezan con

mayscula) y marque la opcin public static void main.

Edite y complete la aplicacin HolaMundo.java. Es interesante utilizar el men Help y

la opcin Dynamic Help para consultar el API de una determinada clase Java, por
ejemplo la clase System.
Nombres de Clases: Crear referencias a otras clases dentro de la clase actual es una tarea de
programacin habitual. Sin embargo, algunas clases de Java tienen nombres muy largos que son
difciles de recordar. Con "CTRL + Espacio" tras escribir los primeros caracteres del nombre
de una clase Java Eclipse muestra las posibles alternativas.
En Eclipse los errores de compilacin se muestran en tiempo real subrayando el
fragmento de cdigo adecuado con una lnea roja. Adems

el entorno automticamente

compila los archivos salvados de un proyecto si la opcin Project >Build automatically se

encuentra activada. Los errores se muestran como marcas rojas en el margen derecho del
editor de Java. La causa del error y la correccin sugerida se obtienen haciendo clic sobre el
icono del error. Eclipse habitualmente permite autocorregir los posibles errores haciendo clic
en el icono de bombilla presente en el margen izquierdo del editor de cdigo.

4.3 Ejecutar programas Java en Eclipse

Los programas sencillos y sin argumentos pueden ejecutarse con la opcin Run > Run as >
Java Application. Observe que la ejecucin de un programa abre una nueva ventana
de tipo Console en la parte inferior del IDE Eclipse donde se realiza la E/S.

Ejecute y depure el programa HolaMundo.java.

Para ejecutar programas que necesitan argumentos se debe crear un perfil de ejecucin con la
opcin Run >Run Configurations > que despliega un men de ventanas con distintos
parmetros de ejecucin, en la pestana "Main" hay que dar nombre a la nueva configuracin,
seleccionar el proyecto que contiene la clase con el mtodo main y seleccionar dicha clase. Si se
desea pasar argumentos al mtodo main (en la forma de "String[] args"), hay que hacer clic en la

solapa de "Arguments" y escribir esos argumentos separados por espacio dentro de la zona en
blanco de "Program Arguments".

Cree un perfil de ejecucin para esta aplicacin y gurdelo con el nombre HolaMundo.
Eclipse da apoyo a la tarea de depuracin a travs de su perspectiva "Window > Open
Perspective > Debug" o seleccionando el icono del "bicho". Una opcin interesante cuando se
depura un programa es la colocacin de puntos de ruptura o Breakpoints. Esto se realiza
en la barra izquierda de la ventana del editor de programas. Seleccionando "Add/Remove
Breakpoint" se aade o quita un punto de ruptura, mientras que "Toggle Breakpoint" cambiara
el estado de activacin del punto de ruptura. Los puntos de ruptura marcan lneas en que la
ejecucin del programa se detendr de manera que sea posible comprobar el valor de las
variables en ese instante, identificando as posibles errores.

Haciendo clic derecho en un punto de ruptura y seleccionando "Breakpoint Properties..." permite

especificar opciones avanzadas del punto de ruptura:
o

"Hit Count" especifica que la ejecucin del programa se detendr cuando se pase por el
punto de ruptura el nmero de veces especificado.

Conditional detendr la ejecucin cuando la condicin sea cierta.

"Suspend when true o Suspend when value changes". detendr la ejecucin cuando el
valor de la variable cambie.

Si introduce un error en su programa, ver que el listado de errores aparece en la ventana

Problems ubicada en la misma zona que la ventana Console. Observe las posibilidades que ofrecen
los controles sobre este tipo de ventanas (abrir, cerrar, fijar, maximizar, limpiar,...) de la parte
inferior del IDE.

4.4 Archivos JAR (Java Archive)

El cdigo Java objeto generado en Eclipse se almacena por defecto en el subdirectorio bin
correspondiente. Tambin se puede empaquetar el cdigo objeto de un proyecto en un

fichero tipo JAR. Los archivos JAR puede generarse selecionando la opcin File > Export >Java
> JAR file aplicada sobre el paquete que se visualiza la ventana del Package Explorer. El fichero
JAR se ubica el directorio base del workspace y puede ejecutarse externamente a Eclipse si al
crear el JAR se especifica la clase principal.

5. Desarrollo de Aplicaciones Bsicas en Java

Una vez desarrollada la aplicacin HolaMundo, debe completar otras las aplicaciones bsicas que
se proporcionan a medio resolver en los archivos de apoyo del Poliformat que descargo en la
carpeta ws/practica1. Los archivos contienen cdigo fuente de Java y en los comentarios se
encuentran propuestos los desarrollos a realizar. La metodologa a seguir es:

Cree un proyecto nuevo para cada uno de los ejercicios (ficheros) de la prctica. Copie
el fichero .java en el directorio src del proyecto correspondiente. Actualice la ventana
del Package Explorer del IDE Eclipse (tecla F5) cada vez que aade un nuevo paquete o
fichero al proyecto y compruebe que esos paquetes se visualizan y son accesibles desde
el editor.
Por ejemplo, para desarrollar el primer ejercicio cree un proyecto llamado Objetos e incluya el
archivo Objetos.java en la carpeta src del proyecto.
AVISO! Es necesario actualizar la ventana Package Explorer del IDE Eclipse con
File > Refresh o tecla F5 cada vez que se aade un nuevo paquete o archivo al
proyecto de, para que eclipse perciba de los cambios o nuevos ficheros
introducidos

Edtelo Objetos.java y realice los ejercicios propuestos sobre el propio cdigo fuente:
puede requerir consultar la ayuda del API con Dynamic Help.

Ejectelo y deprelo: Cree un perfil de ejecucin con el dilogo Run > Run as .
para cada ejercicio propuesto.
Los ejercicios propuestos deben realizarse en el siguiente orden:
1. Objetos.java: ejercicios sobre clases, herencia, objetos,.
2. CountFile.java: cuenta los caracteres de un fichero. Ejemplo de trabajo con ficheros.
3. CopyFile.java: copia ficheros. Ejemplo de trabajo con ficheros.
4. EntradaSalida.java: ejercicios con sentencias de E/S con streams.
5. DataIOTest.java: ejercicios de escritura y lectura de datos numricos de un fichero.
Los ejercicios del 1 al 3 son obligatorios su entrega. El 4 y 5 opcionales y servirn para mejorar
la nota.

5.1 Fichero de Apoyo Objetos.java

// Archivo objetos.java
import java.io.*;

// *clase Punto
class Punto {

// Definicin de las variables miembros de la clase

public int x = 0; public int y = 0;

// Constructor de la clase Punto

public Punto(int x, int y)

{
this.x = x; this.y = y;}
} //Fin clase Punto*

class Rectangulo {

// Definicion de las variables miembros

protected Punto origen;

protected int ancho = 0;

protected int alto = 0;

private static String nombreClase ="Rectangulo";

// Constructores de la clase Rectngulo

public Rectangulo(int origenx, int origeny, int ancho, int alto)

{ origen=new Punto(origenx, origeny);

this.ancho=ancho; this.alto=alto;

}


public Rectangulo(Punto p, int ancho, int alto)

{origen= p; this.ancho=ancho; this.alto=alto;}


public Rectangulo(int ancho, int alto)

{ origen= new Punto(0,0); this.ancho=ancho; this.alto=alto;}


public Rectangulo()

{ origen= new Punto(0,0); this.ancho=0; this.alto=0; }

public int ancho() { return ancho; }

public int alto() { return alto; }

public int area() { return (ancho*alto); }



public void mover(int arriba, int derecha)

{ origen.x+=arriba; origen.y+=derecha; }



public String toString()

{ return "(Origen: {" + Integer.toString(origen.x) + "," +
Integer.toString(origen.y) + "}, "
+
"Final: {" + Integer.toString(origen.x+ancho) +






"," + Integer.toString(origen.y+alto) +
"})";

}

public static String nombre() { return nombreClase; }

protected void finalize() throws Throwable

{ origen = null; super.finalize();}
} //Fin Clase rectangulo*

class RectanguloColor extends Rectangulo {
//EJERCICIO: Implemente una clase RectanguloColor, basndose en la clase Rectangulo.
//Con un nuevo atributo color y sobrecargando el mtodo toString

public String toString() {

//EJERCICIO: Sobrecargue este mtodo para que incluya en el String tambin el
color


}

}//Fin Clase RectanguloColor

class CuadradoColor extends RectanguloColor {

public CuadradoColor(Punto p, int lado, int color)

{ super(p,lado,lado,color); }
}

public class Objetos{

static Rectangulo R1 = new Rectangulo(1,1,7,8);

static Rectangulo R2 = new Rectangulo(new Punto(2,2),7,8);

static Rectangulo R3 ;

static RectanguloColor RC;

static CuadradoColor C;

public static void main(String args[]) throws IOException

{


if (args.length < 4)


{ System.out.println("Uso: Objetos origen-x origen-y ancho alto");


System.exit(1);


}





int[] i = new int[4];


int j = 0;





for(j=0; j < i.length; j++)


i[j] = Integer.parseInt(args[j]);


R3 = new Rectangulo(i[0],i[1],i[2],i[3]);




RC= //EJERCICIO: Cree una instancia de rectngulo color
RC


//EJERCICIO: que aada a R3 el atributo de color.





System.out.println("Nombre de la clase: " + Rectangulo.nombre());


System.out.println("Nombre de la clase de R3: " + R3.nombre());


System.out.println("Area de R3: " + R3.area());


System.out.println("R3: " + R3.toString());


System.out.println("RC: " + RC.toString());


//EJERCICIO: Invoque el mtodo mover(10,10) sobre R3


//EJERCICIO: Invoque el mtodo toString sobre R3 y RC y visualicelos
por pantalla el resultado


//PREGUNTA: Se ha "movido" R3? y RC? Debera haberse "movido" RC?
//Explique convenientemente este aspecto.





C= //EJERCICIO: Cree un CuadradoColor con origen en
el punto:
(2,2),alto=5,ancho=25


System.out.println("C: " + C.toString());


System.out.println("Area de C: " + C.area());

}
}

5.2 Fichero de Apoyo CountFile.java

package hola;
import java.io.*;

class CountFile {
public static void main(String[] args)



throws java.io.IOException, java.io.FileNotFoundException
{

int count = 0;
InputStream is;
String filename;

if (args.length >= 1) {

// EJERCICIO: Cree una instancia de FileInputStream, llamada is,

// para leer del fichero que se especifica como args[0]

filename = args[0];
} else {

is = System.in;

filename = "Input";
}

while (is./* EJERCICIO: */!= -1)
//EJERCICIO: utilice un metodo de FileInputStream para leer un caracter
count++;

System.out.println(filename + " has " + count + " chars.");

5.3 Fichero de Apoyo CopyFile.java

package hola;

import java.io.*;

class CopyFile {

public static void main(String[] args)







throws java.io.IOException,
java.io.FileNotFoundException

{


byte[] buffer = new byte[256];


int count;





if (args.length == 2) {


// EJERCICIO: Cree una instancia de FileInputStream, llamada is,



// para leer del fichero que se especifica como args[0]


// EJERCICIO: Cree una instancia de FileOutputStream, llamada os,



// para escribir en el fichero que se especifica como args[1]

while ((count=is.read(buffer)) != -1) os.write(buffer,0,count);


}


else


{ System.out.println("Se necesitan dos argumentos"); }



}
}

5.4 Fichero de Apoyo EntradaSalida.java

package hola;
import java.io.*;

public class EntradaSalida{

public static void main(String args[]) throws IOException{

int j;

byte[] buffer = new byte[80];

String filename, filename2;

float f1 = (float) 3.1416;

float f2 = 0;



try {



//E/S con InputStream y OutputStream



System.out.println("Teclee una cadena");



j = System.in.read(buffer);



System.out.print("La cadena: ");



System.out.write(buffer,0,j);



//Convertimos cadena de bytes a cadena de caracteres (2 bytes)



String tira = new String(buffer,0,j);



System.out.println("Otra vez la cadena: " + tira);







//E/S con BufferedReader y PrintWriter



//Conveniente con cadenas de caracteres (1 caracter = 2 bytes)



BufferedReader stdIn = new BufferedReader( new
InputStreamReader(System.in));



PrintWriter stdOut = new PrintWriter(System.out);



//E/S con InputStream y OutputStream



System.out.println("Teclee un entero");







//EJERCICIO: Lea un entero por teclado e imprimalo en pantalla







//E/S con BufferedReader y PrintWriter



//Conveniente con cadenas de caracteres (1 caracter = 2 bytes)



System.out.println("Teclee un nombre para un fichero");



//EJERCICIO: Lea de teclado una cadena para el nombre del
fichero



//
y almacnela en la variable filename







//E/S con ficheros y floats en formato numerico



//EJERCICIO: Escriba un float en el fichero filename (en formato
binario)



//EJERCICIO: Lea el float que ha escrito en el fichero filename



//EJERCICIO: Escriba el float que ha leido del fichero filename
en pantalla



//AYUDA: Mire el cdigo de un poco mas abajo...



//
Es parecido (pero en formato de texto)









//E/S con ficheros y
floats en formato de texto filename2=filename + ".txt";



System.out.println("Fichero: "+filename2);







PrintWriter fout2 = new PrintWriter(new
FileOutputStream(filename2));







BufferedReader fin2 = new BufferedReader(




new InputStreamReader(new FileInputStream(filename2)));



fout2.println(new Float(f1).toString()); fout2.flush();



f2=Float.valueOf(fin2.readLine()).floatValue();



System.out.println("Escrito y leido el float: " +f2+ " del
fichero: " +filename2); }



catch (IOException e) {




System.out.println("Error en E/S");




System.exit(1);




}

}
}

5.5 Fichero de Apoyo DataIOTest.java

//Se trata de escribir en un fichero, para despus leerlo y mostrarlo por pantalla.
// El formato del archivo es el siguiente formato:
//
// 9.99 12 Java T-shirt
// 9.99 8
Java Mug
// 15.99
13 Duke Juggling Dolls
//
// NOTA: los datos numricos deben escribirse como "nmeros" y no como cadenas de
caracteres.
// NOTA: los Strings deben escribirse como cadenas de bytes y
// no como cadenas de caracteres (1caracter = 2 bytes)
package hola;
import java.io.*;

public class DataIOTest {

public static void main(String[] args) throws IOException {


//E/S con DataInputStream y DataOutputStream

//Conveniente con datos numricos (stream = secuencia de bytes)

//Aconsejable para ficheros o sockets pero no para teclado y pantalla

//EJERCICIO: Instancie objeto de tipo DataOutputStream para escribir en
fichero "invoice1.txt"

DataOutputStream out =



//EJERCICIO: Instancie un objeto de tipo DataInputStream para leer
del
fichero "invoice1.txt"

DataInputStream in =



//Los datos son:

double[] prices = { 19.99, 9.99, 15.99, 3.99, 4.99 };

int[] units = { 12, 8, 13, 29, 50 };

String[] descs = { "Java T-shirt", "Java Mug", "Duke Juggling Dolls", "Java
Pin",
"Java Key Chain"};



//Bucle para escribir


for (int i = 0; i < prices.length; i ++)


{ out.writeDouble(prices[i]);




out.writeChar('\t');



out.writeInt(units[i]);




out.writeChar('\t');




out.writeBytes(descs[i]);




out.writeChar('\n');


}

out.close();



//Bucle para leer

double price;

int unit;

String desc;

double total = 0.0;



try {


while (true) {



//EJERCICIO: leer el primer double del fichero sobre la variable
price



in.readChar(); // throws out the tab



//EJERCICIO: leer el int siguiente sobre la variable unit




in.readChar();
// throws out the tab



//EJERCICIO: leer la cadena siguiente sobre la variable desc



System.out.println("You've ordered " + unit + " units of " +

desc + " at $" + price);
total = total + unit * price;


}

}

catch (EOFException e) { }


System.out.println("For a TOTAL of: $" + total);

in.close();

while (true){};
}
}