Download Practica Eclipse

INSTITUTO TECNOLÓGICO
SUPERIOR DE SAN MARTÍN
TEXMELUCAN
INGENIERÍA EN SISTEMAS
COMPUTACIONALES
SISTEMAS DISTRIBUIDOS
“PRÀCTICA COLOCAR LOS PLUGIN
DE CORBA Y DE RMI”
Profesor:
Susana Garrido Cortes
Alumnos:
Susana Yarell Rodríguez Contreras
Isaías Rodríguez Ventura
Nora Estrada Serrano
8°B
Esta 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 nú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:
http://www.eclipse.org/downloads/
Su funcionalidad se puede ampliar con plugins.
El programa de prácticas de la asignatura requiere instalar específicamente 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.
Para poder instalar el Plugin antes mencionado se necesitaba instalar el “Galileo”
para que funcionara correctamente si no instalas en Plugin que acabamos de
mencionar el VE nunca se podrá instalar. A continuación se muestran los enlaces
donde fueron descargados los Plugins:

Galileo http://download.eclipse.org/releases/galileo

VE http://download.eclipse.org/tools/ve/updates/1.4/
Plugin Web Tool Platforms (WTP).
- Parte de la distribución Europa. Descargar con el update manager del repositorio
WTPupdates.
My Marketplace Update Repo http://portlet-eclipse.sourceforge.net/update
Es necesario crear un nuevo proyecto no sólo para desarrollar un nuevo programa
de Java, sino para editar también archivos ya existentes (como por ejemplo, un
programa ".java" almacenado en un diskette). Para crear un nuevo proyecto,
seleccione en la línea de menús principal "File > New > Project...". También es
posible seleccionar "New > Project..." haciendo clic derecho en cualquier parte una
vista de Eclipse (como por ejemplo, el Package Explorer o el ResourceNavigator).
Hay varios tipos de proyectos de Eclipse que pueden ser creados:
• Para crear o editar programas Java, un "Java Project" debería ser creado.
Nótese que dentro de un proyecto de Java también puede almacenarse
toda la información relacionada con el proyecto (la cual no tiene por qué
reducirse estrictamente a código fuente, sino que también puede contener
documentación y otros archivos relacionados).
• Los "Simple Project" sólo deberían crearse para almacenar documentos y
otros archivos, pero no código Java que se desee compilar. Por ello,
siempre que se creen archivos ".java" sería recomendable crear un "Java
Project".
• Los "Plug-in Development Project" se usan para añadir nuevos módulos y
funciones al entorno Eclipse. Estos proyectos sólo son necesarios si se es
un desarrollador de Eclipse.
• Los proyectos de "EMF" se utilizan para crear modelos de análisis y diseño.
Puesto que este tutorial se centra en utilizar Eclipse para programar en Java,
escogeremos crear un nuevo "Java Project" seleccionando "Java > Java Project"
y haciendo clic en el botón "Next>" del asistente de creación.
Tras esto, debe especificarse un nuevo nombre para el proyecto. Los proyectos
profesionales se nombran utilizando nombres de dominio dados la vuelta para
evitar posibles conflictos de nombrado. Sin embargo, para un proyecto de uso
interno cualquier nombre descriptivo será suficiente. En este ejemplo, se ha
llamado al nuevo proyecto "Eclipse Tutorial".
Si se usa el directorio por defecto, los archivos del proyecto se almacenarán en el
directorio "[DirectorioDeInstalación]\workspace\[NombreProyecto]". También es
posible especificar un directorio diferente en el que guardar dichos contenidos.
Pese a que en este punto es ya posible terminar la creación del nuevo proyecto
haciendo clic en el botón "Finish", es recomendable pulsar de nuevo el botón
"Next>" para definir explícitamente de esta manera una carpeta fuente para los
archivos ".java" desde el principio. Las carpetas fuente ("Source Folders")
almacenan los archivos de código fuente de Java (.java), de manera que Eclipse
sepa donde encontrarlos y pueda realizar la compilación automática de los
mismos cada vez que un archivo sea guardado.
Para crear dicha carpeta fuente seleccione la pestaña de "Source" y pulse el botón
"Add Folder...". Seleccione el proyecto recientemente creado y pulse el botón
"Create New Folder". Un buen nombre para esta carpeta fuente podría ser
sencillamente "src". Tras especificar dicho nombre, pulse "Ok". A la pregunta de si
desea actualizar la carpeta de salida de archivos compilados, debería responder
afirmativamente. De este modo, los archivos ".class" que resulten de la
compilación de los ".java" almacenados en la carpeta fuente irán a parar a la
carpeta "\bin". Pulse el botón "Finish" para terminar el proceso de creación del
nuevo proyecto. Si se nos pregunta si deseamos pasar a la perspectiva de Java,
deberíamos responder afirmativamente.
Una vez que se ha creado un nuevo proyecto, es hora de aprender cómo crear los
diversos elementos de Java. Para seguir los pasos que se exponen a continuación
es necesario cambiar a la "Perspectiva Java" (si no se ha hecho ya) seleccionando
"Window>Perspectives> Java". La perspectiva de Java contiene las vistas y
editores más útiles a la hora de crear nuevos programas en Java.
Haciendo clic derecho en la carpeta fuente recientemente creada (por ejemplo,
"src") dentro de la vista del Package Explorer, aparecerá un menú contextual.
Seleccionando "New >" en dicho menú se mostrará una lista con los diversos
elementos de Java que pueden ser creados.
Algunos de dichos elementos pueden ser creados también realizando clic sobre
los iconos del menú de la parte superior de la pantalla.
Las clases de Java son los archivos ".java" que contienen el código fuente y que
serán posteriormente compilados en archivos ".class". Estos archivos Java tienen
que ser almacenados dentro de la carpeta fuente recientemente creada (por
ejemplo, "src"). Pulse "New >Class" para abrir la ventana de creación de clases.
1.5.- Ficheros de apoyo
1.5.1.- Fichero Objetos.java
packagehola;
import java.io.*;
classPunto {
publicint x = 0;
publicint y = 0;
publicPunto(int x, int y) {
this.x = x;
this.y = y;
}
}
classRectangulo {
protected Punto origen;
protectedintancho = 0;
protectedint alto = 0;
private static String nombreClase ="Rectangulo";
publicRectangulo(intorigenx, intorigeny, intancho, int alto){
origen=new Punto(origenx, origeny);
this.ancho=ancho; this.alto=alto;
}
publicRectangulo(Punto p, int ancho, int alto){
origen= p;
this.ancho=ancho; this.alto=alto;
}
publicRectangulo(int ancho, int alto){
origen= new Punto(0,0);
this.ancho=ancho; this.alto=alto;
}
publicRectangulo(){
origen= new Punto(0,0);
this.ancho=0; this.alto=0;
}
publicintancho(){
returnancho;
}
publicint alto(){
return alto;
}
publicint area(){
return (ancho*alto);
}
public void mover(intarriba, intderecha){
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(){
returnnombreClase;
}
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
classRectanguloColorextendsRectangulo {
//EJERCICIO: ...
publicStringtoString() {
//EJERCICIO: Sobrecargue este método para que incluya en el String también el
color
}
}
classCuadradoColorextendsRectanguloColor {
publicCuadradoColor(Punto p, int lado, int color){
super(p,lado,lado,color);
}
}
public class Objetos{
staticRectangulo R1 = new Rectangulo(1,1,7,8);
staticRectangulo R2 = new Rectangulo(new Punto(2,2),7,8);
staticRectangulo R3 ;
staticRectanguloColor RC;
staticCuadradoColor 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
//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
packagehola;
importjava.text.*;
importjava.util.*;
classReloj extends Thread {
intcuenta=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 (inti = 1; i<= cuenta; i++) {
//EJERCICIO: Provoque un retraso de 1000 milisegundos
}
System.out.println(getName() + "Riiinnnng!!!");
}
}
public class Relojes {
public static void main(String[] args){
//EJERCICIO: Cree dos instancias de la clase Reloj
}
}
1.5.3.-Fichero CountFile.java
packagehola;
import java.io.*;
classCountFile {
public static void main(String[] args)
throwsjava.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
packagehola;
import java.io.*;
classCopyFile {
public static void main(String[] args)
throwsjava.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");
}
}
}
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)
BufferedReaderstdIn = new BufferedReader( new InputStreamReader(System.in));
PrintWriterstdOut = 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
//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(
newInputStreamReader(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)
packagehola;
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
//EJERCICIO: Instancie un objeto de tipo DataOutputStream para escribir
// en el fichero "invoice1.txt"
DataOutputStreamout =
//EJERCICIO: Instancie un objeto de tipo DataInputStream para leer
// delfichero "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 bucleparaescribir
for (inti = 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){};
}
}