hola

Vista previa del material en texto

PRÁCTICA 1 Introducción a Java y 
Eclipse
DYA 
sta práctica se dedica, fundamentalmente, a conocer el entorno de trabajo para
desarrollo de aplicaciones en Java en el entorno Eclipse. Este IDE es un proyecto
de software libre y está apoyado por gran nuúmero de empresas con interés en el
lenguaje Java y también en otros lenguajes. Se encuentra disponible para las plataformas
Linux, Windows y Mac OS en http://ww.eclipse.org:
Esta práctica introduce el método de trabajo a seguir en cada práctica y a la programación
básica en Java.
1.1.- El entorno de trabajo
El entorno de trabajo está formado, básicamente, por:
1. El IDE Eclipse es una herramienta de software libre para desarrollo de programas en
Java, disponible para plataformas Linux, MacOs X y Windows XP. Disponible en:
E
 1
El directorio de trabajo
http://www.eclipse.org/downloads/
Su funcionalidad se puede ampliar con plugins. El programa de prácticas de la asignatura
requiere instalar especificamente los siguientes plugins:
- Plugin RMI Genady
 - Name: RMI Plugin for Eclipse v2.0
 - URL: http//www.genady.net/rmi/v20/install/ 
- Plugin CORBA ORBstudio
 - Descargar de: http//www.orbzone.org
- Plugin Visual Editor (VE)
 - Parte de la distribución Europa. Descargar con el update manager del repositorio
Callisto.
- Plugin Web Tool Platforms (WTP).
 - Parte de la distribución Europa. Descargar con el update manager del repositorio WTP
updates.
2. Los recursos disponibles en el PoliformaT de la asignatura: 
- Enunciados y ficheros de apoyo para la realización de las prácticas. 
- Documentación sobre Java, incluyendo el API de programación y el tutorial "The Java Tuto-
rial: Object Oriented Programming for the Internet" de K. Walrath y M. Campione. 
1.2.- El directorio de trabajo
En primer lugar es necesario tener una idea clara a la estructura de directorios. Aunque
parezca simple, esta es una de las mayores fuentes de problemas en todas las prácticas. Eclipse
requiere utilizar un directorio de trabajo base o workspace referido como $WS. Puede utilizar por
ejemplo:
 UNIX -> DIRECTORIO BASE ($WS) : $HOME/workspace
 WINDOWS -> DIRECTORIO BASE ($WS) : C:\Documents and Settings\USER\workspace
Recuerde que el laboratorio no garantiza preservar el contenido de los directorios de discos locales.
Por tanto, es su responsabilidad almacenar sus programas la unidad W: que proporciona la UPV a
cada estudiante al final de cada práctica.
Para recuperar un proyecto de una sesión de trabajo anterior alamacenado en la unidad W: al direc-
torio de trabajo, deberá realizarlo con la opción Import de Eclipse.
2 Introducción a Java y Eclipse
El directorio de trabajo
 DYA 
1.2.1.- Estructura del directorio de trabajo
Cada práctica constituirá un proyecto Java (Java project) de Eclipse. Cada proyecto es un
directorio que tendrá dos subdirectorios src para ubicar el código fuente y bin para el código 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. 
Así por ejemplo, un proyecto denominado prj-sockets, con dos paquetes denominados client y ser-
ver tendrá la siguiente estructura:
$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
Esta estructura de directorios es la que utilizan la mayoría de los IDE’s para desarrollo de Java,
incluyendo Eclipse y JBuilder.
1.2.2.- Inicializando los contenidos del directorio de trabajo
Algunas prácticas disponen en la web de un fichero comprimido (.zip) con material de
apoyo. Este material está organizado normalmente según la estructura de directorios de un proyecto
arriba indicada. El subdirectorio src contiene ficheros fuente cuya implementación está incompleta.
Los ejercicios a realizar para completar la implementación del fichero fuente se encuentran enun-
ciados como comentarios en el propio fichero.
Cuando necesite utilizar los ficheros de apoyo el método será el siguiente.
1. Descargar el fichero zip con el material de apoyo a un directorio de descargas referido como $DL
(p.e. $DL=$HOME/descargas) y descomprimirlo, creando la estructura de directorios arriba indi-
cada.
2. Copiar el fichero desede el directorio de descargas:
$DL/prj-hola/src/hola/fichero.java
al correspondiente directorio del workspace:
$WS/prj-hola/src/hola/fichero.java
3. Es necesario actualizar la ventana del Package Explorer del IDE Eclipse (Refresh / tecla F5)
cada vez que se añade un nuevo paquete o fichero al proyecto de forma externa a Eclipse para
que este se aperciba de los cambios o nuevos ficheros introducidos. 
 3
Desarrollo de un proyecto elemental: Hola mundo!
4.
1.3.- Desarrollo de un proyecto elemental: Hola mundo!
Para desarrollar un proyecto Java previamente creado, según se detalla en el apartado ante-
rior, básicamente han de seguirse los pasos que a continuación se detallan:
1. Abrir el IDE Eclipse y escoger como directorio workspace el directorio $WS/
2. Crear un proyecto Java (por ejemplo prj-hola para la primera práctica) en el IDE Eclipse, espe-
cificando que se creen subdirectorios separados para código fuente (src) y código objeto (bin)
con la opción: ‘Create separate source and output folders’.
3. Crear en el proyecto los paquetes necesarios para el desarrollo de la práctica. En este caso solo
existe un único paquete denominado hola.
4. Crear un fichero HolaMundo.java, en el paquete en que deba incluirse, que en este caso es el
paquete hola. Opción: New->Class + public static void main
5. Editar y completar la aplicación HolaMundo.java.
- Puede ser interesante en este apartado utilizar el menú Help y la opción Dynamic Help para
consultar el API de una determinada clase Java que se desee utilizar, por ejemplo la clase
System.
6. La compilación de todos los ficheros de que consta un proyecto se realizará automáticamente
cada vez que salve el fichero si la opcion Project-> Build automatically se encuentra activada.
Los errores vienen indicados a principio de la línea correspondiente del editor. La causa del error
y la corrección sugerida se obtienen haciendo click sobre el icono del error.
7. Ejecutar y depurar el programa HolaMundo.java. La forma más sencilla de ejecutar un pro-
grama es con el menú Run del IDE Eclipse. El proyecto será recompilado cada vez que ejecute
el programa.
- Los programas sencillos y sin argumentos pueden ejecutarse con la opción Run as -> Java
Application.
- Los programas que necesiten argumentos, argumentos de la máquina virtual o modificar pro-
piedades de Java precisan crear un perfil de ejecución con la opción Run... que despliega un
menú de ventanas con distintos parámetros de ejecución. Cree un perfil para esta aplicación y
guárdelo con el nombre HolaMundo.
- Una opción interesante cuando se depura un programa (no tan simple como este) es la coloca-
ción de puntos de ruptura o Breakpoints. Esto se realiza en la barra izquierda de la ventana
del editor de programas.
- Observe que la ejecución de un programa abre una nueva ventana de tipo Console en la parte
inferior del IDE Eclipse donde se realiza la E/S. 
- Si introduce un error en su programa, verá que el listado de errores aparece en la ventana Pro-
blems ubicada en la misma zona que la ventanas Console. Observe también las posibilidades
4 Introducción a Java y Eclipse
Desarrollo de algunas otras aplicaciones básicas en Java
 DYAque ofrecen los controles sobre este tipo de ventanas (abrir, cerrar, fijar, maximizar, lim-
piar,...) de la parte inferior del IDE.
8. El código objeto generado se almacena en el directorio $WS/prj-sockets/bin/ pero también puede
crear un fichero tipo JAR (Java Archive) que empaquete el código objeto de un proyecto. Este
fichero puede generarse con la opción Export->Java->JAR file aplicada sobre el paquete que se
visualiza la ventana del Package Explorer. Este fichero se ubica el directorio base del works-
pace. Puede ejecutarse externamente a Eclipse si al crear el JAR se especifica la clase principal.
1.4.- Desarrollo de algunas otras aplicaciones básicas en Java
Una vez ha desarrollado la aplicación HolaMundo!, se propone completar el paquete hola
con otras aplicaciones básicas en Java. Estas aplicaciones se encuentran a medio resolver como
ficheros de apoyo. En esta caso la metodología a seguir es:
1. Incluir el fichero en el proyecto. Para ello, cópielo (en vez de crearlo) desde el directorio de des-
cargas al directorio de trabajo o workspace. Actualizar la ventana del Package Explorer del
IDE Eclipse (tecla F5) cada vez que se añade un nuevo paquete o fichero al proyecto y compro-
bar que esos paquetes se visualizan y son accesibles desde el editor de programas.
2. Editarlo, y realizar los ejercicios propuestos sobre el propio código fuente: puede requerir con-
sultar la ayuda del API con Dynamic Help.
3. Ejecutarlo y depurarlo: Cree un perfil de ejecución con el diálogo Run... para cada ejercicio pro-
puesto. 
Los ejercicios propuestos son, por este orden:
• Objetos.java: ejercicios sobre clases, herencia, objetos,...
• Relojes.java: ejercicios de utilización de la clase Thread.
• CountFile.java: cuenta los caracteres de un fichero. Ejemplo de trabajo con ficheros. 
• CopyFile.java: copia ficheros. Ejemplo de trabajo con ficheros.
• EntradaSalida.java: ejercicios con sentencias de E/S con streams.
• DataIOTest.java: ejercicios de escritura y lectura de datos numéricos de un fichero. 
 5
Ficheros de apoyo
1.5.- Ficheros de apoyo
1.5.1.- Fichero Objetos.java
package hola;
import java.io.*;
class Punto {
 public int x = 0;
 public int y = 0;
 public Punto(int x, int y) {
 this.x = x;
 this.y = y;
 }
}
class Rectangulo {
 protected Punto origen;
 protected int ancho = 0;
 protected int alto = 0;
 private static String nombreClase ="Rectangulo";
 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() {
6 Introducción a Java y Eclipse
Ficheros de apoyo
 DYA 
 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();
 }
}
//EJERCICIO: Implemente una clase RectanguloColor, basándose en la clase Rectangulo.
//EJERCICIO: con un nuevo atributo color y sobrecargando el método toString
class RectanguloColor extends Rectangulo {
 //EJERCICIO: ...
 public String toString() {
 //EJERCICIO: Sobrecargue este método para que incluya en el String también el color
 }
}
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 rectángulo color RC
 7
Ficheros de apoyo
 //EJERCICIO: que añada 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 método mover(10,10) sobre R3
 //EJERCICIO: Invoque el método toString sobre R3 y RC
 //EJERCICIO: y visualicelos por pantalla el resultado
 //PREGUNTA: Se ha "movido" R3? y RC? Debería 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());
 }
}
1.5.2.- Fichero Relojes.java
package hola;
import java.text.*;
import java.util.*;
class Reloj extends Thread {
int cuenta=0;
public Reloj(String nombre, int cuenta) {
 super(nombre); this.cuenta=cuenta;
 }
 public void start() {
 Date h = new Date();
 System.out.println(getName() + "-> " +
 DateFormat.getTimeInstance(3,Locale.FRANCE).format(h) +
 " Faltan " + cuenta + " seg. para la alarma");
 super.start();
 }
 public void run() {
 for (int i = 1; i <= cuenta; i++) {
 //EJERCICIO: Provoque un retraso de 1000 milisegundos
 }
 System.out.println(getName() + "Riiinnnng!!!");
 }
}
public class Relojes {
8 Introducción a Java y Eclipse
Ficheros de apoyo
 DYA 
public static void main(String[] args){
//EJERCICIO: Cree dos instancias de la clase Reloj
}
}
1.5.3.- Fichero 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.");
 }
1.5.4.- Fichero 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]
 9
Ficheros de apoyo
 // 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");
 }
 }
}
1.5.5.- Fichero 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 imprÌmalo 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 almacénela en la variable filename
10 Introducción a Java y Eclipse
Ficheros de apoyo
 DYA 
 //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 cÛdigo 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);
 }
}
}
1.5.6.- Fichero DataIOTest.java
/Se trata de escribir en un fichero con formato:
//
// 9.99 12 Java T-shirt
// 9.99 8 Java Mug
// 15.99 13 Duke Juggling Dolls
//
// y luego leerlo y sacarlo por pantalla
// NOTA: los datos numéricos deben escribirse como "números" y
// no como cadenas de caracteres.
// NOTA: los Strings deben escribirse como cadenas de bytes
// 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 numéricos (stream = secuencia de bytes)
 //Aconsejable para ficheros o sockets pero no para teclado y pantalla
 11
Ficheros de apoyo
 //EJERCICIO: Instancie un objeto de tipo DataOutputStream para escribir
 // en el 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" };
 //Un 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();
 //Un 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){};
 }
12 Introducción a Java y Eclipse
Ficheros de apoyo
 DYA 
}
 13
Ficheros de apoyo
14 Introducción a Java y Eclipse
	PRÁCTICA 1 Introducción a Java y Eclipse
	1.1.- El entorno de trabajo
	1.2.- El directorio de trabajo
	1.2.1.- Estructura del directorio de trabajo
	1.2.2.- Inicializando los contenidos del directorio de trabajo
	1.3.- Desarrollo de un proyecto elemental: Hola mundo!
	1.4.- Desarrollo de algunas otras aplicaciones básicas en Java
	1.5.- Ficheros de apoyo
	1.5.1.- Fichero Objetos.java
	1.5.2.- Fichero Relojes.java
	1.5.3.- Fichero CountFile.java
	1.5.4.- Fichero CopyFile.java
	1.5.5.- Fichero EntradaSalida.java
	1.5.6.- Fichero DataIOTest.java