3URJUDPDFLyQ -DYD

3UiFWLFD
3URJUDPDFLyQ-DYD
,QIRUPiWLFD&XUVR3UiFWLFDQž
SiJLQD
Ë1',&(
35È&7,&$1° 1.1
1.2
1.3
1.4
1.5
EJERCICIO 1: LEER UNA LÍNEA DE UNA SOLA VEZ Y PARTIRLA EN PALABRAS ......................................................2
EJERCICIO 2: ORDENAR NUMEROS PASADOS POR EL TECLADO .............................................................................5
EJERCICIO 3: GENERAR NUMEROS ALEATORIOS Y ORDENARLOS SEGÚN EL USUARIO...........................................6
EJERCICIO 4: MI PRIMERA CLASE .........................................................................................................................7
EJERCICIO 5: CLASE RECT ...................................................................................................................................8
35È&7,&$1°
En esta práctica vamos a realizar los ejercicios al igual que en la práctica pasada, es decir que se te
dará el código fuente para que aprendas a familiarizarte con las funciones y clases de Java, así como
con los entornos de desarrollo.
Ahora ya no vamos a utilizar la consola de MS-DOS para escribir y ejecutar los programas.
Daremos un paso más: vamos a utilizar el IDE -%XLOGHU)RXQGDWLRQ, un entorno de desarrollo
para -DYD, del que ya hemos hablado en su día, el cual es de libre distribución.
Deberás de crear un directorio en el cual vas a trabajar con tus programas, por ejemplo
*?,QIR?3UDF.
(-(5&,&,2/((581$/Ë1($'(81$62/$9(=<3$57,5/$(13$/$%5$6
Primero debes crear un proyecto nuevo con el JBuilder, para lo cual debes ir al menú )LOH!1HZ
3URMHFW (como se muestra en la Figura 1):
Figura 1
A continuación aparecerá la ventana de la Figura 2. Sólo hay dos cosas que debes cambiar
de lo que te pone por defecto el -%XLOGHU:
•
En la etiqueta 3URMHFW1DPH deberás colocar el nombre del projecto a generar, que en
este caso es (MHU.
•
En la etiqueta 5RRW3DWK deberás colocar el directorio donde vas a almacenar tu projecto,
que en este caso puede ser *?,QIR.
Una vez que has colocado estos parámetros, puedes darle al botón )LQLVK directamente, asi
te va a generar algunas cosas por defecto que no tienen importancia, por ahora.
Si miras ahora en tu directorio *?,QIR podrás ver que -%XLOGHU te ha generado dentro otro
subdirectorio: (MHU. Si miras dentro de Ejer1, podrás ver dos ficheros importantes:
•
Ejer1.jpr: fichero del proyecto
•
Ejer1.html: fichero para hacer tu página Web que llame a tu applet.
,QIRUPiWLFD&XUVR3UiFWLFDQž
SiJLQD
Figura 2
Debes tener el proyecto generado como en la Figura 3.
Hasta ahora todo bien, si tienes todas las cosas que te he mencionado anteriormente; caso
contrario debes volver al principio e intentarlo nuevamente. Si por segunda vez no lo has logrado,
llama al ayudante de la asignatura para que te de una mano.
Figura 3
Ahora falta lo más importante: crear el fichero (MHUMDYD, que será donde esté nuestro
código de la aplicación, para lo cual debes seguir los siguientes pasos:
•
)LOH!1HZ&ODVV: Saldrá una ventana nueva como la que puedes ver en la Figura 4.
•
En la etiqueta Package borra el contenido.
,QIRUPiWLFD&XUVR3UiFWLFDQž
SiJLQD
•
En la etiqueta Class Name debes poner el nombre de la clase a generar: Ejer1
•
Como es la clase principal, debes activar la casilla *HQHUDWHPDLQPHWKRG, para que esta
clase sea la que tenga el método PDLQ de la aplicación.
•
Finalmente, ya puedes darle al botón OK. Verás cómo el JBuilder te ha creado el fichero
Ejer1.java (el cual lo ha abierto automáticamente).
•
Ya puedes empezar a escribir el código de la aplicación.
$FWLYDU
Figura 4
A continuación se presenta el código del programa. La clase principal que se utiliza y que
hace la separación de las palabras que hay en una cadena de string’s es 6WULQJ7RNHQL]HUVeamos
su utilización y dos de sus métodos: KDV0RUH(OHPHQWV y QH[W7RNHQ.
ILFKHUR(MHUMDYD
import java.io.*;
import java.util.StringTokenizer;
FODVV Ejer1 {
SXEOLFVWDWLFYRLG main(String [] args) throws IOException {
System.out.print("Hola, Como te llamas? ");
BufferedReader teclado = new BufferedReader(
new InputStreamReader(System.in));
String nombre="";
,QLFLDOL]DPRVODYDULDEOH
nombre = teclado.readLine();
/HHUWHFODGRKDVWDHQFRQWUDU³(QWHU´
System.out.println("Hola " + nombre + ". Como estas?"+’\n’);
3DUDSDUWLUODOtQHDHQSDODEUDV
StringTokenizer st = new StringTokenizer(nombre);
FUHDUHOREMHWR
,QIRUPiWLFD&XUVR3UiFWLFDQž
String token;
while (st.hasMoreElements()) {
token = st.nextToken();
System.out.println(token);
}
} ILQGHPDLQ
SiJLQD
YDULDEOHWHPSRUDO
REWLHQHHOHOHPHQWR
,PSULPH
} ILQGHODFODVH(MHU
Este programa lee toda una cadena de caracteres que escribas por el teclado y la parte en
palabras (sólo reconoce como palabras independientes las separadas por un espacio).
Recuerda que la clase ya la tienes generada, por lo tanto sólo tienes que copiar lo que hay en
la función PDLQ y algunas cosas que falten, como los LPSRUW iniciales.
Si ya has terminado de escribir el programa, puedes compilarlo desde la misma herramienta
de desarrollo JBuilder o desde la consola del MS-DOS:
•
-%XLOGHU: desde el menú 3URMHFW!0DNH(MHU
•
Desde la FRQVROD: debes situarte en el directorio donde esté el fichero (MHUMDYD , en
este caso (MHUVUF, y teclear:
!MDYDF(MHUMDYD
Si ya has compilado y no hay error alguno, debes ejecutarlo desde la consola del MS-DOS,
para lo cual primero debes situarte en el directorio de trabajo:
•
Si has compilado con -%XLOGHU, el fichero compilado (MHUFODVV estará en el
subdirectorio (MHUFODVVHV, que es el directorio por defecto donde el -%XLOGHU pone los
ficheros compilados.
•
Si has compilado con la consola MS-DOS, verifica que estás en el directorio donde esté
el fichero (MHUFODVV.
Si ya has localizado el fichero, puedes ejecutarlo de la siguiente manera:
!MDYD(MHU
(-(5&,&,225'(1$5180(5263$6$'26325(/7(&/$'2
En este ejercicio se van a ordenar todos los números que pases por el teclado de menor a mayor.
Vas a aprender a utilizar los métodos o funciones de una clase, así como las variables miembro de
ésta. También aprenderás a trabajar con arreglos (DUUD\V) para lo cual utilizaremos el operador QHZ
El nombre de la clase es (MHU. Queda a tu criterio si utilizas el JBuilder o lo haces desde la
consola del MS-DOS, con un editor de texto cualquiera.
ILFKHUR(MHUMDYD
import java.io.*;
import java.util.StringTokenizer;
FODVV (MHU {
// variables miembro de la clase Ejer2
int Numero;
int[] Datos;
//array para almacenar los numeros
SXEOLF(MHU{
//constructor de la clase
,QIRUPiWLFD&XUVR3UiFWLFDQž
SiJLQD
}
SXEOLFVWDWLFYRLGPDLQ(String [] args) throws IOException {
String cadena="";
//Inicializamos la variable
System.out.print("Dar los numeros a ordenar: ");
BufferedReader teclado = new BufferedReader(
new InputStreamReader(System.in));
cadena = teclado.readLine();
//Lee teclado hasta encontrar “Enter”
System.out.println("La cadena dada es: "+cadena);
3DUDSDUWLUODOtQHDHQSDODEUDV
StringTokenizer st = new StringTokenizer(cadena);
int num = st.countTokens();
REWHQHPRVHOQXPHURGH7RNHQV
Ejer2 obj1 = new Ejer2();
obj1.Numero = num;
obj1.Datos = new int[num];
String sTmp;
int count=0;
while (st.hasMoreElements()) {
sTmp = st.nextToken();
FUHDUXQREMHWRGHODFODVH
UHVHUYDPRVPHPRULDSDUD1QXPHURV
FUHDUXQDYDULDEOHWHPSRUDO
KDFHUORWDPELpQFRQ)RU
REWLHQHORVHOHPHQWRVR7RNHQV
3DVDPRVDHQWHURVORVVWULQJV
obj1.Datos[count++] = Integer.parseInt(sTmp);
}
//Ahora los ordenaremos de menor a mayor
obj1.Ordena();
//llamamos a la funcion ordena
} ILQGHPDLQ
SXEOLFYRLG Ordena(){
System.out.println("\nLos numeros sin ordenar son: ");
for (int i=0;i<Numero;i++)
System.out.println("Num: "+i+" valor: "+Datos[i]);
//usaremos un sistema de ordenamiento sencillo
for (int i=0;i < Numero-1;i++) {
for (int j=i+1;j<Numero;j++) {
if ( Datos[i] > Datos[j]) {
// hay que permutar los valores
int tmp = Datos[j];
Datos[j] = Datos[i];
Datos[i] = tmp;
}
}
}
System.out.println("\nLos numeros ordenados de menor a mayor
for (int i=0;i<Numero;i++)
System.out.println("Num: "+i+" valor: "+Datos[i]);
son: ");
}
} ILQGHODFODVH(MHU
(-(5&,&,2*(1(5$5180(526$/($725,26<25'(1$5/266(*Ò1(/868$5,2
Este ejercicio es un poco distinto al anterior, ya que en este caso no te voy a dar el código fuente.
Ha llegado el momento en que empieces tú solo a hacerlo.
,QIRUPiWLFD&XUVR3UiFWLFDQž
SiJLQD
El programa, que debes llamarlo (MHUMDYD, tiene que generar de forma aleatoria 50
números reales, comprendidos entre 0 y 1000 y ordenarlos de forma ascendente o descendente,
según lo decida el usuario, para lo cual le debes pedir por teclado al usuario que ingrese el tipo de
orden. Utilizar el sencillo método de ordenación que usamos en el ejemplo anterior. $GHODQWH…
(-(5&,&,20,35,0(5$&/$6(
Ha llegado el momento de que empieces a generar tus propias clases. Este ejercicio te introduce en
las clases de forma sencilla.
La clase principal del ejercicio (la que tiene el método PDLQ) es la (MHU. Por lo tanto
debes hacer un fichero denominado (MHUMDYD, el cual va a albergar a dicha clase.
Tu clase nueva será la clase 3XQWR, la cual debes generar en otro fichero denominado
3XQWRMDYD. Esta clase tendrá dos variables miembro, x e y, y sirve para almacenar coordenadas por
ejemplo. Verás que hay dos formas de acceder a las variables:
•
Directamente, através del objeto ó
•
A través de un método creado para ello: getX() y getY().
También puedes ver que la clase tiene dos constructores, al cual se accede según los
parámetros que se le pasen.
Escribe los dos ficheros (Ejer4.java y Punto.java), compílalos y ejecútalos desde la consola
del MD-DOS así:
!MDYD(MHU
Si no has usado el JBuilder, los puedes compilar desde la consola del MS_DOS de la
siguiente manera:
!MDYDF(MHUMDYD3XQWRMDYD
Si los compilas por separado te va a dar un error al compilar Ejer4.java, ya que no
encontrará la nueva clase Punto creada.
Al final del código, en la clase principal, puedes ver que utilizamos una clase de Java que
ya existe para tales fines: la clase 3RLQW.
// Mi primera clase
ILFKHUR(MHUMDYD
import java.awt.Point;
SXEOLFFODVV Ejer4 {
SXEOLFVWDWLFYRLGmain( String[] args) {
int x,y;
System.out.println("Mi primera clase Propia: Punto");
Punto p1 = new Punto();
x = p1.x;
XQDIRUPDGHREWHQHUORVYDORUHV
y = p1.y;
System.out.println("Valores: x= "+x+" y= "+y);
SRQHUYDORUHVD[\\GHS
p1.x = 10;
,QIRUPiWLFD&XUVR3UiFWLFDQž
SiJLQD
p1.y = 15;
x = p1.getX();
2WUDIRUPDGHREWHQHUORVYDORUHV
y = p1.getY();
XVDQGRODVIXQFLRQHVPLHPEUR
System.out.println("Valores: x= "+x+" y= "+y);
FUHDFLRQGHRWURREMHWRGHODFODVH3XQWRXVDQGRRWURFRQVWUXFWRU
System.out.println("\nCreacion de otro objeto de la clase Punto");
System.out.println("usando otro constructor");
Punto p2 = new Punto(50,75);
System.out.println("1 Metodo: x= "+x+" y= "+y);
System.out.println("2 Metodo: x= "+p2.getX()+" y= "+p2.getY());
DKRUDTXH\DKDVYLVWRFRPRVHFUHDXQDFODVH
XVDUHPRVODFODVH3RLQWGH-DYD
SDUDHVWRVHQHFHVLWDDJUHJDUODVJWHOLQHDDOLQLFLR
LPSRUWMDYDDZW3RLQW
Point p3 = new Point(12,7);
System.out.println("Usaremos la clase Point de Java");
System.out.println("valores: x= "+p3.x+" y= "+p3.y);
}
} ILQGHPDLQ
ILQGHODFODVH(MHU
ILFKHUR3XQWRMDYD
FODVV3XQWR {
int x,y;
SXEOLF Punto(){
x=0;
y=0;
}
YDULDEOHVPLHPEURGHODFODVH3XQWR
FRQVWUXFWRUSRUGHIHFWRSRQHYDULDEOHVD
SXEOLF Punto(int tx, int ty){ RWURFRQVWUXFWRUTXHLQLFLDOL]D
x=tx;
y=ty;
}
SXEOLFLQW getX(){
return x;
}
}
PHWRGRTXHGHYXHOYHHOYDORUGH[
SXEOLFLQW getY(){
PHWRGRTXHGHYXHOYHHOYDORUGH\
return y;
}
ILQGHODFODVH3XQWR
(-(5&,&,2&/$6(5(&7
Si te ha sobrado tiempo, trata de crear una clase Rect, que tenga las coordenadas de dibujo de un
rectángulo: punto inicial (x,y) y ancho y alto (w,h). Dicha clase debe tener un constructor que
permita pasarle una clase tipo Punto (como la creada anteriormente) para el punto inicial. 6XHUWH«