PROGRAMACION EN LENGUAJE´ JAVArobertominguez.altervista.org/files/CursoJAVA.pdf · libro JAVA TM Un lenguaje de programaci´on en Internet escrito por E. Castillo, A. Cobo, P. G´omez,

UNIVERSIDAD DE CASTILLA-LA MANCHA

ESCUELA TECNICA SUPERIOR DE INGENIEROSDE CAMINOS, CANALES Y PUERTOS

PROGRAMACION EN LENGUAJE

JAVA

Roberto Mınguez y Cristina Solares

CIUDAD REAL, 2006EDITORIAL UCLM

i

ii

Estos apuntes has sido realizados con LATEX, y reproducidos a partir de originales sumin-istrados por Cristina Solares. Notese que la mayor parte del material ha sido extraıda dellibro JAVA TM Un lenguaje de programacion en Internet escrito por E. Castillo, A. Cobo,P. Gomez, y C. Solares, adaptando los contenidos al programa propuesto de la asignatura.

@ Roberto Mınguez y Cristina SolaresCiudad Real, Ciudad Real, Espana, 2006

Ninguna parte de estos apuntes puede ser reproducida, grabada en sistema de almace-namiento o transmitida en forma alguna ni por cualquier procedimiento, ya sea electronico,mecanico, reprografico, magnetico o cualquier otro, sin autorizacion previa y por escrito delos autores.

El codigo penal castiga con multas de hasta 18.000 euros y penas de hasta prision menora quien intencionadamente reproduzca, plagie, distribuya o comunique publicamente unaobra literaria, artıstica o cientıfica, sin la autorizacion de los titulares de los correspondien-tes derechos de propiedad intelectual.

Indice general

1. Introduccion 11.1. Internet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.2. ¿Que es Java? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21.3. La plataforma Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41.4. Direcciones de interes en internet . . . . . . . . . . . . . . . . . . . . . . . . 4

2. PROGRAMACION ORIENTADA A OBJETOS 52.1. Objetos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52.2. Clases . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62.3. Herencia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72.4. Creacion de Clases . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82.5. Creacion de Objetos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132.6. Utilizacion de Objetos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152.7. Variables de instancia y de clase . . . . . . . . . . . . . . . . . . . . . . . . 162.8. Metodos de instancia y de clase . . . . . . . . . . . . . . . . . . . . . . . . . 172.9. Mensajes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182.10. Liberacion de memoria de objetos no utilizados . . . . . . . . . . . . . . . . 18

Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

3. EL LENGUAJE JAVA 243.1. Un ejemplo: Los numeros complejos . . . . . . . . . . . . . . . . . . . . . . 243.2. Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30

3.2.1. Nombre de una variable . . . . . . . . . . . . . . . . . . . . . . . . . 313.2.2. Tipos de datos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 323.2.3. Campo de accion de una variable . . . . . . . . . . . . . . . . . . . . 343.2.4. Iniciacion de variables . . . . . . . . . . . . . . . . . . . . . . . . . . 35

3.3. Constantes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 353.4. Comentarios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 363.5. Operadores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36

3.5.1. Operadores aritmeticos . . . . . . . . . . . . . . . . . . . . . . . . . 373.5.2. Operadores relacionales y condicionales . . . . . . . . . . . . . . . . 383.5.3. Operadores de asignacion . . . . . . . . . . . . . . . . . . . . . . . . 383.5.4. El operador cast . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39

3.6. Matrices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40

iii

INDICE GENERAL iv

3.7. Cadenas de caracteres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 413.8. Expresiones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41

3.8.1. Expresiones numericas . . . . . . . . . . . . . . . . . . . . . . . . . . 423.8.2. Expresiones booleanas . . . . . . . . . . . . . . . . . . . . . . . . . . 42

3.9. Sentencias y bloques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 433.10. Control de flujo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44

3.10.1. Sentencia if-else . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 443.10.2. Sentencia else-if . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 463.10.3. Sentencia switch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 543.10.4. Ciclo while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 603.10.5. Ciclo do-while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 643.10.6. Ciclo for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 653.10.7. Sentencias para manejar excepciones . . . . . . . . . . . . . . . . . . 733.10.8. Sentencias de bifurcacion . . . . . . . . . . . . . . . . . . . . . . . . 73

3.11. El metodo main . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 743.11.1. Llamada al metodo main() . . . . . . . . . . . . . . . . . . . . . . . 753.11.2. Argumentos de la lınea de comandos . . . . . . . . . . . . . . . . . . 76

3.12. Los Paquetes estandar de Java . . . . . . . . . . . . . . . . . . . . . . . . . 803.13. Applets y aplicaciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80

3.13.1. Applets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 813.13.2. Aplicaciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84

3.14. Mas practicas resueltas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87

4. Programa JBuilder 88

A. Examenes Resueltos 99

Bibliografıa 157

Indice 157

Indice de cuadros

3.1. Tipos de datos basicos o variables. . . . . . . . . . . . . . . . . . . . . . . . 333.2. Operadores binarios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 373.3. Lista de operadores unarios . . . . . . . . . . . . . . . . . . . . . . . . . . . 373.4. Lista de operadores relacionales. . . . . . . . . . . . . . . . . . . . . . . . . 383.5. Lista de operadores condicionales. . . . . . . . . . . . . . . . . . . . . . . . 393.6. Lista de operadores de asignacion. . . . . . . . . . . . . . . . . . . . . . . . 393.7. Orden de preferencia de los operadores. . . . . . . . . . . . . . . . . . . . . 43

v

Capıtulo 1

Introduccion

1.1. Internet

Los ultimos anos han constituido una autentica explosion y revolucion de los orde-nadores. La aparicion de la red Internet ha dado lugar a que millones de personas quenunca habıan utilizado el ordenador se hayan lanzado a una utilizacion repentina y masiva,que fundamentalmente se basa en navegar electronicamente a traves de bases de datos, bus-cando informacion de todo tipo, material bibliografico, comunicandose con amigos o gruposde amigos, asociandose a grupos de personas afines que se relacionan electronicamente, etc.

Mediante la red se puede:

Acceder a todo tipo de informacion: (prensa, bibliotecas, grafica, etc.).

Traer todo tipo de software: en forma de programas, juegos, aplicaciones, etc.

Capturar imagenes de todo tipo: (fotografıas, dibujos, etc.).

Traer sonidos: en varios formatos.

Acceder a vıdeos.

etc.

El uso de Internet tiene ventajas e inconvenientes. Entre las ventajas caben destacar lassiguientes:

Capacidad ilimitada de almacenamiento: ya que los servidores se encargan dealmacenar por el.

Ahorro de espacio de almacenamiento: solo hace falta guardar una copia de cadafichero. Se pasa de una copia por usuario a una copia por servidor (unas pocas).

Informacion de los ficheros actualizada independientemente del usuario: loque da lugar a que este pueda usar siempre versiones actualizadas.

Se libera al usuario del problema de las copias de seguridad: limitandoseestos solo a la seguridad de los ficheros propios.

1

CAPITULO 1. INTRODUCCION 2

Actualizacion mucho mas facilmente: pues solo hay que actualizar en los ficherosservidores. Ademas esta actualizacion puede hacerse por verdaderos especialistas, conlo que se evita al usuario muchos problemas.

Software compatible: independiente de la plataforma, sea esta Macintosh, PC com-patible, UNIX, etc.

En cuanto a las desventajas, algunas son:

Necesidad de redes de comunicacion muy potentes: (en cuanto a capacidad yvelocidad).

Alto coste de acceso a la informacion: (modems, lıneas telefonicas, pago decuotas, etc.)

Problemas de seguridad: Hacen falta metodos que garanticen la seguridad de nue-stro sistema informatico.

No existe de momento un lenguaje de programacion general y especıficopara aplicaciones de Internet: Hoy las aplicaciones se desarrollan en una serie delenguajes no compatibles (C, C++, Pascal, ADA, etc.).

Aplicaciones existentes no son compatibles: no son portables de un sistema aotro.

El desarrollo de aplicaciones verdaderamente interactivas en Internet noes facil con los medios disponibles.

El trabajo es fuertemente dependiente de los diferentes servidores y de lasvıas de comunicacion.

1.2. ¿Que es Java?

Java es un lenguaje de programacion:

Simple: es casi identico al C y C++. Todos los programadores de estos dos lenguajespueden convertirse de la noche a la manana, si ası lo desean, en programadores deJava.

Multiplataforma: Un sueno de todo programador es escribir un programa en unaplataforma determinada y que despues funcione en todas. Java es un lenguaje multi-plataforma, todo programa se puede ver bajo las plataformas: Windows, Macintosh,Unix, sin necesidad de hacer cambio alguno.

Se eliminan los tres problemas mas importantes de C y C++:

1. El uso de punteros: en Java se han eliminado estos, con lo que los problemassubyacentes han desaparecido.


2. La gestion de memoria: la liberacion de memoria en Java se hace de modoautomatico.

3. El control de acceso a una matriz: el lenguaje Java lleva control del tamanode la matriz y no permite salirse del mismo.

Orientado a objeto, es decir, trabaja con objetos y con metodos que actuan sobreellos. Las ventajas mas importantes de la programacion orientada al objeto son:

1. Los programas son mas faciles de modificar2. Los programas son mas faciles de mantener3. El codigo utilizado es mucho mas portable y reutilizable4. La estructura de los programas se entiende mejor

Multitarea.

Prestaciones multimedia: texto, graficos, sonido, animaciones, etc.

Seguro

Facilmente accesible: se puede acceder gratuıtamente al sistema Java de SUN atraves de Internet (http://www.sun.com) y traerse todo el material necesario paratrabajar con Java:

1. Aprender a programar en Java, pues existen cursos interactivos gratuitos y com-pletos que explican, con todo detalle y paso a paso, como programar en Java.

2. Interpretar programas Java, pues hay ya varios programas de acceso a Internetque incorporan un interprete de Java, como Netscape 3.0, por ejemplo.

3. Compilar programas Java, pues puede uno traerse, tambien vıa Internet, todo elsistema de programacion Java o comprar otros compiladores.

Otra ventaja importante de Java es su utilizacion en paginas Web, estas como es sabidocontienen muchos elementos tales como:

Graficos

Texto

Enlaces a otras paginas

Tablas

Sonido

Animaciones

etc.

Sin embargo, hasta hace poco tiempo no incorporaban aplicaciones. Con el Java, es yaposible incorporar aplicaciones o APPLETS, que no son mas que programas que residiendoen un servidor remoto son ejecutados a traves de la red mediante un interprete utilizandolos recursos del cliente.


1.3. La plataforma Java

La plataforma Java tiene dos componentes:

Java Virtual Machine (Java VM)

Java Application Programming Interface (Java API)

Todo interprete de codigo Java compilado (JDK, navegador Web,...) es una implementacionde la Java VM.

La Java API es un conjunto de paquetes que pueden ser utilizados por todo programaJava:

paquete java.applet

paquete java.awt

paquete java.awt.event

paquete java.io

paquete java.math

paquete java.lang

1.4. Direcciones de interes en internet

Algunas direcciones de interes son:

http://www.sun.comDireccion de la empresa Sun Microsystems, desarrolladora de Java.

http://www.javasoft.comLugar oficial de informacion sobre el lenguaje Java.

http://java.sun.com/docs/books/tutorial/index.htmlTutorial interactivo de introduccion a la programacion en Java.

http://www.javaworld.comRevista electronica sobre Java.

Capıtulo 2

PROGRAMACION ORIENTADAA OBJETOS

2.1. Objetos

Los objetos constituyen el concepto fundamental para entender la tecnologıa que seconoce como tecnologıa orientada a objetos. Si miramos a nuestro alrededor podemos vermuchos ejemplos de objetos del mundo real: la mesa de estudio, el ordenador, el bolıgrafo,etc. Todos estos objetos del mundo real tienen dos caracterısticas comunes: todos ellostienen un estado y un comportamiento. Los objetos de un programa se modelan de maneraanaloga. Un objeto mantiene su estado en forma de variables miembros e implementa sucomportamiento mediante metodos. Los metodos permiten crear un codigo que puede serllamado desde fuera del objeto y pueden tomar argumentos y, opcionalmente, devolver unvalor.

Definicion 2.1 (Objeto). Un objeto es un conjunto constituido por una o varias variablesy, opcionalmente, por metodos.

Todo objeto del mundo real se puede representar en un programa utilizando objetos. Todoaquello que el objeto conoce (estado) se expresa por sus variables, y todo lo que puede hacer(comportamiento) se expresa por sus metodos. Estas variables y metodos se conocen comovariables miembros y metodos. Dentro de un objeto las variables constituyen el nucleo delmismo y los metodos rodean dicho nucleo aislandolo de otros objetos del programa. Estefenomeno de colocar las variables de los objetos bajo la proteccion de sus metodos se conocecomo encapsulacion.

Ejemplo ilustrativo 2.1 (Objeto automovil). Un automovil puede ser consideradoun objeto. Ası por ejemplo, mi automovil en un determinado momento puede tener unascaracterısticas definidas por sus variables, y ademas, puede hacer las acciones definidas porsus metodos:

1. Variables: Definen el estado actual de mi coche:

a) Modelo: “Ford”.

5

CAPITULO 2. PROGRAMACION ORIENTADA A OBJETOS 6

b) Cilindrada: 1900 c.c.

c) Velocidad 120 km/h.

d) Marcha 5a.

e) Direccion norte.

2. Metodos: Acciones que puede realizar en ese momento:

a) Acelerar.

b) Frenar.

c) Parar.

d) Cambiar de marcha.

e) Girar a la derecha.

f ) Girar a la izquierda.

g) Continuar recto.

2.2. Clases

En el mundo real, se encuentran muchos objetos del mismo tipo. Por ejemplo, mi or-denador es uno de todos los ordenadores del mundo. Utilizando la terminologıa orientadaa objetos, mi ordenador es un miembro o ejemplar de la clase de objetos conocidos comoordenadores. Objetos similares se reproducen como objetos del mismo tipo, por lo que sepuede crear un prototipo para tales objetos. Estos prototipos son lo que se conoce comoclases.

Definicion 2.2 (Clase). Una clase es un prototipo que define las variables y los metodoscomunes a todos los objetos de un cierto tipo.

Cuando se crea un ejemplar de una clase, las variables declaradas por la clase son almace-nadas en memoria. Una vez creadas, se pueden utilizar los metodos miembros de la clasepara asignar valores a las variables.

Ejemplo ilustrativo 2.2 (Clase automovil). Para todos los automoviles que existanpuedo crear un prototipo para definir sus variables y metodos comunes:

1. Variables:

a) Modelo: “Ford”, “Renault”, “Honda”, “Mercedes”, etc.

b) Cilindrada: 1200 c.c, 1800 c.c, 1900 c.c, 2000 c.c, etc.

c) Velocidad en km/h.

d) Marcha.

e) Direccion.


2. Metodos:

a) Acelerar.

b) Frenar.

c) Parar.

d) Cambiar de marcha.

e) Girar a la derecha.

f ) Girar a la izquierda.

g) Continuar recto.

2.3. Herencia

Los objetos se definen como miembros de clases. Conociendo la clase de un objeto sepuede tener mucha informacion sobre el mismo. En programacion orientada a objetos sepueden definir clases (subclases) en terminos de otras clases (superclases). Toda subclasehereda el estado (en la forma de declaracion de variables) y los metodos de la superclase.Sin embargo, las subclases no estan limitadas al estado y comportamiento de su superclase.Las subclases pueden anadir nuevas variables miembros y nuevos metodos a los heredadosde la superclase y dar implementaciones particulares para los metodos heredados anulandola definicion original de los metodos dada por la superclase.

Ejemplo ilustrativo 2.3 (Clase camion). En el Ejemplo Ilustrativo 2.2 se define la claseautomovil con las variables y metodos comunes a todos los automoviles. Todas las variablesy metodos de la clase automovil son perfectamente validas para la definicion de un camion,pero hay determinadas caracterısticas importantes a considerar en un camion que no estanincluidas en la clase automovil, por ejemplo, el peso maximo autorizado (PMA), la tara, oacciones como la carga y la descarga. Ası pues es posible crear una subclase camion a partirde la clase automovil que herede todas sus caracterısticas de estado y comportamiento peroque ademas incluya otras como:

1. Variables:

a) PMA: peso maximo autorizado.

b) Tara.

2. Metodos:

a) Cargar.

b) Descargar.

c) Se puede redefinir el metodo frenar, por ejemplo.


2.4. Creacion de Clases

Una clase es un prototipo que se puede utilizar para crear objetos. La implementacionde una clase consta de dos componentes: la declaracion de la clase y el cuerpo de la clase.

DeclaracionClase {CuerpoClase

}

En la declaracion de una clase debe aparecer, como mınimo, la palabra class y el nombrede la clase que se esta definiendo.

class NombreClase {...

}

Los nombres de las clases, por convenio, comienzan por mayuscula. En la declaracion deuna clase se puede:

Declarar cual es la superclase de la clase.

Listar las interfases implementadas por la clase.

Declarar si la clase es publica, abstracta o final.

Comentario 2.1 Desde el punto de vista practico, en este curso solo se trabajara conclases publicas y finales.

En Java, toda clase tiene una superclase. Si no especificamos una superclase para la clase,se supone que es la clase Object (declarada en el paquete java.lang). Para especificar lasuperclase explıcitamente, se pone la palabra extends y el nombre de la superclase entre elnombre de la clase que se esta declarando y la llave que abre el cuerpo de la misma:

class NombreClase extends NombreSuperClase {...

}

Cuando se declara una clase, se pueden especificar tambien la lista de interfases implemen-tadas por la clase. Una interfase declara un conjunto de metodos y constantes sin especificarla implementacion para los metodos. Cuando una clase demanda implementar una inter-fase, esta declarando que se da una implementacion para todos los metodos declarados enla interfase. Para declarar que la clase implementa una o mas interfases se utiliza la palabraclave implements. Por convencion, la clausula implements sigue a extends si esta existe.

Si se pone antes de class la palabra final, se declara que la clase es final, es decir, queno pueden crearse subclases de ella:

final class NombreClase {...

}


El cuerpo de una clase contiene dos secciones diferentes: declaracion de variables miem-bros y definicion de los metodos asociados a dicha clase. Las variables definen el estado deun objeto definido por esta clase y los metodos corresponden a los mensajes que pueden serenviados a un objeto. Generalmente, se declaran las variables miembros de la clase primeroy luego las declaraciones de los metodos y su implementacion:

DeclaracionClase {declaracionVariablesMiembro

...declaracionMetodos

...}

Como mınimo, en la declaracion de una variable miembro aparecen dos componentes: eltipo de dato de la variable y su nombre.

tipo variableNombre;

Tambien se pueden especificar que objetos tienen acceso a dicha variable, mediante public,protected, etc. o si se trata de una constante. La declaracion de una variable miembro serealiza en el cuerpo de la clase pero no dentro de un metodo, y, por convenio, su nombrecomienza por minuscula. No se pueden declarar mas de una variable miembro con el mismonombre en la misma clase, sin embargo, puede tener el mismo nombre que un metodo. Paracrear una variable miembro constante se utiliza la palabra final en la declaracion de lavariable. La siguiente clase declara una constante llamada NUM cuyo valor es 2.23.

class Const{final double NUM=2.23;

}

Por convencion, los nombres de las constantes se ponen con letras mayusculas.De manera similar a como se implementa una clase, la implementacion de un metodo

consiste de dos partes: la declaracion y el cuerpo del mismo.

DeclaracionMetodo{CuerpoMetodo;

}

Los metodos declarados dentro de una clase tienen acceso completo a todas las variablesmiembro de dicha clase y pueden acceder a ellas como si estuvieran definidas dentro delmetodo. En la declaracion del metodo ademas del nombre va una cierta informacion, como:

el valor de retorno del metodo (el que devuelve),

el numero y tipo de argumentos requeridos por dicho metodo y

que otras clases y objetos pueden llamar tambien al metodo.


Pero los dos unicos elementos requeridos en la declaracion son el nombre y el tipo dedato devuelto. Si un metodo no devuelve ningun valor, debe declararse como void y sidevuelve un valor debe utilizar la sentencia return para devolverlo.

En Java se permite definir varios metodos con el mismo nombre, estos son diferenciadospor el compilador por el numero y tipo de argumentos pasados en el. Por ejemplo, en laclase Math existen cuatro definiciones del metodo abs, que calcula el valor absoluto de unnumero. Estas se diferencian en el argumento, que puede ser double, float, int o long.Una clase puede redefinir un metodo de su superclase. El nuevo metodo debe tener el mismonombre, tipo de retorno y lista de parametros que el metodo que redefine. No se puedenpasar metodos como argumentos en los metodos. El argumento de un metodo puede tenerel mismo nombre que una de las variables miembros de la clase. En este caso se dice que elargumento oculta a la variable miembro. Argumentos que ocultan variables miembros sonfrecuentemente utilizados en constructores para iniciar una clase. Por ejemplo en la clasesiguiente:

class Persona{float peso,estatura;Color colorpelo;

public Persona(float peso,float estatura,Color colorpelo){this.peso=peso;this.estatura=estatura;this.colorpelo=colorpelo;

}}

los argumentos del constructor ocultan a las variables miembro. Para referirse a la propiaclase, se utiliza la palabra clave this. Si el metodo oculta una variable miembro de susuperclase el metodo puede referirse a ella utilizando la palabra clave super. Lo mismosucede si se redefinen metodos de la superclase. Sea la clase:

class PracticaSuper{int var;void metodo(){var=1;

}}

y su subclase que oculta la variable miembro var y redefine metodo():

class SubPracticaSuper extends PracticaSuper{int var;void metodo(){

var=2;super.metodo();System.out.println(var);System.out.println(super.var);


}}

Primero metodo() asigna a la variable var correspondiente a la subclase el valor 2 y luegoasigna a la version de var de la clase superior el valor 1. Entonces metodo devuelve losvalores de las dos variables con nombre var:

21

En el cuerpo de un metodo se pueden declarar variables para utilizar dentro del metodo.Estas variables son variables locales.

Ejemplo ilustrativo 2.4 (Creacion de la clase automovil). A continuacion se mues-tra el codigo Java para la creacion de la clase automovil que se ha de guardar en un ficherollamado Automovil.java:

/*** Title: Automovil* Description: Mi primera clase tipo automovil* Copyright: Copyright (c) 2005* Company: * @author roberto* @version 1.0*/

public class Automovil {String modelo;int cilindrada;float velocidad;int marcha;String direccion;

public Automovil(String m, int c) {super();modelo=m;cilindrada=c;velocidad=0;marcha=0;direccion = "recto";

}

public Automovil(String m, int c,String dir) {super();modelo=m;cilindrada=c;velocidad=0;marcha=0;direccion = dir;

}


void Acelera (float v){velocidad=velocidad+v;

}

void Frena (float v){velocidad=velocidad-v;

}

void Para (){marcha=0;velocidad=0;

}

void CambiaMarcha (int m){marcha=m;

}

void girarDerecha (){direccion="derecha";

}

void girarIzquierda (){direccion="izquierda";

}

void continuarRecto (){direccion="recto";

}}

Ejemplo ilustrativo 2.5 (Creacion de la clase camion). A continuacion se muestrael codigo Java para la creacion de la clase camion, subclase de la clase automovil, que se hade guardar en un fichero llamado Camion.java:

/*** Title: Camion* Description: Mi primera clase tipo camion* Copyright: Copyright (c) 2005* Company: * @author roberto* @version 1.0*/

public class Camion extends Automovil {float PMA;float PesoCarga;

public Camion(String m,int c,float p) {super(m,c);


PesoCarga=p;}

void Carga (float c){PesoCarga=PesoCarga+c;

}

void Descarga (float c){PesoCarga=PesoCarga-c;

}

void Para (){super.Para();PesoCarga=0;

}

}

2.5. Creacion de Objetos

Antes de proceder con los metodos de creacion de objetos es importante recalcar losiguiente:

Comentario 2.2 Una vez creadas las clases para programar es necesario crear e interac-cionar mediante objetos de las clases, se vio que en Java se pueden trabajar o bien conprogramas independientes o con Applets, en este curso trabajaremos por defecto con progra-mas y para ello todos los objetos se definiran dentro de un metodo llamado main dentro deuna clase llamada Principal cuya creacion es como sigue a continuacion:

/*** Title: Principal* Description: Clase para la ejecucion de los programas Java* Copyright: Copyright (c) 2005* Company: * @author roberto* @version 1.0*/

public class Principal {

public Principal() {}

public static void main(String[] args) {/*Creacion de objetos y manipulacion mediante metodos

*/}


}

La estructura de la clase Principal es la misma para todas las aplicaciones que se em-plearan en este curso.

En Java se crea un objeto creando un ejemplar de una clase. Se puede crear un objetode la forma siguiente:

String str = new String();

Ası se crea un nuevo objeto de la clase String (dicha clase se encuentra en el paquetejava.lang). Con esta declaracion se realizan tres acciones: declaracion, creacion del objetoe iniciacion. Con String str se crea una variable de tipo String cuyo nombre es str, eloperador new crea un nuevo objeto de tipo String y String() inicia el objeto. La declaracionde objetos aparece frecuentemente en la misma lınea que la creacion pero no tiene por queser ası. Como en la declaracion de otras variables, las declaraciones de objetos puedenaparecer solas como:

String str;

Comentario 2.3 Los nombres de las clases, por convenio, comienzan por letra mayuscula.

El operador new crea un nuevo objeto reservando memoria para el. Este operador re-quiere un unico argumento: una llamada a un metodo constructor. Los metodos construc-tores son metodos especiales con los que cuenta cada clase en Java y que son responsablesde la iniciacion de nuevos objetos de ese tipo. El operador new crea el objeto y el constructorlo inicia. Por ejemplo en:

new String({‘h’,‘o’,‘l’,‘a’});

String( {‘h’,‘o’,‘l’,‘a’ }) es una llamada al constructor de la clase String. El oper-ador new devuelve una referencia al nuevo objeto creado. Esta referencia puede ser asignadaa una variable del tipo apropiado.

String cadena = new String({‘h’,‘o’,‘l’,‘a’});

Como ya se ha mencionado las clases contienen metodos constructores para iniciar los ob-jetos. Una clase puede tener varios constructores para realizar diferentes tipos de iniciacionde los nuevos objetos. En una clase, los constructores se reconocen porque tienen el mismonombre que la clase y no tienen tipo de retorno. Un constructor sin argumentos, se conocecomo el constructor por defecto. Si una clase tiene multiples constructores todos ellos debentener el mismo nombre, coincidente con el de la clase, pero deben tener distinto numero otipo de argumentos. Cada constructor inicia un nuevo objeto de diferente modo. El compi-lador se encarga de identificar cual de ellos es el llamado. Los constructores solo pueden serllamados con el operador new. Cuando se declaran los constructores de una clase, se puedeespecificar que otros objetos pueden crear ejemplares de esa clase. Los niveles de acceso quese pueden utilizar son:


privado (private): otras clases no pueden crear ejemplares de esta.

protegido (protected): solo subclases de dicha clase pueden crear ejemplares de lamisma.

publico (public): cualquier clase puede crear ejemplares de esta.

amistoso (friendly): solo clases dentro del mismo paquete que esta clase pueden crearejemplares de ella.

Notese que estos niveles se aplican tanto a la creacion de clases como al acceso a lasvariables de clase y a los metodos, el nivel por defecto es el friendly.

Comentario 2.4 En este curso, desde el punto de vista del acceso a objetos, trabajaremossiempre en modo publico o friendly, es decir, se pueden crear objetos de esa clase desdecualquier otra clase. Notese que para determinadas aplicaciones puede ser muy util la re-striccion de accesos pero esta caracterıstica queda fuera del alcance de este curso.

2.6. Utilizacion de Objetos

Para acceder a las variables de un objeto, se concatenan los nombres de la variable y delobjeto con un punto. Por ejemplo, si se tiene un polıgono llamado pol en el programa, sepuede acceder a su variable miembro npoints, el numero de puntos con el que se construyedicho polıgono, con pol.npoints. Las variables miembros xpoints e ypoints son arrayscon las coordenadas x e y de los puntos que se utilizan para construir el polıgono, si sequieren dar las coordenadas de uno de estos puntos se consigue mediante la sentencia:

pol.xpoints[0]=2;pol.ypoints[0]=3;

Para llamar a los metodos de un objeto, simplemente se concatena el nombre del metodocon el objeto mediante un punto, dando los argumentos del metodo entre parentesis. Si elmetodo no requiere argumentos, se utilizan los parentesis vacıos. Por ejemplo, en la seccionanterior, la variable cadena era de tipo String, con una llamada al metodo length() decadena se obtiene su longitud.

cadena.length();

La llamada al metodo length() esta directamente dirigida al objeto cadena. Las llamadasa metodos tambien se conocen como mensajes.

Ejemplo ilustrativo 2.6 (Manipulacion de las clases automovil y camion). Unavez creadas las clases Automovil y Camion se va a proceder a crear objetos y manipularlos.El codigo para realizar cada una de las siguientes acciones se inserta en el metodo main()de la clase Principal mostrada en el Comentario 2.2:

1. Se crea un objeto de la clase automovil de la marca “Ford” con 2000 c.c. de cilindraday se escriben sus caracterısticas en pantalla:


Automovil miautomovil=new Automovil("Ford",2000);System.out.println("Mi automovil es modelo "+miautomovil.modelo);System.out.println("Con una cilindrada de "+miautomovil.cilindrada);

2. Se mete la primera marcha y se escribe la marcha actual:

miautomovil.CambiaMarcha(1);System.out.println("La marcha actual es "+miautomovil.marcha);

3. Se gira a la derecha y se escribe en pantalla la direccion actual del coche:

miautomovil.girarIzquierda();System.out.println("La direccion actual es "+miautomovil.direccion);

4. A continuacion se crea un objeto de la clase camion, se trata de un “Volvo” de 10000c.c. de cilindrada y cargado con 25000 kg:

Camion micamion;micamion = new Camion("Volvo",10000,25000);

5. La velocidad inicial es nula, es decir, esta parado. A continuacion se endereza ladireccion y se pone el volante recto escribiendo la direccion actual:

micamion.continuarRecto ();System.out.println("La direccion del camion es "+micamion.direccion);

6. Se acelera a 80 km/h y se escribe la velocidad:

micamion.Acelera (80);System.out.println("La velocidad es "+micamion.velocidad+" km/h");

La salida por pantalla tiene queda de la siguiente manera:

Mi automovil es modelo FordCon una cilindrada de 2000La marcha actual es 1La direccion actual es izquierdaLa direccion del camion es rectoLa velocidad es 80.0 km/h

Comentario 2.5 Para referirse a la propia clase se utiliza la palabra clave this tanto paralas variables como para los metodos.

2.7. Variables de instancia y de clase

Notese que hasta ahora las variables se definıan de la siguiente forma:


class A{int var;

}

que se conoce con el nombre de variable de instancia. Cada vez que se crea una instanciade una clase, es decir, un objeto de esa clase, el sistema crea una copia de cada una de lasvariables de instancia de la clase. Se puede acceder a ellas solo desde un objeto de la clase.

A a=new A();\\ Se crea la variable a de la clase AA b=new A();\\ Se crea la variable b de la clase Aa.var; \\ Acceso a la variable var del objeto ab.var; \\ Acceso a la variable var del objeto b

Notese que en las dos ultimas sentencias se accede distintas variables.Alternativamente, existen variables de clase que se declaran utilizando la palabra clave

static de la siguiente manera:

class A{static int var;

}

Estas variables estan asociadas a la clase, de forma que todos los ejemplares de la clasecomparten la misma copia de las variables de clase. Se puede acceder a ellas a traves de unejemplar o a traves de la propia clase.

A a=new A();\\ Se crea la variable a de la clase AA b=new A();\\ Se crea la variable b de la clase Aa.var; \\ Acceso a la variable var a traves del objeto ab.var; \\ Acceso a la variable var a traves del objeto bA.var; \\ Acceso a la variable var a traves de la clase

Notese que en las tres ultimas sentencias se accede a la misma variable.

2.8. Metodos de instancia y de clase

Analogamente se distinguen metodos de instancia y metodos de clase, estos ultimos sedefinen empleando la misma palabra clave static.

Los metodos de instancia tienen las siguientes caracterısticas:

1. Tienen acceso a las variables de instancia y de clase.

2. Solo se puede acceder a ellos desde un objeto de la clase.

Los metodos de clase por contra:

1. Tienen acceso solo a las variables de clase, no pueden acceder a las variables deinstancia.

2. Pueden llamarse desde la clase, no es necesario un ejemplar.


2.9. Mensajes

Un objeto solo no es util, por lo que frecuentemente aparece como una componente de unprograma que contiene otros muchos objetos. Es a traves de la interaccion entre estos objetoscomo se consigue un alto nivel de funcionalidad del programa. Estos objetos interaccionany se comunican enviandose mensajes unos a otros. El objeto que recibe el mensaje necesitala informacion adecuada para saber que debe hacer. Esta informacion se pasa a traves delmensaje como un parametro. Un mensaje esta formado por tres componentes:

El objeto al que se envıa el mensaje.

El nombre del metodo a utilizar.

Los parametros que necesita el metodo.

Un ejemplo es el que sigue.

c3.suma(c1,c2);

en el que c3 es el objeto al que se envıa el mensaje, suma es el metodo a utilizar, y c1 y c2son los parametros que necesita el metodo.

2.10. Liberacion de memoria de objetos no utilizados

Java permite crear objetos sin tener que destruirlos posteriormente. Cuando se crea unobjeto, el interprete de Java reserva suficiente espacio en memoria para el. En particularguardara suficiente memoria para sus variables miembros. Cuando un objeto deja de seraccesible, Java lo destruira automaticamente y devolvera el espacio reservado para el objetoal espacio de memoria libre, que podra ser utilizada por nuevos objetos. Este proceso seconoce como “recogida de basura”(garbage collection).

Antes de que la memoria asociada a un objeto sea liberada, el sistema llamara a sumetodo finalize(). Una clase puede definir su propia finalizacion redefiniendo el metodofinalize() de la clase java.lang.Object. Dicho metodo debe ser declarado de la formasiguiente:

protected void finalize() throws throwable{...}

Practica 2.1 (Clases Punto y Rectangulo). Crear un clase que se llame Punto de laque no se puedan generar subclases y que tenga las caracterısticas siguientes:

1. Pertenece al paquete geometric.

2. Se emplea para definir puntos en el espacio dados por sus coordenadas, por ellohabra dos variables x e y asociadas a la clase que pueden tomar cualquier valorreal con la maxima precision posible (tipo double).


3. El constructor recibe dos argumentos que se corresponden con las coordenadas x e yque se quieren dar al punto.

4. Tiene un metodo llamado distancia dentro de la clase Punto que recibe como argu-mentos las coordenadas x1 e y1 de forma que calcula y devuelve la distancia d de esepunto con respecto al punto x e y definido por las variables de instancia asociadas ala clase Punto. La distancia se calcula con la formula:

d =√

(x− x1)2 + (y − y1)2, (2.1)

para la cual existen dos metodos tipo static de la clase Math, uno llamado sqrt querecibe como argumento un numero tipo double y devuelve la raız cuadrada en unavariable tambien tipo double, y el otro pow que recibe dos argumentos tipo double ydevuelve el valor tipo double de la potencia del primer argumento elevado al segundoargumento.

5. Tambien tiene otro metodo distancia con distinto tipo de argumentos, en este casorecibe una variable llamada p de la clase Punto. Dentro de este metodo se empleara elmetodo distancia definido en el punto 4 para el calculo y devolucion de la distanciad.

A continuacion crear una clase llamada Rectangulo con las siguientes caracterısticas:

1. Pertenece tambien al paquete geometric.

2. Se emplea para definir un rectangulo y tiene como variables de instancia pil, pur,diagonal, ancho y alto, donde pil es un objeto de la clase Punto que se correspondecon la esquina inferior izquierda del rectangulo, pur es un objeto de la clase Punto quese corresponde con la esquina superior derecha del rectangulo, y las restantes variablesson longitudes de la diagonal, del ancho y del alto del rectangulo, respectivamente.Todas las dimensiones son de tipo double.

3. El primer constructor recibe como argumentos un ancho a1 y un alto a2 de forma quela esquina inferior izquierda del objeto rectangulo generado con este constructor seael origen de coordenadas, mientas que las coordenadas del segundo punto se obtienena partir del origen y de los datos de ancho y alto. La diagonal queda sin definir.

4. El segundo constructor recibe como argumentos dos puntos p1 y p2, objetos de tipoPunto, que se emplearan para dar valores a los puntos pil y pur, respectivamente.Las demas dimensiones quedan sin definir.

5. Por ultimo, se crean tres metodos llamados calculadiag, calculancho y calculargoque se encargan de dar valor a las variables diagonal, ancho y alto, respectivamente,a partir de las coordenadas de los puntos pil y pur.

Para poder emplear estas dos clases crear la clase Principal definida en el Comentario2.2, que pertenezca al paquete geometric, y que contiene el metodo main(). En ella serealizan las siguientes acciones:


1. Crear una variable p1 de tipo Punto con coordenadas (0, 0).

2. Crear una variable p2 de tipo Punto con coordenadas (30, 40).

3. Declarar una variable de tipo Rectangulo llamada r1 pero sin inicializarla.

4. Inicializar la variable r1 empleando los puntos p1 y p2.

5. Escribir la distancia entre los puntos p1 y p2 usando el metodo System.out.println()y el metodo correspondiente de la clase Punto.

6. ¿Podrıas escribir los valores de las variables diagonal, ancho y alto del objeto r1?¿Por que?

7. Escribir los valores de esas variables empleando el metodo que creais conveniente.

Solucion: La solucion de todos los apartados se da a continuacion. En primer lugar sedescribe la clase Punto que habra de ubicarse en un fichero llamado “Punto.java”:

1. package geometric;

final class Punto {

2. double x,y;

3. public Punto(double x,double y) {this.x=x;this.y=y;

}

4. public double distancia(double x1,double y1) {double d;d = Math.sqrt(Math.pow(x - x1, 2) + Math.pow(y - y1, 2));return (d);

}

5. public double distancia(Punto p) {double d = this.distancia(p.x,p.y);return(d);

}}// Final de la definicion de la clase Punto

A continuacion se describe la clase Rectangulo que habra de ubicarse en un ficherollamado “Rectangulo.java”:

1. package geometric;

public class Rectangulo {


2. Punto pil,pur;double diagonal, ancho, alto;

3. public Rectangulo(double a1,double a2) {pil.x = 0.0;pil.y = 0.0;pur.x = a1;pur.y = a2;ancho = a1;alto = a2;

}

4. public Rectangulo(Punto p1,Punto p2) {pil = p1;pur = p2;

}

5. public void calculadiag () {diagonal = pil.distancia(pur);

}

public void calculancho () {ancho = pil.distancia(pur.x,pil.y);

}

public void calculalto () {alto = pil.distancia(pil.x,pur.y);

}}// Fin de la definicion de la Rectangulo

Para finalizar, se crea la clase Principal en un fichero llamado “Principal.java” perte-neciente al mismo paquete geometric:

package geometric;

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

Todo lo que viene a continuacion esta ubicado en el cuerpo del metodo main:

1. Punto p1=new Punto(0,0);


2. Punto p2=new Punto(30,40);

3. Rectangulo r1;

4. r1 = new Rectangulo(p1,p2);

5. System.out.println("La distancia entre los punto p1 y p2 es de "+ p1.distancia(p2));

6. No, porque el constructor empleado no define los valores de las variables diagonal,ancho y alto del objeto r1, y hasta que no esten definidos sus valores no se puedeacceder a ellos.

7. r1.calculadiag();r1.calculalto();r1.calculancho();System.out.println("La diagonal del rectangulo r1 mide " + r1.diagonal

+ " unidades");System.out.println("El ancho del rectangulo r1 mide " + r1.ancho

+ " unidades");System.out.println("El alto del rectangulo r1 mide " + r1.alto

+ " unidades");

Ejercicios del Capıtulo

Ejercicio 1. Disenar un programa que dibuje varias figuras geometricas (rectangulos,ovalos, triangulos, pentagonos, hexagonos, etc.) cuyo contorno tenga diferentes grosoresy puedan rellenarse de diferentes sombreados y colores.

Se pide: Disenar un conjunto de clases que lo hagan facilmente implementable y eficazpara dicho proposito.

Ejercicio 2. En una empresa se quiere trabajar con una base de datos para control de lamisma que incluya la informacion sobre:

El personal, clasificado por categorıas.

Los clientes, con sus nombres, apellidos, direcciones, telefonos, numeros de fax, pro-ductos mas comprados, etc.

Productos fabricados, con sus precios, cantidades disponibles en almacen, etc.


Facturas emitidas y su estado.

Se pide: Disenar un conjunto de clases para dicho tratamiento, incluyendo las variablesmiembro de cada clase y los metodos correspondientes.

Ejercicio 3. Considera tu escritorio y todos los elementos de trabajo que se encuentransobre el. Hacer una descripcion del mismo mediante clases. Inicialmente se define la claseEscritorio, y cada uno de los elementos serıan variables miembros de esta.

Ejercicio 4. Piensa en un deporte que te guste. Describe mediante clases todas las tecnicasdel mismo y equipos que participan en el mismo. Por ejemplo, si este deporte es el balonces-to, la clase principal serıa la clase Baloncesto, cada uno de los equipos serıan una clase yserıan variables miembros de la clase Baloncesto y entre los metodos de la clase principalestarıan las distintas estrategias de juego.

Ejercicio 5. Disenar utilizando programacion orientada a objetos, una aplicacion que simuleunos grandes almacenes. Dicho lugar constara de tres plantas, la primera de ellas dedicada aalimentacion, la segunda dedicada a ropa y la ultima dedicada a muebles y electrodomesti-cos. A su vez cada planta tiene sus propias dependencias, ası en la planta de alimentacionhabra carnicerıa, pescaderıa, etc., en la planta de ropa habra una dependencia para ropa denino y otra para ropa de adulto, etc., y en la ultima tambien se pueden distinguir distintassecciones. Se trata de que una persona que llegue a dichos almacenes pueda visitar cada unade las plantas y secciones, observar los productos y precios, y ademas un cliente tambiendebe poder preguntar sobre la existencia de un cierto producto o marca. Una vez que uncliente decide comprar un producto, esta compra debe ser almacenada en una base de datospara cuando se acabe el dıa se pueda hacer un recuento de las ventas.

Ejercicio 6. Hacer una descripcion de los coches de una determinada casa automovilıstica,utilizando programacion orientada a objetos. En dicha aplicacion aparecera una clase prin-cipal Coche, con las caracterısticas comunes a todos los coches de esa casa, y luego cadamarca de coche dentro de esa casa que sera una subclase de la clase Coche.

Ejercicio 7. Hacer una descripcion mediante clases de los animales de un zooloogico. Uti-lizar subclases para las diferentes subespecies.

Capıtulo 3

EL LENGUAJE JAVA

En este capıtulo se comienza dando un sencillo ejemplo para ilustrar los elementos masimportantes que aparecen en un programa Java. Se trata de que el lector no iniciado tengauna primera vision de la estructura de un programa, sin necesidad de profundizar demasiadoen detalles concretos.

Una vez que el lector tenga esta primera impresion, se describiran mas en detalle losdiferentes elementos, tales como variables, constantes, operadores, matrices, cadenas de car-acteres, expresiones, sentencias y bloques, de forma que pueda conocer con mas profundidadcomo se tratan estos elementos en el lenguaje Java.

El capıtulo termina describiendo las sentencias if-else, else-if, switch, while, fory do-while que sirven para controlar el flujo de los programas.

3.1. Un ejemplo: Los numeros complejos

En esta seccion se da un ejemplo en el que se implementa una clase para trabajar connumeros complejos. Puesto que se utiliza para ilustrar inicialmente los diferentes elementosdel Java, se recomienda al lector que no trate de comprender en detalle todo el programasino solo su estructura, ya que unicamente se trata de darle una vision muy general.

Programa 3.1 (Definicion de la clase Complejo).

package numerocomplejo;

import java.io.*;import java.lang.*;

// Se define la clase Complejopublic class Complejo extends Object{

// La clase tiene las dos variables miembros siguientesdouble preal;double pimag;

// Se define el constructor de la clasepublic Complejo(double partereal,double parteimag){

24

CAPITULO 3. EL LENGUAJE JAVA 25

preal=partereal;pimag=parteimag;

}// Se define el metodo para calcular el complejo opuestopublic void opuesto(){preal=-preal;pimag=-pimag;

}// Se define el metodo para calcular el complejo conjugadopublic void conjugado(){pimag=-pimag;

}// Se define el metodo para calcular el modulopublic double modulo(){return Math.pow(preal*preal+pimag*pimag,0.5);

}// Se define el metodo para calcular el argumentopublic double argumento(){if(preal==0.0 && pimag==0.0){

return 0.0;}else

return Math.atan(pimag/preal);}

// Se define el metodo para imprimir el complejopublic void imprime(){System.out.println("(" + preal + "," + pimag + ")");

}// Se define el metodo para calcular la suma de dos complejospublic void suma(Complejo c1,Complejo c2){preal=c1.preal+c2.preal;pimag=c1.pimag+c2.pimag;

}// Se define el metodo para calcular el producto de dos complejospublic void producto(Complejo c1,Complejo c2){preal=c1.preal*c2.preal-c1.pimag*c2.pimag;pimag=c1.preal*c2.pimag+c1.pimag*c2.preal;

}// Se define el metodo para calcular el cociente de dos complejos// y se genera una excepcion cuando el divisor es el complejo ceropublic void cociente(Complejo c1,Complejo c2)throws ZerodivisorException{double aux;if(c2.preal==0.0 && c2.pimag==0.0){

throw new ZerodivisorException("Divide por cero");}else{aux=c2.preal*c2.preal+c2.pimag*c2.pimag;preal=(c1.preal*c2.preal+c1.pimag*c2.pimag)/aux;pimag=(c1.pimag*c2.preal-c1.preal*c2.pimag)/aux;


}}

// Se define la excepcion ZerodivisorExceptionclass ZerodivisorException extends Exception{ZerodivisorException(){super();}ZerodivisorException(String s){super(s);}

}}

Las dos primeras sentencias import, que inician el programa, se utilizan para importarclases ya programadas. De esta forma podemos referirnos a ellas y utilizarlas sin necesidadde programarlas. El lenguaje Java viene con una serie de paquetes de programas como elio, util, lang o awt, etc., que se describen al final de este capıtulo.

En las sentencias que siguen se define la clase Complejo. Toda clase en Java debe seruna extension de otra clase ya existente. En caso de que no haya alguna que nos intereseextender, como en este caso, Java supone que es la clase Object, que es la clase que ocupael lugar preeminente de la jerarquıa. La sentencia

public class Complejo extends Object

da el nombre Complejo a la clase, la declara de tipo publica, mediante el adjetivo public,con lo que puede ser accesible desde fuera de la clase, y la define como una extension de laclase Object, con lo que hereda todas sus variables y metodos.

Toda clase tiene dos componentes: variables miembros y metodos. En este caso lasvariables miembros de la clase Complejo son su parte real y su parte imaginaria, que sedeclaran de tipo doble precision (double) y se llaman preal y pimag, respectivamente,mediante las sentencias:

double preal;double pimag;

Seguidamente se definen los metodos, que indican como se crean ejemplares de la clasey que operaciones pueden hacerse con los numeros complejos y como hacerlas. El primerode ellos es el constructor de la clase. Cuando se crea un ejemplar de esta clase, este metodolo inicia y le asigna las partes real e imaginaria que le indiquen sus argumentos (parterealy parteimaginaria) a sus variables miembros (preal y pimag).

Los metodos opuesto() y conjugado() cambian las partes imaginarias y/o reales paraobtener los complejos opuesto y conjugado, respectivamente.

El metodo modulo() devuelve el modulo del complejo que es

|(a, b)| = (a2 + b2)1/2

Para elevar a la potencia 1/2 se utiliza la funcion pow del paquete Math.El metodo argumento() controla primero si el complejo es nulo, mediante la sentencia

if(preal==0.0 && pimag==0.0), que simplemente comprueba si las partes real e imagi-naria son nulas, en cuyo caso devuelve el argumento nulo (return 0.0). El operador && es


el operador relacional “y”. En caso contrario se utiliza la funcion atan() del paquete Mathque da el arco tangente para calcular el argumento a devolver.

El metodo imprime() imprime el complejo con el formato (a, b) utilizando la claseSystem y la funcion println. Los signos + concatenan las diferentes partes del texto. Noteseque hay que abrir y cerrar los parentesis, poner la coma de separacion y escribir las partesreal e imaginaria, en su correspondiente orden.

Los metodos suma(), producto() y cociente() calculan la suma, el producto y elcociente de dos numeros complejos. Para ello, hay que recordar que las formulas que dan lasuma, el producto y el cociente de complejos son:

(a, b) + (c, d) = (a + c, b + d), (3.1)(a, b)× (c, d) = (ac− bd, ad + bc) (3.2)

(a, b)/(c, d) = (ac + bd

c2 + d2,ad− bc

c2 + d2). (3.3)

En el cociente, el metodo genera la excepcion ZerodivisorException, con el mensaje‘‘Divide por cero’’, cuando el complejo divisor es nulo. La variable aux es una variableauxiliar de tipo double que se utiliza para no tener que calcular dos veces el denominadorcomun de la expression (3.3).

Finalmente, la clase ZerodivisorException define que hacer cuando se produce dichaexcepcion. En este caso, solo definimos el constructor, aunque de dos formas diferentes: unasin argumento, que simplemente llama al constructor de la superclase Exception y, otra,con un argumento, que tambien llama al correspondiente constructor de la superclase, esdecir al que posee el mismo argumento. Esta posibilidad de definir metodos con el mismonombre y diferentes argumentos, no admitida en otros lenguajes, caracteriza al lenguajeJava. El compilador Java se encarga de determinar de cual de ellos se trata en cada caso,simplemente analizando el numero de sus argumentos y su tipo.

Para poder utilizar la clase Complejo se necesita escribir el metodo main() (si se tratade una aplicacion) que cree ejemplares de la clase Complejo y utilice sus metodos. Esto sehace en el programa que sigue, si bien antes se ha incluido el resultado que se obtiene enpantalla al ejecutarlo. El lector debe comprobar, paso a paso, como este resultado se vagenerando al ejecutar las sentencias del programa.

Programa 3.2 (Programa para probar la clase complejo).

package numerocomplejo;

import numerocomplejo.Complejo.*;

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

Complejo c1,c2,c3;


c1=new Complejo(1.0,2.0);c2=new Complejo(3.0,4.0);c3=new Complejo(0.0,0.0);c1.imprime();c2.imprime();c3=c2;c3.opuesto();c3.imprime();c3.conjugado();c3.imprime();c3.suma(c1,c2);c3.imprime();System.out.println("El modulo de la suma es = " + c3.modulo());System.out.println("El argumento de la suma es = " + c3.argumento() +" radianes");c3.producto(c1,c2);c3.imprime();c2.preal=0.0;c2.pimag=0.0;System.out.println("El argumento de c2 es = " + c2.argumento() +" radianes");try{c3.cociente(c1,c2);System.out.println("El cociente es : ");c3.imprime();

}catch (ZerodivisorException e){System.out.println("Al calcular el cociente se ha producido una excepcion \n"

+ e.getClass() + "\n" + "con el mensaje : " + e.getMessage());}

}}

El resultado del programa queda de la siguiente manera:

(1.0,2.0)(3.0,4.0)(-3.0,-4.0)(-3.0,4.0)(-2.0,6.0)El modulo de la suma es = 6.324555320336759El argumento de la suma es = -1.2490457723982544 radianes(-14.0,-22.0)El argumento de c2 es = 0.0 radianesAl calcular el cociente se ha producido una excepcionclass numerocomplejo.Complejo$ZerodivisorExceptioncon el mensaje : Divide por cero

La primera sentencia indica que la clase Principal pertenece al mismo paquete quela clase Complejo, mientras que la segunda importa todas las caracterısticas de la claseComplejo, en la que se han definido los numeros complejos y las operaciones que puedenrealizarse con ellos (calcular su modulo, argumento, su opuesto, su conjugado, imprimirlo,suma, producto y cociente, etc.), imprescindible para que no de un error al arrojar laexcepcion.


Una de las formas de ejecutar un programa Java es mediante la definicion de una claseque contenga el metodo main(). Por ello, la sentencia

public class Principal

define la clase Principal, que contendra el metodo main para la generacion de objetos yla escritura. El adjetivo public indica que va a ser accesible desde el exterior, es decir, quepueden crearse ejemplares de esta clase desde fuera de ella.

Dentro de esta clase se crea el metodo main(), que es el que Java busca entre las clasesexistentes para comenzar la ejecucion del programa. En el se definen, mediante la sentenciaComplejo c1,c2,c3, tres copias de la clase Complejo, que se llaman c1, c2 y c3, y quereciben el nombre de variables, puesto que pueden cambiar sus valores durante la ejecuciondel programa. Con esta sentencia solo se indica el tipo de variable (Complejo) de que setrata, pero no se reserva espacio en memoria para ellas, lo que sı se hace en las sentenciasque siguen

c1=new Complejo(1.0,2.0);c2=new Complejo(3.0,4.0);c3=new Complejo(0.0,0.0);

en las que ademas se inician los complejos dandoles sus partes reales e imaginarias. Lapalabra clave new sirve para crear un nuevo ejemplar y reservar la memoria necesaria.

Al metodo Complejo() se le llama constructor, por encargarse de construir un elementode la clase, reservando espacio en memoria y haciendo las iniciaciones necesarias. Noteseque tiene el mismo nombre que la clase que construye.

Seguidamente, se imprimen los complejos c1 y c2, llamando al metodo imprime(),que es uno de los metodos de la clase Complejo. Notese que para llamar al metodo seescribe el nombre de la variable seguido de un punto y del nombre del metodo. Si este tieneargumentos, se incluyen entre parentesis y, si no los tiene, se escriben los parentesis sin nadaen su interior, como ocurre en este caso.

La sentencia c3=c2 asigna al complejo c3 el valor que en ese instante tenga el complejoc2, por lo que c3, que inicialmente era el complejo (0, 0), (fue iniciado a ese valor mediantela sentencia c3=new Complejo(0.0,0.0)), pasa a ser el complejo (3, 4).

Las sentencias dobles

c3.opuesto();c3.imprime();c3.conjugado();c3.imprime();

convierten a c3 primero en su opuesto y lo imprime, y luego en su conjugado y lo imprime.Con las sentencias

c3.suma(c1,c2);c3.imprime();

se almacena en c3 la suma de los complejos c1 y c2 y se imprime.Las sentencias

System.out.println("El modulo de la suma es = " + c3.modulo());System.out.println("El argumento de la suma es = " +c3.argumento() + " radianes");


imprimen el modulo de la suma y su argumento, utilizando el metodo de impresion printlndel sistema.

Posteriormente se calcula el producto de los complejos c1 y c2 y se almacena el resultadoen el complejo c3.

Con objeto de probar el comportamiento de los metodos argumento y cociente cuandose trata con el complejo nulo, se hace primero c2 igual al complejo nulo, mediante lassentencias

c2.preal=0.0;c2.pimag=0.0;

luego se escribe su argumento con la sentencia

System.out.println("El argumento de c2 es= " + c2.argumento() + " radianes");

y seguidamente se calcula el cociente y se imprime mediante

try{c3.cociente(c1,c2);System.out.println("El cociente es : ");c3.imprime();

}catch (ZerodivisorException e){System.out.println("Al calcular el cociente se ha

producido una excepcion " + e.getClass()+ "\ncon el mensaje : " + e.getMessage());

}

Notese que se preve la posibilidad de obtener un error (en este caso una division porcero), por lo que se escribe el verbo try (intentar) antes del calculo del cociente, y el verbocatch (capturar) que indica lo que debe hacerse en dicho caso, es decir, imprimir un mensajeindicando que se ha producido una excepcion en la clase correspondiente. Se recomiendaal lector en este punto que haga un esfuerzo por entender la estructura de los programas3.1 y 3.2 anteriores antes de seguir con la lectura de los detalles del lenguaje Java, puesseguidamente se pasa ya a describir los diferentes elementos del lenguaje.

Comentario 3.1 Desde el punto de vista practico en este curso no se dara excesiva im-portancia al tratamiento de las excepciones, para mas detalles vease el libro [1].

3.2. Variables

Las variables pueden considerarse como zonas o espacios de memoria en las que sealmacena la informacion. Son los pilares de la programacion y los elementos sobre los quese actua. Para poder utilizar una variable es necesario especificar su nombre y su tipo. Elnombre sirve para saber a que zona de memoria se esta uno refiriendo, y el tipo sirve parasaber el tamano de la memoria necesario para almacenarla y como debe interpretarse lainformacion, tanto al guardarla en memoria como al leerla. En realidad, la informacion, sea


del tipo que sea, se almacena en binario, es decir en forma de bits (ceros y unos), por lo quehay que transformarla tanto para almacenarla como para interpretarla.

El lenguaje JAVA esta fuertemente tipificado, lo que significa que toda variable y todaexpresion tienen un tipo, que se conoce al compilar, es decir, no hay que esperar a ejecutar elprograma para saber el tipo de datos que contiene una variable dada. Esto limita los valoresque pueden tomar las variables y producir las expresiones, limita las operaciones que puedenrealizarse con las variables y expresiones y determina el significado de las operaciones quelas afectan. Todo ello sirve para detectar errores en el momento de la compilacion, que deotro modo pasarıan desapercibidos.

Por tanto, al declarar una variable deben especificarse su tipo y su nombre. Por ejemplo,las sentencias:

int edad;double estatura;boolean terminado;

definen tres variables cuyos nombres son “edad”, “estatura” y “terminado” y cuyos valoresson de tipo “entero” (int), “doble precision” (double) y “booleano” (boolean), respecti-vamente.

Algunos ejemplos de definicion de variables son:

int a,b;String nombre,domicilio;long d;boolean f;

El punto y coma al final de toda sentencia en Java indica el final de la misma y no hayque olvidarlo.

3.2.1. Nombre de una variable

El nombre de una variable no es de libre eleccion, sino que debe cumplir las condicionessiguientes:

1. Debe comenzar siempre con una letra (mayuscula o minuscula) o con un signo desubrayado (_).

2. El resto del nombre puede estar formado por combinaciones de letras, numeros ysignos de subrayado. Por ejemplo miEdad, Edad_1,A1

3. No debe incluir espacios ni caracteres como & y *.

4. Debe ser un identificador legal de Java formado por una serie de caracteres unificados(Unicode). Unicode es un sistema de codificacion de caracteres disenado para soportartexto escrito en diferentes idiomas. Permite hasta un total de 34.168 caracteres dife-rentes, que incluyen caracteres acentuados de todo tipo, caracteres griegos, hebreos,cirılicos, japoneses, etc.


5. No debe coincidir con una palabra clave ni con true o false.

Las palabras clave reservadas por Java son:

abstract default if private throwboolean do implements protected throwsbreak double import public transientbyte else instanceof return trycase extends int short voidcatch final interface static volatilechar finally long super whileclass float native switchconst for new synchronizedcontinue goto package this

6. Tampoco debe coincidir con el nombre de otra variable declarada en su mismo campode accion, pudiendo hacerlo con variables declaradas en diferente campo.

3.2.2. Tipos de datos

En Java, toda variable tiene siempre asignado un unico tipo de dato. Este determina losvalores que la variable puede almacenar y las operaciones que se pueden realizar con ella.

Hay tres tipos de variables o expresiones:

Basicas : que contienen la informacion propiamente dicha. Estas pueden ser:

• Numericas : que a su vez pueden ser:

◦ Enteras : byte, short, int, long, que toman valores enteros.◦ Coma flotante : float (simple precision) y double (doble precision), que

toman valores reales.

• Booleanas : boolean, que toman los valores logicos “true” y “false”.

• Tipo caracter : char, que toman solo valores de tipo caracter.

Referenciales : que no contienen la informacion, sino donde se encuentra esta, esdecir, son referencias a objetos. Estas pueden ser:

• Tipo clase : class, que contienen referencias a clases.

• Tipo interfase : interface, que contienen referencias a una interfase.

• Tipo matriz : array, que contienen referencias a una matriz.

Tipo nulo : que es un tipo especial que no tiene nombre, por lo que no se puedendeclarar variables o transformar otras a este tipo. La referencia nula null es el unicovalor que puede tomar una expresion de este tipo. Todas las variables de tipo refer-encial pueden tomar este valor null.


En la Tabla 3.1 se describen, uno a uno, los diferentes tipos de datos o variables basicas,sus tamanos asociados y los valores mınimos y maximos de cada uno de ellos.

Veamos un ejemplo:

Programa 3.3 (Ilustracion de los diferentes tipos de variables).

class DrawPanel extends Panel{

static int dimension;int x,y;double[] a=new double[10];

void Draw(Graphics g) {int RectLength=80;g.setColor(Color.blue);g.fillRect(x,y,RectLength,RectLength);g.setColor(Color.black);

}}

Este programa crea una clase DrawPanel, que es una subclase de (extiende) la clase yaexistente Panel, en la que se definen las variables miembros dimension, x e y, que son de tipoint y la variable a, que es una matriz, de dimension 10. Ademas, se define un metodo Draw,que lleva un argumento g, de tipo Graphics. Este metodo dibuja un rectangulo sombreadocon su vertice superior izquierdo en el punto (x,y), de anchura RectLength y de la mismaaltura y asigna el color negro al grafico g.

La variable g del programa anterior esta declarada como un objeto de la clase Graphicsy es de tipo referencial, es decir, no contiene el grafico sino solo la direccion de memoria enla que se encuentra. El nombre g hace referencia a la direccion de memoria donde reside lavariable. Por el contrario, el nombre de la variable primitiva RectLength hace referencia alvalor real de la variable.

Tipo Tamano Mınimo Maximobyte 8 bits −256 255short 16 bits −32768 32767int 32 bits −2147483648 2147483647long 64 bits −9223372036854775808 922337203685477580float 32 bits −224E − 149 224E104double 64 bits −253E − 1045 253E1000boolean N/A false truechar 16 bits Caracter Unicode

Tabla 3.1: Tipos de datos basicos o variables.

Observaciones:


Si se desea especificar un entero en notacion octal, el entero debe estar precedido porun 0. Si se desea notacion hexadecimal se precede el entero con un 0 y una x.

int n=023;int m=0xF;

El tipo double tiene mas precision y puede almacenar mas cifras decimales.

En la mayorıa de los ordenadores, los enteros se procesan mucho mas rapido que losnumeros almacenados en coma flotante.

Los numeros en coma flotante pueden almacenar valores mas grandes y mas pequenosque los enteros.

3.2.3. Campo de accion de una variable

Un detalle importante a la hora de programar, es el lugar de declaracion de una variable,el cual determina su campo de accion.

Se denomina campo de accion de una variable al bloque de codigo en el que dicha variablees accesible. Ademas este campo determina cuando se crea la variable y cuando se destruye.

Atendiendo al campo de accion, se pueden clasificar las variables en las clases siguientes:

Variable de clase. Es una variable de tipo clase que se declara dentro de la defini-cion de una clase o interfase, usando la palabra clave static, pudiendo prescindirde esta en la definicion de una interfase. Estas variables son creadas e iniciadas, avalores determinados o por defecto, al construirse la clase, dejando de existir cuandodesaparece dicha clase y tras completar el proceso previo a la destruccion del objeto(metodo finalize).

Variables miembros de una clase. Se declaran en la definicion de una clase sinusar la palabra clave static. Si a es una variable miembro de una clase A, cadavez que se construye un nuevo objeto de la clase A o una subclase de A se crea unanueva variable a y se inicia dandole un valor concreto o por defecto. La variable dejade existir cuando desaparece la clase a la que pertenece y tras completar el procesoprevio a la destruccion del objeto (metodo finalize).

Componentes de una matriz. Son variables sin nombre que se crean e inician avalores concretos o por defecto cuando se crea un objeto nuevo de tipo matriz. Lascomponentes de la matriz dejan de existir cuando desaparece la misma.

Variable local. Se declara dentro de un metodo y solo es accesible dentro del mismo.Por ejemplo, cuando se entra en un bloque o ciclo for, se crea un nuevo ejemplar porcada variable local del bloque o ciclo. Sin embargo, las variables locales no se inicianhasta que se ejecuta la sentencia de declaracion correspondiente. Las variables localesdejan de existir cuando se termina el bloque o ciclo.


Parametro de un metodo o constructor. Es el argumento formal de un metodoo un constructor, mediante el cual se pasan valores a un metodo. Cada vez que seinvoca el metodo se crea una variable con ese nombre y se le asigna el valor quetenıa la correspondiente variable en el metodo que la llama. Su campo de accion es elmetodo o constructor del cual es argumento.

Parametro de un manipulador de excepciones. Es similar al parametro de unmetodo pero en este caso es el argumento de un manipulador de excepciones.

En el ejemplo anterior:

RectLength es una variable local.

La variable g es un parametro de un metodo.

La variable dimension es una variable de clase.

Las variables x e y son variables miembros de la clase DrawPanel.

a[] es una matriz.

3.2.4. Iniciacion de variables

Al declarar las variables locales, las de clase y las que son miembros de clases puedendarsele valores iniciales. Por ejemplo, las tres sentencias de definicion anteriores puedensustituirse por las siguientes:

int edad=30;double estatura=1.78;boolean Terminado=true;

en cuyo caso ademas de reservar espacio en memoria para ellos, se almacenan en ellos losvalores indicados.

Los parametros de los metodos y los de los manipuladores de excepciones no puedeniniciarse de este modo. El valor de estos parametros es fijado por el metodo que los llama.

3.3. Constantes

Las constantes en Java son como las variables, pero se diferencian de ellas en que su valorno se altera durante la ejecucion del programa. Para distinguirlas de ellas se las precede deladjetivo final. Por convenio, las constantes se escriben todas en mayusculas. Por ejemplo,las conocidas constantes π y e pueden definirse como sigue:

final double PI=3.14159265358979;final double E=2.71728182;


3.4. Comentarios

En un programa pueden introducirse comentarios que aclaren ciertos aspectos del pro-grama siempre que se indique al compilador cuando comienzan y, en algunos casos, cuandoterminan. En Java se distingen tres clases de comentarios:

/* texto */. El texto comprendido entre /* y */ es ignorado por el compilador. Seutiliza para comentarios de mas de una lınea.

// texto. El texto desde // hasta el final de lınea es ignorado. Se utiliza para comen-tarios de una sola lınea.

/** documentacion */. El texto comprendido entre /** y */ puede ser procesadopor otra herramienta para preparar documentacion de la siguiente declaracion de clase,constructor, interfase, metodo o campo.

Es una buena practica de programacion utilizar comentarios explicando el significadode las variables y los argumentos de los metodos, ası como comentar en detalle que hacenestos ultimos. De no hacerlo, sera muy difıcil a otras personas, o incluso a nosotros mismos,entender lo que hace el programa.

3.5. Operadores

Todos los tipos de datos basicos estan asociados a ciertos operadores mediante los cualesse construyen expresiones.

Existen operadores unarios y binarios que requieren uno o dos operandos, respectiva-mente.

Los operadores unarios pueden aparecer antes o despues del operando:

x++;++y;

Los operadores binarios siempre aparecen entre los dos operandos:

5*6;a+b;

Todo operador devuelve siempre un valor. Dicho valor y su tipo dependen del operadory del tipo de los operandos.

Los operadores pueden clasificarse en las siguientes categorıas:

aritmeticos

relacionales y condicionales

bit-a-bit y logicos

de asignacion


3.5.1. Operadores aritmeticos

Se distinguira entre operadores binarios y unarios.

Operadores Binarios

Operadores BinariosOperador Operacion Descripcion

+ a + b Adicion- a - b Diferencia* a * b Producto/ a / b Division% a % b Calcula el resto de dividir a entre b

Tabla 3.2: Operadores binarios

Los operadores aritmeticos binarios, salvo el operador % que solo actua con enteros,manejan indistintamente los tipos enteros y los de coma flotante. El compilador Java seencarga de detectar el tipo correspondiente.

Cuando un operador tiene operandos de diferente tipo, estos se convierten a un tipocomun siguiendo las reglas:

La categorıa de los tipos, de mayor a menor, es la siguiente: double, float, long,int, short, char.

En cualquier operacion en la que aparezcan dos operandos de tipos diferentes se elevala categorıa del que la tenga menor.

En una sentencia de asignacion, el resultado final se convierte al tipo de la variable ala que son asignados.

Operadores Unarios

Operadores UnariosOperador Operacion Descripcion

+ y - +a y -a Fijan el signo del operando

++++xx++

Anade 1 a x antes de utilizarlaAnade 1 a x despues de utilizarla

----xx--

Resta 1 a x antes de utilizarlaResta 1 a x despues de utilizarla

Tabla 3.3: Lista de operadores unarios

Veamos como actuan estos operadores con algunos ejemplos:


int i=7;4 * i++;i+2;

Las dos ultimas sentencias dan como resultado 4*7=28 y 8+2=10, pues en la primera semultiplica 4 por el valor de la variable i, que es 7, y luego se incrementa dicha variable enuna unidad, por lo que toma el valor 8. Tras esto se le suma 2 en la sentencia siguiente.

int i=7;4 * ++i;i+2;

En este caso los resultados son 4*8=32 y 8+2=10, pues primero se incrementa una unidada la variable i y luego se multiplica por 4.

3.5.2. Operadores relacionales y condicionales

Los operadores relacionales comparan dos valores y determinan la relacion que existeentre ellos. Los primeros se muestran en la Tabla 3.4 y los segundos en la Tabla 3.5.

Operadores RelacionalesOperador Empleo Descripcion

> a > bDevuelve true si a es mayor que b,Devuelve false en caso contrario.

>= a >= bDevuelve true si a es mayor o igual que b,Devuelve false en caso contrario.

< a < bDevuelve true si a es menor que b,Devuelve false en caso contrario.

<= a <= bDevuelve true si a es menor o igual que b,Devuelve false en caso contrario.

== a == bDevuelve true si a y b son iguales,Devuelve false en caso contrario.

!= a != bDevuelve true si a y b son diferentes,Devuelve false en caso contrario.

Tabla 3.4: Lista de operadores relacionales.

Normalmente, los operadores relacionales se usan junto a los operadores llamados condi-cionales formando ası expresiones mas complejas. Existen tres operadores condicionales.

Observar que el operador & es equivalente a && si sus dos operandos son de tipo boolean.Similarmente ocurre con | y con ||.

3.5.3. Operadores de asignacion

El operador = asigna a la variable de la izquierda el valor que toma la expresion de laderecha:


Operadores CondicionalesOperador Empleo Descripcion

&& a && bDevuelve true si a y b son true,Devuelve false en caso contrario.

|| a || bDevuelve false si a y b son false,Devuelve true en caso contrario.

! !aDevuelve false si a es true yDevuelve true si a es false

Tabla 3.5: Lista de operadores condicionales.

float i = 3.5;

Ademas de este operador basico existen otros que nos permiten simplificar cualquieroperacion. Por ejemplo:

n = n*5;

es equivalente a:

n *= 5;

La Tabla 3.6 muestra todos los operadores de asignacion:

Operadores de AsignacionOperador Empleo Descripcion

+= a += b a = a + b-= a -= b a = a - b*= a *= b a = a * b/= a /= b a = a / b%= a %= b a = a % b

Existen otros

Tabla 3.6: Lista de operadores de asignacion.

3.5.4. El operador cast

A veces se necesita almacenar valores de un tipo en variables de tipo diferente. Como Javano permite almacenar a cada variable mas que valores de su tipo, es necesario transformarlospreviamente.

El lenguaje Java no permite una conversion tan facil de tipos como el C. Para realizarladebe recurrirse al operador cast, que transforma un tipo de dato en otro compatible, talcomo se ve en el siguiente ejemplo:


float a;int b;

b = (int) a;

Es decir, a la variable b, que es de tipo int (entera) se le asigna el valor de la parteentera de la variable a que es de tipo float.

3.6. Matrices

En el programa pueden necesitarse un gran numero de variables, todas ellas del mismotipo y bajo una caracterıstica comun. Por ejemplo, considerense los 100 primeros multiplosde 2. Estos podrıan almacenarse ası:

int m1 = 2;int m2 = 4;int m3 = 6;...int m100 = 200;

lo que resultarıa bastante penoso. Por ello, se dispone de las matrices (arrays), demanera que la declaracion se hace como sigue:

int mult[];mult = new int[100];

En la primera sentencia se especifica el tipo de los elementos de la matriz (int en estecaso) y se da un nombre a la matriz, seguido de un doble corchete [] el cual indica alcompilador que lo que se declara es una matriz.

int mult[]

Pero la declaracion int mult[]; no asigna memoria para almacenar los elementos dela matriz, de manera que si se intenta acceder a alguno de ellos o asignarle un valor, elcompilador dara un mensaje de error. Para evitar esto y asignar la memoria necesaria serecurre al operador new

mult = new int[100];

A partir de ese instante ya se pueden dar valores a todos los elementos de la matriz:

for(int i=0;i<100;i++) {mult[i] = 2*(i+1);

}

Para acceder al elemento i-esimo de la matriz, basta con escribir: mult[i], teniendo encuenta que los ındices de la matriz comienzan a numerarse en 0.

Los elementos de una matriz son tratados como cualquier variable y pueden ser decualquier tipo, incluso de tipo referencial como objetos u otras matrices. Por ejemplo:


String a[] = new String[20];

Los elementos de esta matriz son tipos de referencia, cada elemento hace referencia a unobjeto String. Pero en la declaracion no se ha asignado suficiente memoria para los objetosString, de manera que si se quiere acceder a algun elemento de la matriz a se obtiene unaexcepcion NullPointerException, que indica que no se ha reservado memoria para dichavariable. Ası que se necesitan hacer las siguientes declaraciones:

for(int i=0;i<a.length;i++) {a[i] = new String(’’Elemento ’’ + i);

}

3.7. Cadenas de caracteres

Se denomina cadena de caracteres a una secuencia o conjunto ordenado de ellos. Todacadena de caracteres se implementa mediante la clase String.

En un ejemplo anterior se ha visto una forma de manejar estos objetos:

String a[] = new String[20];

Otra forma consiste en usar cadenas constantes de caracteres, delimitadas por ’’ (comil-las), como por ejemplo:

’’Hola’’;

Tambien se pueden unir dos cadenas de caracteres mediante el operador de concatenacion+. Por ejemplo:

’’La ecuacion tiene ’’ + n + ’’ soluciones.’’

donde n es una variable entera definida con anterioridad dentro del programa y convertidaa string antes de unirse a las dos cadenas. Este recurso se emplea con frecuencia asociadoal metodo System.out.println().

3.8. Expresiones

Toda expresion es una combinacion de variables, operadores y llamadas a metodos, quecalcule un valor.

Las expresiones se utilizan para calcular y asignar valores a variables y para controlar laejecucion de un programa. Realizan las operaciones indicadas por sus elementos y devuelvenalgun valor.

Existen dos tipos de expresiones:

Numericas: que toman valores numericos.

Booleanas: que solo toman los valores true o false.


3.8.1. Expresiones numericas

Cualquier variable que represente un numero es una expresion numerica. Veamos algunosejemplos:

int ii+10--n;

Toda asignacion es tambien una expresion:

a = 100b* = 2

3.8.2. Expresiones booleanas

Solo poseen los valores true o false. Por ejemplo:

n != ma < b

Las dos sentencias:

int a = 5if(a){

...}

no son correctas, pues a es una expresion numerica y el compilador no puede evaluarla comotrue o false.

En una expresion es importante el orden en que se aplican los operadores. No es lomismo

5 * 3 + 4

que

5 * (3 + 4)

Si se omiten los parentesis el compilador actua por su cuenta y aplica sus reglas depreferencia de modo que los operadores que figuran delante en el orden de preferenciaactuan antes que los que figuran detras. En este caso, el operador * esta por delante deloperador +, de manera que el resultado serıa (5*3) + 4.

En la Tabla 3.7 se da el orden de preferencia de los operadores: los operadores estanordenados de arriba a abajo segun su orden de preferencia; los operadores de una mismalınea tienen el mismo orden de preferencia y, dentro de una expresion, se evaluan de izquierdaa derecha.


. [] ()++ -- ! ~ instanceofnew (type)* / %+ -<< >> >>>< >== !=&^|&&||? := += -= *= /= %= ^=&= |= <<= >>= >>>=

Tabla 3.7: Orden de preferencia de los operadores.

3.9. Sentencias y bloques

Un programa no es mas que un conjunto de sentencias ordenadas. Una sentencia es unainstruccion completa para el compilador, que acaba en un punto y coma.

Una expresion como a = 100 o a <b se convierte en una sentencia cuando va seguidade un punto y coma:

a = 100;a < b;

Una sentencia indica una accion. La expresion

2+2;

indica al compilador que realice esa operacion pero no, lo que debe hacer con el resultado.Por el contrario, la sentencia

a = 2+2;

ordena al compilador que almacene el resultado en la variable a. A continuacion el ordenadorestara preparado para realizar la siguiente tarea.

Veamos cuatro clases de sentencias:

Sentencias de declaracion: establecen los nombres y el tipo de variables.

Sentencias de asignacion: asignan valores a las variables.

Sentencias de funcion: llaman a funciones para realizar una determinada tarea.


Sentencias estructuradas o de control de flujo: while, if-else, switch, etc.que se analizan en la seccion siguiente.

Un bloque es un conjunto de dos o mas sentencias agrupadas y encerradas entre llaves, noexistiendo punto y coma tras la llave de cierre. Por ejemplo, el programa que sigue contieneun bloque.

for(i=0;i<100;i++) {mult[i] = 2*(i+1);System.out.println(’’Elemento i ’’ + mult[i]);

}

3.10. Control de flujo

Una de las cualidades de los lenguajes de programacion consiste en que se puede con-trolar el flujo del programa. Las sentencias se ejecutan ordenadamente, pero un bloquede codigo puede ejecutarse solo bajo ciertas condiciones, o bien, hacerlo repetidas veces.Puede determinarse ası el orden de ejecucion de las sentencias segun convenga. Para ellonos servimos de las sentencias estructuradas o de control de flujo.

3.10.1. Sentencia if-else

Se define primero la sentencia if, que tiene el formato:

if(expresion){sentencias}

Actua de la manera siguiente: si expresion tiene el valor true, se ejecuta la sentenciao bloque {sentencias}. Si es false, no se ejecuta el bloque {sentencias}.

Una alternativa mas potente es la sentencia if-else cuyo formato es:

if(expresion){sentencias1}

else{sentencias2}

Si expresion tiene el valor true, se ejecuta el bloque {sentencias1}; en caso contrario,se pasa a ejecutar la sentencia o bloque {sentencias2}.

Veamos un ejemplo:

...if (a < b) {

a = b * 2;System.out.println(’’El resultado es ’’ + a);...

}


Si como resultado de sentencias anteriores, a vale 3 y b vale 5, se ejecuta las sentenciade impresion y da como resultado a = 10. Si por el contrario, a fuera mayor que b, no seentrarıa a ejecutar el bloque y se pasarıa a las siguientes sentencias del programa.

...if (a < b) {

a = b * 2;} else {

a = b + 5;a++;

}

En este caso, si a es menor que b, se ejecuta a = b * 2; en caso contrario, es decir, sia es mayor o igual que b, se pasa a ejecutar el bloque

{ a = b + 5;a++;}

Practica 3.1 (Cajero Automatico). Tratando de disenar el sistema informatico de unaentidad bancaria, se esta realizando un subprograma para el manejo de los cajeros au-tomaticos. La intencion es crear un metodo llamado retirar que tenga las caracterısticassiguientes:

1. Es un procedimiento de autorizacion para la retirada de dinero, de forma que lo unicoque ha de hacer es indicar si autoriza la retirada o no, en funcion de si el saldodisponible es suficiente. Por ello recibe como argumento local al metodo la cantidad.

2. En caso de autorizar se ha de escribir en pantalla que se autoriza la retirada dela cantidad solicitada, y actualizar el saldo actual del usuario, almacenado en unavariable de instancia llamada saldo.

3. En caso de no autorizar la operacion por falta de fondos se ha de escribir en pantallaque se no autoriza la retirada de la cantidad solicitada por falta de fondos, y escribirel saldo actual.

Nota: El cajero solo puede dar billetes de 10, 20, y 50 euros.

Solucion:

// La variable cantidad la defino como entera porque el cajero esta limitado// a los billetes de 10, 20 y 50

public boolean retirar(int cantidad){boolean aut;

// La variable saldo es una variable de instancia accesible desde el metodoif (cantidad >= saldo) {

System.out.println("La operacion esta autorizada");saldo += cantidad;


aut = true;return(aut);

} else {System.out.println("La operacion no se autoriza");System.out.println("Su saldo actual es de " + saldo + " euros");aut = false;return(aut);

}}

3.10.2. Sentencia else-if

La sentencia anterior solo permite elegir entre dos opciones. La sentencia else-if amplıael numero de posibilidades. Su sintaxis es la siguiente:

if(expresion1){sentencias1}

else if(expresion2){sentencias2}

...else

{sentenciasN}

Las expresiones se evaluan en orden; si cualquier expresion es verdadera, se ejecuta lasentencia o el bloque asociado a ella, y se concluye la ejecucion de la sentencia else-if. Solose ejecuta el ultimo else en el caso de que todas las expresiones expresion1, expresion2,. . . , expresion(N-1) sean falsas. Veamos un ejemplo:

...int b = 10;int a;if(a > 1) {

a = b * 2;}else if(a < 2) {

a = b + 5;b++;

}else if(a != 3) {

a += b;}else {

a = b ^ 2;}


Si a cumple alguna de las tres primeras expresiones, se ejecuta la sentencia correspon-diente; en caso contrario, se evaluara la ultima sentencia.

Pudiera ocurrir que fueran ciertas dos o mas expresiones (tomese, por ejemplo, a iguala 1). En este caso, se ejecutarıan solo las sentencias correspondientes a la primera de ellasy se saldrıa del bloque else-if. (En nuestro caso, serıan las sentencias correspondientes ala expresion (a < 2) ).

Practica 3.2 (Manipulacion de rectangulos e intersecciones). Para la realizaciondel ejercicio pueden ser de utilidad los metodos de tipo static de la clase Math, abs, miny max que calculan el valor absoluto de un numero, el valor maximo de entre dos numeros,y el valor mınimo de entre dos numeros, respectivamente.

Crear un clase que se llame Rectangulo y que tenga las caracterısticas siguientes:

1. Pertenece al paquete rectangulo.

2. Se emplea para definir rectangulos paralelos a los ejes de coordenadas, por ello habra cua-tro variables de instancia xi, xs, yi e ys que se corresponden con las coordenadas x ey de las esquinas del rectangulo tal y como se muestra en la Figura 3.1(a). Puedentomar cualquier valor real con la maxima precision posible (tipo double).

3. Dispone de dos variables de instancia mas para almacenar el ancho y alto del rectangu-lo.

4. El primer constructor no recibe ningun argumento y solo reserva espacio en memoriapara las variables de instancia. Hacer referencia al metodo super() de la clase demayor jerarquıa Object.

5. El segundo constructor recibe cuatro argumentos que se corresponden con las coorde-nadas de las esquinas, se llamaran x1, x2, y1, e y2. Se dan en ese orden y el problemaes que tanto para las variables x como para las y no se sabe cual de las dos es ma-yor, y por tanto como asignar los valores a las variables de instancia de la clase. Elconstructor ha de tenerlo en cuenta. Se inicializaran los valores del ancho y el altodentro del constructor.

6. El tercer constructor recibe las coordenadas x e y de la esquina inferior izquierdadel rectangulo ası como los valores del ancho y alto, estos ultimos solo pueden tomarvalores enteros. Se inicializaran los valores de todas las variables de instancia.

7. Tiene un metodo llamado mover que desplaza el rectangulo una cantidad dx a laderecha (si es positivo), y dy hacia arriba (si es positivo) (vease la Figura 3.1(b)).

8. Tiene un metodo llamado dentro que permite saber si un punto dado por sus coor-denadas x e y esta dentro del rectangulo (vease la Figura 3.1(c)).

9. Tiene un metodo llamado menorrec que dado un rectangulo cualquiera, permiteobtener otro rectangulo que tiene una caracterıstica especial, es el menor rectanguloque contiene tanto al rectangulo de la clase como al que se ha dado como dato oargumento al metodo, tal y como se muestra en la Figura 3.1(d).


(a) Definicion de la clase Rectangulo. (b) Efecto que tiene el metodo mover en el rectanguloasociado a la clase.

(c) Comprobacion de si un punto esta dentro delrectangulo.

(d) Menor rectangulo circunscrito a dos dados.

Figura 3.1: Interpretacion grafica de la clase Rectangulo.


10. Por ultimo contiene un metodo llamado intersec, que dado un rectangulo cualquieradevuelve el rectangulo interseccion con el rectangulo asociado a la clase. En este casola casuıstica es complicada, para facilitar el control de flujo en la Figura 3.2 se mues-tran los posibles casos para el calculo de la interseccion. Notese que son mutuamenteexcluyentes.

Para poder emplear esta clase crear la clase Principal definida en el Comentario 2.2,que pertenezca al paquete rectangulo, y que contiene el metodo main(). En ella se realizanlas siguientes acciones:

1. Crear una variable cuadro1 de tipo Rectangulo con los datos (20.0,0.0,0.0,30.0).

2. Escribir las coordenadas en pantalla, ası como su ancho y su alto.

3. Crear una variable cuadro2 de tipo Rectangulo cuyas coordenadas de la esquinainferior izquierda sean (10.0,10.0) y tengan un ancho y un alto de 10 unidades exactas,respectivamente.

4. Escribir las coordenadas de rectangulo almacenado en la variable cuadro2.

5. Desplazar el rectangulo almacenado en la variable cuadro1 5 unidades a la derecha y10 unidades hacia arriba.

6. Escribir las nuevas coordenadas de rectangulo tras su desplazamiento.

7. Comprobar si la esquina inferior izquierda del rectangulo almacenado en la variablecuadro2 esta dentro del rectangulo definido por la variable cuadro1 y escribir uncomentario segun el caso.

8. Declarar e inicializar dos objetos nuevos de la clase Rectangulo en las variablescuadro3 y cuadro4, en el momento de reservar espacio en memoria para los mis-mos ninguna de sus variables de instancia recibira valores.

9. Almacenar en la variable cuadro3 el menor rectangulo circunscrito a los rectangulosalmacenados en las variables cuadro1 y cuadro2.

10. Analogamente, almacenar en la variable cuadro4 el menor rectangulo circunscrito alos rectangulos almacenados en las variables cuadro1 y cuadro2, pero haciendolo deforma diferente al apartado anterior.

11. Escribir en pantalla los resultados obtenidos tanto para cuadro3 como para cuadro4.El resultado sera correcto si ambos coinciden.

12. Declarar e inicializar dos objetos nuevos de la clase Rectangulo en las variablescuadro5 y cuadro6, en el momento de reservar espacio en memoria para los mis-mos ninguna de sus variables de instancia recibira valores.

13. Almacenar en la variable cuadro5 la interseccion de los rectangulos almacenados enlas variables cuadro1 y cuadro2.


Figura 3.2: Posibles casos para el calculo de la interseccion de dos rectangulos.


14. Analogamente, almacenar en la variable cuadro6 la interseccion de los rectangulosalmacenados en las variables cuadro1 y cuadro2, pero haciendolo de forma diferenteal apartado anterior.

15. Escribir en pantalla los resultados obtenidos tanto para cuadro5 como para cuadro6.El resultado sera correcto si ambos coinciden.

Solucion: La solucion de todos los apartados se da a continuacion. En primer lugarse describe la clase Rectangulo que habra de ubicarse en un fichero llamado “Rectangu-lo.java”:

package rectangulo;

public class Rectangulo {double xi,xs,yi,ys;double ancho,alto;

public Rectangulo() {super();

}

public Rectangulo(double x1, double x2, double y1, double y2) {super();if(x1>x2){xs = x1;xi = x2;

}else{xs = x2;xi = x1;

}if(y1>y2){ys = y1;yi = y2;

}else{ys = y2;yi = y1;

}ancho=xs-xi;alto=ys-yi;

}

public Rectangulo(double x1, double y1, int ancho, int alto) {super();xi = x1;yi = y1;xs = xi+Math.abs(ancho);ys = yi+Math.abs(alto);this.ancho=Math.abs(ancho);this.alto=Math.abs(alto);

}


public void mover(double dx,double dy){xi=xi+dx;xs+=dx;yi=yi+dy;ys+=dy;

}

public boolean dentro(double x, double y){boolean in=false;if((x>=xi)&&(x<=xs)&&(y>=yi)&&(y<=ys)){in=true;

}return(in);

}

public Rectangulo menorrec(Rectangulo r) {Rectangulo menor=new Rectangulo();if(xi<=r.xi){menor.xi=xi;

}else{menor.xi=r.xi;

}if(yi<=r.yi){menor.yi=yi;

}else{menor.yi=r.yi;

}menor.xs=Math.max(xs,r.xs);menor.ys=Math.max(ys,r.ys);return(menor);

}

public Rectangulo intersec(Rectangulo r) {Rectangulo inter=new Rectangulo();if(this.dentro(r.xi, r.yi)){inter.xi=r.xi;inter.yi=r.yi;inter.xs=Math.min(xs,r.xs);inter.ys=Math.min(ys,r.ys);return(inter);

}else if(this.dentro(r.xs, r.ys)){inter.xs=r.xs;inter.ys=r.ys;inter.xi=Math.max(xi,r.xi);inter.yi=Math.max(yi,r.yi);return(inter);

}else if(this.dentro(r.xi, r.ys)){inter.xi=r.xi;inter.ys=r.ys;inter.xi=Math.min(xs,r.xs);


inter.yi=Math.max(yi,r.yi);return(inter);

}else if(this.dentro(r.xs, r.yi)){inter.xs=r.xs;inter.yi=r.yi;inter.xi=Math.max(xi,r.xi);inter.yi=Math.min(ys,r.ys);return(inter);

}else if((r.xi<=xi)&&(r.xs>=xs)&&(r.yi<=yi)&&(r.ys>=ys)){inter=this;return(inter);

}else{System.out.println("No existe interseccion");return(inter);

}}

}

La clase principal queda de la siguiente manera:

package rectangulo;

public class Principal {public Principal() {}public static void main(String[] args) {Rectangulo cuadro1=new Rectangulo(0.0,20.0,0.0,30.0);System.out.println("Las coordenadas del cuadro1 son (" + cuadro1.xi+", "

+ cuadro1.yi + ") y (" + cuadro1.xs + ", " + cuadro1.ys + ")");System.out.println("El ancho del rectangulo es " + cuadro1.ancho);System.out.println("El alto del rectangulo es " + cuadro1.alto);Rectangulo cuadro2=new Rectangulo(10.0,10.0,10,10);System.out.println("Las coordenadas del cuadro2 son (" + cuadro2.xi + ", "

+ cuadro2.yi + ") y (" + cuadro2.xs + ", " + cuadro2.ys + ")");cuadro1.mover(5.0,10.0);System.out.println("Las nuevas coordenadas del cuadro1 son (" + cuadro1.xi

+ ", " + cuadro1.yi + ") y (" + cuadro1.xs + ", " + cuadro1.ys + ")");if(cuadro1.dentro(cuadro2.xi, cuadro2.yi)){System.out.println("La esquina inferior izquierda del cuadro 2 "

+ "esta dentro del cuadro1");}else{System.out.println("La esquina inferior izquierda del cuadro 2 "

+ "esta fuera del cuadro1");}Rectangulo cuadro3=new Rectangulo();Rectangulo cuadro4=new Rectangulo();cuadro3=cuadro1.menorrec(cuadro2);System.out.println("El cuadro 2 lo constituyen los puntos (" + cuadro2.xi

+ ", " + cuadro2.yi + ") y (" + cuadro2.xs + ", " + cuadro2.ys + ")");cuadro4=cuadro2.menorrec(cuadro1);System.out.println("El menor rectangulo que contiene a los cuadros 1 y 2 es");


System.out.println("El cuadro 3 lo constituyen los puntos (" + cuadro3.xi+ ", " + cuadro3.yi + ") y (" + cuadro3.xs + ", " + cuadro3.ys + ")");

System.out.println("El cuadro 4 lo constituyen los puntos (" + cuadro4.xi+ ", " + cuadro4.yi + ") y (" + cuadro4.xs + ", " + cuadro4.ys + ")");

Rectangulo cuadro5=new Rectangulo();Rectangulo cuadro6=new Rectangulo();cuadro5=cuadro1.intersec(cuadro2);cuadro6=cuadro2.intersec(cuadro1);System.out.println("El rectangulo interseccion de los puntos 1 y 2 es");System.out.println("El cuadro 5 lo constituyen los puntos (" + cuadro5.xi

+ ", " + cuadro5.yi + ") y (" + cuadro5.xs + ", " + cuadro5.ys + ")");System.out.println("El cuadro 6 lo constituyen los puntos (" + cuadro6.xi

+ ", " + cuadro6.yi + ") y (" + cuadro6.xs + ", " + cuadro6.ys + ")");}

}

La salida del programa queda como:

Las coordenadas del cuadro1 son (0.0, 0.0) y (20.0, 30.0)El ancho del rectangulo es 20.0El alto del rectangulo es 30.0Las coordenadas del cuadro2 son (10.0, 10.0) y (20.0, 20.0)Las nuevas coordenadas del cuadro1 son (5.0, 10.0) y (25.0, 40.0)La esquina inferior izquierda del cuadro 2 esta dentro del cuadro1El cuadro 2 lo constituyen los puntos (10.0, 10.0) y (20.0, 20.0)El menor rectangulo que contiene a los cuadros 1 y 2 esEl cuadro 3 lo constituyen los puntos (5.0, 10.0) y (25.0, 40.0)El cuadro 4 lo constituyen los puntos (5.0, 10.0) y (25.0, 40.0)El rectangulo interseccion de los puntos 1 y 2 esEl cuadro 5 lo constituyen los puntos (10.0, 10.0) y (20.0, 20.0)El cuadro 6 lo constituyen los puntos (10.0, 10.0) y (20.0, 20.0)

3.10.3. Sentencia switch

En este caso, se dispone de varias opciones derivadas de la evaluacion de una unicaexpresion. La sintaxis es la siguiente:

switch(expresion) {case {expresion1-constante1}:

{sentencias1}case {expresion2-constante2}:

{sentencias2}...case {expresionN-constanteN}:

{sentenciasN}default {sentencias}

Cada case lleva una o mas constantes enteras o expresiones constantes enteras. Si uncase coincide con el valor de expresion, la ejecucion comienza ahı. Todas las expresiones


de los case deben ser diferentes. Si ninguna de ellas coincide con expresion se ejecutan lassentencias correspondientes a default. El default es optativo; si no esta y ninguno de loscasos coincide, no se ejecuta ninguna accion.

Ası, el bloque de codigo:

...int b = 10;int a;if (a == 1) {

a = b * 2;}else if (a == 2) {

a = b + 5;b++;

}else if (a == 3) {

a += b;} else {

a = b ^ 2;}

puede reescribirse de la forma siguiente:

...int b = 10;int a;

switch (a) {case 1:

a = b * 2;break;

case 2:a = b + 5;b++;break;

case 3:a+ = b;break;

default:a = b ^ 2;break;

}

Sin embargo, la sentencia switch es mas eficiente.Un punto a destacar es el uso de la sentencia break, la cual provoca una salida inmediata

del switch. Tras ejecutar las sentencias correspondientes a un case, se pasa al siguientecase a menos que se fuerce a salir con la ayuda de la sentencia break.


El siguiente ejemplo puede ilustrar perfectamente el funcionamiento de las sentenciascondicionales if y switch de Java. Se trata de un programa que recibe un numero enterode a lo sumo seis dıgitos, es decir en el rango comprendido entre 0 y 999999, y escribe enpantalla la expresion literal de ese numero. Por ejemplo, la expresion literal del numero284513 es:

doscientos ochenta y cuatro mil quinientos trece

Programa 3.4 (Expresion literal de un numero).El programa tiene dos clases, una para la generacion de la cadena de caracteres que carac-teriza el numero y otra principal que contiene el metodo main() en el que se introduce elnumero deseado y se llama al metodo correspondiente. Las dos clases pertenecen al paqueteexpreliternumero. La primera clase es ConvertirLetras:

package expreliternumero;

public class ConvertirLetras {

public static String Convertir3Digitos(int n) {int unidades, decenas, centenas;String su, sd, sc, respuesta;unidades = n % 10;decenas = (n / 10) % 10;centenas = n / 100;if ( (decenas == 1) && (unidades > 0) && (unidades < 6)) {su = new String("");switch (unidades) {case 1:

sd = new String("once");break;

case 2:sd = new String("doce");break;

case 3:sd = new String("trece");break;

case 4:sd = new String("catorce");break;

case 5:sd = new String("quince");break;

default:sd = new String("");

}}else {switch (unidades) {case 1:

su = new String("uno");


break;case 2:su = new String("dos");break;

case 3:su = new String("tres");break;

case 4:su = new String("cuatro");break;

case 5:su = new String("cinco");break;

case 6:su = new String("seis");break;

case 7:su = new String("siete");break;

case 8:su = new String("ocho");break;

case 9:su = new String("nueve");break;

default:su = new String("");

}switch (decenas) {case 1:if (unidades == 0) sd = new String("diez");else sd = new String("dieci");break;

case 2:if (unidades == 0) sd = new String("veinte");else sd = new String("veinti");break;

case 3:if (unidades == 0) sd = new String("treinta");else sd = new String("treinta y ");break;

case 4:if (unidades == 0) sd = new String("cuarenta");else sd = new String("cuarenta y ");break;

case 5:if (unidades == 0) sd = new String("cincuenta");else sd = new String("cincuenta y ");break;

case 6:


if (unidades == 0) sd = new String("sesenta");else sd = new String("sesenta y ");break;

case 7:if (unidades == 0) sd = new String("setenta");else sd = new String("setenta y ");break;

case 8:if (unidades == 0) sd = new String("ochenta");else sd = new String("ochenta y ");break;

case 9:if (unidades == 0) sd = new String("noventa");else sd = new String("noventa y ");break;

default:sd = new String("");

}}switch (centenas) {case 1:if ( (unidades == 0) && (decenas == 0))sc = new String("cien");

elsesc = new String("ciento ");

break;case 2:sc = new String("doscientos ");break;

case 3:sc = new String("trescientos ");break;

case 4:sc = new String("cuatrocientos ");break;

case 5:sc = new String("quinientos ");break;

case 6:sc = new String("seiscientos ");break;

case 7:sc = new String("setecientos ");break;

case 8:sc = new String("ochocientos ");break;

case 9:sc = new String("novecientos ");break;


default:sc = new String("");

}respuesta = new String(sc);respuesta = respuesta.concat(sd);respuesta = respuesta.concat(su);return (respuesta);

}

public static String ConvertirNumero(int numero) {String respuesta = new String();int nmiles = numero / 1000;if (nmiles > 999) {respuesta = "FUERA DE RANGO";

}else if (nmiles == 0) {respuesta = Convertir3Digitos(numero);

}else if (nmiles == 1) {respuesta = "mil ";respuesta = respuesta.concat(Convertir3Digitos(numero % 1000));

}else {respuesta = Convertir3Digitos(nmiles);respuesta = respuesta.concat(" mil ");respuesta = respuesta.concat(Convertir3Digitos(numero % 1000));

}return (respuesta);

}

}

Mientras que la clase principal queda de la siguiente manera:

package expreliternumero;

public class Principal {

public Principal() {}

public static void main(String[] args) {

int numero= 36879;System.out.println(ConvertirLetras.ConvertirNumero(numero));

}}


3.10.4. Ciclo while

La sentencia while tiene la estructura:

while(expresion){sentencias}

Con ella se ejecuta el bloque {sentencias} mientras el valor de la expresion es true. Elciclo se repite hasta que el valor de expresion toma el valor false. Entonces, el compiladorsale del ciclo.

Hay que tener cuidado de alterar adecuadamente alguno de los elementos que aparecenen expresion dentro del bloque {sentencias}. De no ser ası, el programa no saldrıa nuncade este ciclo.

...int a = 1;while ( a != 15 ) {

a *= 2;a = a + 1;

}...

La variable a comienza tomando el valor 1, distinto de 15. Por tanto, se ejecutan las sen-tencias. Luego a vale 3, que sigue siendo distinto de 15, por lo que se vuelven a ejecutar lassentencias y se repite el proceso hasta llegar a tener a = 15. En este instante, se sale delciclo while y se continua con las sentencias siguientes del programa.

Practica 3.3 (Busqueda de un elemento en una lista). Crear un metodo estatico querealize la busqueda de un numero entero en una matriz ordenada de numeros utilizandosentencias tipo while. Dicha busqueda se basa en el algoritmo de la biseccion, partiendode los elementos que ocupan las posiciones extremas de la matriz se obtiene el elementocentral y se determina en cual de los dos submatrices debe buscarse el numero. Repitiendoel proceso sucesivamente se llega a localizar ese numero, si es que se encuentra. La funciondevuelve la posicion en la que se encuentra el numero dentro de la matriz; en caso de noencontrarse, devuelve -1.

Nota: La longitud de una lista almacenada en una variables cualquiera x, se obtienemediante la llamada al metodo length, que en este caso se emplea como x.length, quedevuelve un entero int con el valor de su longitud. Por otro lado el metodo public staticint floor(double a) de la clase Math proporciona el mayor entero menor que el argumentoa.

Solucion:

En primer lugar se crea una clase con un metodo estatico para realizar la busqueda:

package buscar;

public class Buscar {


public Buscar() {}

public static int Buscar(int x[], int n) {int e1=0;int e2=x.length-1;int centro;if(x[e1]==n)return(e1+1);

else if (x[e2]==n)return(e2+1);

while (e1<e2) {centro=(int) Math.ceil((e1+e2)/2);if(centro==e1) {return(-1);

} else if(x[centro]==n) {return(centro+1);

} else if (x[centro]<n) {e1=centro;

} else {e2=centro;

}}return(-1);

}}

En segundo lugar se genera la clase principal con un ejemplo de busqueda en una listadeterminada:

package buscar;

public class Principal {public Principal() {}public static void main(String[] args) {int lista[] = {1, 4, 7, 14, 23, 56, 61, 92, 150};int numero = 23;int posicion;posicion = Buscar.Buscar(lista,numero);if (posicion == -1) {System.out.println("El numero " + numero + " no esta en la lista.");

} else {System.out.println("El numero " + numero + " esta en la posicion " +

posicion + ".");}

}}

La ejecucion del programa genera la siguiente salida:

El numero 23 esta en la posicion 5.


Veamos a continuacion otro ejemplo.

Practica 3.4 (Conjetura de Collatz).

La conjetura de Collatz asegura que dada la funcion

F (n) =

n2 si n es par

3n+12 si n es impar

con n ∈ Z

la sucesion de valores n, F (n), F (F (n)), F (F (F (n))),... siempre llega a alcanzar el valor1, independientemente del valor de partida n. El programa que se incluye a continuacionpuede servir para comprobar dicha conjetura. La clase Collatz tiene definidos dos metodos,el primero de ellos define la funcion F (n) anterior mediante una sentencia condicional if.Por otro lado, se encuentra el metodo main(), se supone que el primer parametro quereciba es el numero n de partida, aunque se define un numero por defecto para el casoen que no se den argumentos de entrada en el metodo main. Ese primer parametro esalmacenado automaticamente en la variable args[0]. Los argumentos que recibe el metodomain() de cualquier clase son tratados siempre como cadenas de caracteres y almacenadosen una matriz de objetos de la clase String. Si se desea tratarlos de otra forma deben serconvertidos explıcitamente. En este programa ese primer argumento debe ser convertido avalor entero. Una vez obtenido ese valor entero, comienza un ciclo while que finaliza cuandose alcanza el valor 1.

Solucion:

package collatz;

public class Collatz {

public static int F(int x) {if(x%2==1) {

return (3*x+1)/2;} else {

return x/2;}

}

public static void main(String args[]) {int n, i=1;if (args.length >= 1) {Integer argumento = new Integer(args[0]);n=argumento.intValue();

} else {n=231;

}while(n!=1) {


System.out.println( "Iter. " + i + ":" + n );i++;n=F(n);

}System.out.println("SE ALCANZA EL 1 TRAS "+ i +" ITERACIONES");

}}

La forma de pasar los argumentos al metodo main() de una clase depende del entornoy del compilador Java en el que se este trabajando. En algunos casos, cuando se declarael metodo main() con argumentos aparece automaticamente un cuadro de dialogo paraintroducirlos. Tambien puede utilizarse la utilidad javai que forma parte del entorno Java.

Por ejemplo, haciendo la llamada al metodo main() de la clase Collatz al mismo tiempoque se pasa el valor inicial n = 56, se obtiene un resultado como el que se muestra acontinuacion:

Iter. 1:56Iter. 2:28Iter. 3:14Iter. 4:7Iter. 5:11Iter. 6:17Iter. 7:26Iter. 8:13Iter. 9:20Iter. 10:10Iter. 11:5Iter. 12:8Iter. 13:4Iter. 14:2SE ALCANZA EL 1 TRAS 15 ITERACIONES

Practica 3.5 (Comprobador de numeros primos).A continuacion se presenta un ejemplo muy simple de programa Java que permite reconocersi un numero entero es primo o no. El algoritmo es por todos conocido, se trata de comprobarsi el numero tiene algun divisor distinto de la unidad y del propio numero. El unico aspectode la implementacion que merece la pena destacar es la forma de pasar el numero comoargumento del metodo main().

Solucion:

package primo;

public class Primo {


public static void main(String args[]) {long n, i=2;boolean fin=false;if (args.length>=1) {Integer argumento = new Integer(args[0]);n = argumento.intValue();

} else {n = 231;

}while ((i<n)&&(!fin)) {if(n%i==0) {fin = true;

} else {i++;

}}if (fin) {System.out.println("EL NUMERO " + n + " NO ES PRIMO");

} else {System.out.println("EL NUMERO " + n + " ES PRIMO");

}}

}

3.10.5. Ciclo do-while

La estructura de la sentencia do-while es:

do{{sentencias}

}while({expresion});

Mientras en los ciclos while y for, que se vera en la proxima seccion, las condiciones determino se evaluan al principio de cada iteracion, en el ciclo do-while se comprueban alfinal, despues de cada repeticion del ciclo, por lo que el bloque {sentencias} se ejecutasiempre, al menos una vez.

Ası, primero se ejecutan las sentencias del bloque sentencias y despues se evaluaexpresion. Si es verdadera, se vuelve a ejecutar el bloque sentencias, y ası sucesivamente.Cuando expresion toma el valor false se acaba el ciclo.

El ciclo do-while es el menos utilizado. A continuacion, veamos un ejemplo:El bloque while:

int a = 1;while ( a != 15 ) {

a = a + 1;}


equivale al bloque con do-while:

int a = 1;do {

a = a + 1;} while (a != 14);

Es decir, se produce el mismo efecto en ambos casos.

Practica 3.6 (Cuenta atras). Generar un programa java que cuente hacia atras desdeel numero que el usuario introduce en la lınea de mensajes.

Solucion:

public class contar{

public static void main(String args[]){

Integer argumento=new Integer(args[0]);int count=argumento.intValue();do {

System.out.println(count + " ");count = count - 1; //o count--;

} while (count > 0) ;}

}

3.10.6. Ciclo for

Este ciclo actua hasta un cierto lımite impuesto por el programador. Su sintaxis es lasiguiente:

for({iniciacion} ;{limite} ; {incremento}){sentencias}

El ciclo for es equivalente a:

{iniciacion}while({limite}) {

{sentencias}{incremento}

}

Las tres componentes del ciclo for son expresiones; iniciacion e incremento suelenser asignaciones o llamadas a una funcion, y limite, una expresion relacional.

La expresion iniciacion se ejecuta al comienzo del bucle.


La expresion limite indica cuando se ejecuta el bucle y se evalua al comienzo de cadaiteracion, de manera que cuando su valor es true se ejecuta el bloque {sentencia} ysi es false, el ciclo for concluye.

Las sentencias del bloque sentencias se ejecutan en cada ciclo.

Las sentencias del bloque incremento se ejecutan al final de cada iteracion o ciclo.

Cualquiera de esta expresiones se puede omitir.El ciclo for es frecuente en la iniciacion de los elementos de un matriz:

int mult[];mult = new int[100];for(int i=0;i<100;i++) {

mult[i] = 2*(i+1);}

Practica 3.7 (Escritura de numeros primos de 2 a 1000). Escribir todos los numerosprimos entre 2 y 1000 usando el ciclo for, suponiendo que tenemos un metodo tipo staticllamado check(long a) de la clase Primo que devuelve una variable booleana con valorverdadero si el numero es primo y falso si no lo es.

Solucion:

public class primos {

public static void main(String args[]){int STOP = 1000;int number = 2;boolean isPrime;

for (int i=number;i<=STOP;i++) {isPrime = Primo.check((long) i);if (isPrime) {

System.out.println(i);}

}}

Practica 3.8 (Serie de Fibonacci). Utilizando el ciclo for, construir un programa quegenere la sucesion de Fibonacci

1, 1, 2, 3, 5, 8, . . .

cuyos terminos se obtienen como suma de los dos anteriores.Solucion:


public class Fibonacci {public static void main(String[] args) {int xn, x0 = 0, x1 = 1;int limite = 20for(int i = 1; i <= limite; i++) {xn = x0 + x1;System.out.print(xn + " ");x0 = x1;x1 = xn;

}System.out.println();

}}

Practica 3.9 (U). tilizando el ciclo for, construir una aplicacion que vaya escribiendo enla consola Java los argumentos introducidos en la lınea de comando. Y otra aplicacion quelos escriba en el sentido opuesto al que se escribieron.

Solucion:

En primer lugar la escritura normal:

public class Escribir {public static void main(String[] args) {int i = 0;for(i =0;i< args.length;i++) {System.out.print(args[i] + " ");i++;

}System.out.println();

}}

Y en segundo lugar la inversa:

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

for(int i = args.length-1; i >= 0; i--){for(int j=args[i].length()-1;j>=0;j--){

System.out.print(args[i].charAt(j));}

System.out.print(" ");}System.out.println();

}}

Practica 3.10 (Generacion de piramides mediante de bucles anidados). Comoejemplo de la utilizacion de los ciclos for de Java y de la posibilidad de anidamiento de


unos ciclos dentro de otros, se presenta a continuacion un programa muy simple que permitegenerar piramides de dıgitos como la que puede verse a continuacion.

1232

345434567654567898765678901098767890123210987

890123454321098901234567654321090123456789876543210

Esta piramide tiene una altura de 10 filas, sin embargo, pueden construirse piramides deotras alturas sin mas que pasarlas como argumento al metodo main() de la clase Piramide,en caso de no hacerlo, la altura por defecto es 10.

Solucion:

package piramide;

public class Piramide {

public static void main(String args[]) {int i, j, k, m;int altura;if (args.length >= 1) {Integer argumento = new Integer(args[0]);altura = argumento.intValue();

}else {altura = 10;

}for(i=1,m=1;i<=altura;i++,m+=2) {for (j=1;j<=altura-i;j++) {System.out.print(" ");

}for (k=i;k<=m;k++) {System.out.print(k % 10);

}for (j=m-1;j>=i;j--) {System.out.print(j % 10);

}System.out.println("");

}}

}


Practica 3.11 (Multiplicacion de matrices). Generar un programa Java con las si-guientes clases:

La clase Matriz con dos constructores diferentes, un metodo Mostrar() para visu-alizar la matriz en la pantalla, y un metodo Multiplicar que permita la multiplicacionmatricial de dos matrices:

Cij =m∑

k=1

AikBkj .

La clase Principal con el metodo main() en el que se definen tres matrices, las dosprimeras son

A =

2 1 0−1 3 2

4 1 −1

y B =

2 35 41 2

y la tercera es el resultado de multiplicar las anteriores, es decir:

C =

9 1015 1312 14

Solucion:

La clase matriz que implementa el metodo mostrar y producto se lista a continuacion:

package matriz;

public class Matriz {int nfilas, ncolumnas;float x[][];

public Matriz(float m[][]) {nfilas=m.length;ncolumnas=m[0].length;x=m;

}

public Matriz(int n, int m) {nfilas=n;ncolumnas=m;x=new float[n][m];

}

public void Mostrar() {int i,j;for(i=0;i<nfilas;i++) {for(j=0;j<ncolumnas;j++)System.out.print(x[i][j]+" ");

System.out.println("");}


}

public static Matriz Multiplicar (Matriz A, Matriz B) {int i,j,k;float suma;Matriz C= new Matriz (A.nfilas, B.ncolumnas);for(i=0;i<A.nfilas;i++)for(j=0;j<B.ncolumnas;j++){suma=0;for(k=0;k<A.ncolumnas;k++)suma+=A.x[i][k]*B.x[k][j];

C.x[i][j]=suma;}

return(C);}

}

Mientras que la clase Principal queda de la siguiente manera:

package matriz;

public class Principal {public Principal() {}

public static void main(String args[]) {float x[][]={{2,1,0},{-1,3,2},{4,1,-1}};float y[][]={{2,3},{5,4},{1,2}};Matriz A=new Matriz(x);Matriz B=new Matriz(y);Matriz C;System.out.println("Producto:");C=Matriz.Multiplicar(A,B);C.Mostrar();

}}

De forma que la salida del programa queda como:

Producto:9.0 10.015.0 13.012.0 14.0

Practica 3.12 (Rotaciones de palabras). El ejemplo que sigue muestra un sencilloprograma Java que permite obtener todas las rotaciones de una palabra; por ejemplo, dadala palabra Bienvenido, sus rotaciones serıan las palabras:

ienvenidoB envenidoBi nvenidoBie venidoBien enidoBienvnidoBienve idoBienven doBienveni oBienvenid Bienvenido


El programa recibe la palabra a rotar en los argumentos de su metodo main() y obtiene lamatriz de caracteres asociada con la llamada al metodo toCharArray() de la clase String.A partir de ahı se entra en un ciclo, de manera que en cada iteracion el primer caracter espasado al ultimo lugar y los siguientes adelantan una posicion.

Solucion:

public class Rotaciones {

public static void main(String args[]) {if (args.length>0) {int i,j,longitud=args[0].length();char cadena[] = args[0].toCharArray();char temp;for (j=0;j<longitud;j++){temp=cadena[0];for (i=1;i<longitud;i++) {

cadena[i-1]=cadena[i];}cadena[longitud-1]=temp;System.out.println(cadena);

}}

}}

Practica 3.13 (Simulador de pago). El programa que se presenta a continuacion utilizala funcion random() de la clase Math para generar aleatoriamente numeros entre 0 y 1. Siesos numeros son multiplicados por 50 y convertidos los resultados a tipo int se obtienennumeros enteros aleatorios en el rango comprendido entre 0 y 50.

En una matriz bidimensional se almacenan los valores de las distintas monedas y billetesde curso legal en Espana junto con numeros aleatorios entre 0 y 50 que indican las disponi-bilidades de cada uno de los tipos de monedas y billetes. Tras mostrar en pantalla toda esainformacion, se entra en un ciclo while en el que se generan, tambien de forma aleatoria,cantidades a pagar entre 0 y 50000 y se indica la forma de hacerlo con las monedas y billetesdisponibles. El ciclo termina cuando una cantidad no puede ser abonada ıntegramente.

Solucion:

package dinero;

import java.util.*;

public class Dinero {public static void main(String args[]) {int i,Total=0, pago, resta, m;boolean disponible=true;


int x[][] = new int[12][2];for (i=0;i<12;i++) {x[i][0]=1+5*i;x[i][1]=(int)(50*Math.random());

}for(i=0;i<12;i++)Total+=x[i][0]*x[i][1];

System.out.println("Cantidad total disponible: "+Total+" pts");for(i=0;i<8;i++)System.out.println(x[i][1]+" monedas de "+x[i][0]+" pts");

for(i=8;i<12;i++)System.out.println(x[i][1]+" billetes de "+x[i][0]+" pts");

while(disponible) {pago=(int)(50000*Math.random());resta=pago;System.out.println("Pago de "+pago+" pts =");i=11;while ((resta!=0)&&(i>=0)) {if(resta>=x[i][0]){m=Math.min(resta/x[i][0],x[i][1]);if (m!=0){resta-=m*x[i][0];x[i][1]-=m;System.out.print(" "+m+"*"+x[i][0]);

}}i--;

}if (resta!=0){System.out.println(" Faltan "+resta+" pts.");disponible=false;

}elseSystem.out.println("");

}}

}

La ejecucion de este programa producirıa una salida similar a la siguiente:

Cantidad total disponible: 509612 pts12 monedas de 1 pts22 monedas de 5 pts49 monedas de 10 pts20 monedas de 25 pts2 monedas de 50 pts2 monedas de 100 pts


46 monedas de 200 pts0 monedas de 500 pts11 billetes de 1000 pts44 billetes de 2000 pts0 billetes de 5000 pts40 billetes de 10000 ptsPago de 35950 pts =3*10000 2*2000 1*1000 4*200 1*100 1*50

Pago de 29966 pts =2*10000 4*2000 1*1000 4*200 1*100 1*50 1*10 1*5 1*1

Pago de 16818 pts =1*10000 3*2000 4*200 1*10 1*5 3*1

Pago de 31773 pts =3*10000 1*1000 3*200 6*25 2*10 3*1

Pago de 8089 pts =4*2000 3*25 1*10 4*1

Pago de 2929 pts =1*2000 4*200 5*25 1*1 Faltan 3 pts.

3.10.7. Sentencias para manejar excepciones

Cuando se produce un error, el metodo puede lanzar un mensaje de excepcion paraavisar del mismo. Esto se consigue con la sentencia throw. El metodo tambien puede usarlas sentencias try, catch y finally para manejar la excepcion. Las excepciones se tratanen detalle en [1].

3.10.8. Sentencias de bifurcacion

La sentencia break obliga al programa a pasar al siguiente ciclo. Otra forma de usarbreak es la siguiente.

Supongase que en el programa se tiene la sentencia siguiente:

breakHere: {sentencia}

Para pasar directamente a esta lınea del programa basta con escribir:

break breakHere;

Por otra parte, la sentencia continue se usa dentro de un ciclo para iniciar la siguienteiteracion del ciclo que la contiene. De esta manera se evitan ejecutar las sentencias del ciclosiguientes a continue. Por ejemplo, con las sentencias:

for (i = 0; i < n; i++) {if(a[i] < 0)continue;

...}


se ignoran los valores negativos.La sentencia return finaliza la ejecucion de la funcion que la contiene y devuelve el

control a la sentencia siguiente de la funcion de llamada. Ademas, puede devolver un valor.En este ultimo caso, la sintaxis es:

return expresion;

3.11. El metodo main

El metodo main() es el metodo de arranque de toda aplicacion en lenguaje Java. Elnombre se hereda del lenguaje C, en el que la existencia del bloque de codigo main() esforzosa.

De hecho, puede ejecutarse una clase cualquiera sin mas que incluir en ella el metodomain(). Cuando se trata de aplicaciones, bastara implementarlo en una de las clases (la quese arranca), y no hay que incluirlo en el resto de las clases definidas en el programa.

El metodo main() es la herramienta de que dispone el lenguaje Java para decirle alordenador que hacer tras arrancar una aplicacion o clase. Por ello, es llamado automatica-mente por el entorno Java al arrancar la clase o aplicacion, controla el flujo del programadesde su comienzo, asigna los recursos que se necesiten y se encarga de llamar a cualquierotro metodo que se requiera.

La forma de declarar el metodo main() es la siguiente:

public static void main(String args[]) {}

public : puede ser llamado por cualquier objeto.

static : es un metodo de clase, es decir, esta asociado mas bien a la clase que a unejemplar de la clase.

void : no devuelve ningun valor.

args[] : es un objeto de la clase String en el que el usuario pasa la informacion a laclase.

Deben tenerse en cuenta las siguientes observaciones:

El metodo main() es un metodo de clase, por lo que si se quieren invocar metodos dela clase, se debe crear un ejemplar de la misma.

Si se disena una interfase de usuario, se debe crear un espacio y una ventana dondecolocar el applet creado.

A continuacion se muestra un ejemplo:

Programa 3.5 (Ejemplo del uso del metodo main).


public class Checkboxes extends Applet {

Checkbox a, b, c;Checkbox x, y, z;CheckboxGroup group;

public void init() {a = new Checkbox();b = new Checkbox(’’B’’);c = new Checkbox(’’C’’);group = new CheckboxGroup();x = new Checkbox(’’X’’, group, true);y = new Checkbox(’’Y’’, group, false);z = new Checkbox(’’Z’’, group, false);

setLayout(new GridLayout(3,2));add(a);add(x);add(b);add(y);add(c);add(z);validate();

}

public static void main() {// Se crea una ventanaFrame ventana = new Frame (’’Checkboxes’’);

// Se crea un ejemplar de la clase }Checkboxes checkboxes = new Checkboxes();

// Se invoca un m\’etodo de la clase }checkboxes.init();

// Se a\~{n}ade el applet a la ventana }ventana.add(’’Center’’,checkboxes);ventana.show();

}}

3.11.1. Llamada al metodo main()

Cuando el entorno Java ejecuta la clase o aplicacion, lo primero que hace es llamaral metodo main(), el cual invoca al resto de metodos necesarios para hacer funcionar laaplicacion.

Si la clase a compilar no tiene implementado un metodo main(), el proceso se detieney se envıa el mensaje de error:

In class NombreClase : void main(String args[]) is not defined

donde NombreClase es el nombre de la clase que genera el error.


3.11.2. Argumentos de la lınea de comandos

Los programas pueden necesitar informacion para poder ejecutarse segun los deseosdel usuario. Una de las herramientas que lo permiten son los argumentos de la lınea decomandos. Estos argumentos son caracteres o cadenas de caracteres que el usuario teclea yque permiten modificar el comportamiento de la aplicacion sin necesidad de recompilarla.

El metodo main():public static void main(String args[]) acepta como unico argumento una matriz

de elementos de la clase String, que se llaman argumentos de la lınea de comandos, puestoque se les puede dar valores al comienzo de la ejecucion, mediante un cuadro de dialogoque se muestra al usuario al ejecutar el programa Java o en el comando de arranque de laaplicacion (entornos UNIX). Mediante estos argumentos se puede enviar informacion a laaplicacion.

Por tanto, el programa Java debe ser capaz de leer los argumentos y programarlos. Elproceso es el siguiente:

Al ejecutar una aplicacion, el sistema pasa los argumentos tecleados por el usuario almetodo main de la aplicacion, mediante una matriz de objetos de tipo String. Cada unode los argumentos es uno de los elementos de la matriz.

Programa 3.6 (Ejemplo de un programa Java con argumentos).

import java.awt.*;

public class Imprimir {public static void main(String args[]) {for(int i=0; i<args.length; i++) {System.out.println(args[i]);

}}

}

Tras compilar el fichero donde se define esta clase e iniciar la ejecucion del programaen algunos entornos como Macintosh, se muestra al usuario un cuadro de dialogo, medianteel cual el usuario introduce los argumentos de la lınea de comandos, que pasan a ser losargumentos del metodo main, es decir, los componentes de la matriz args.

A continuacion se muestran dos ejemplos donde se manipulan los argumentos:

Programa 3.7 (Ejemplo de un programa Java con argumentos).

import java.awt.*;

public class Imprimir {public void algoritmo1() {

System.out.println(’’Se ejecuta el algoritmo 1’’);}


public void algoritmo2() {System.out.println(’’Se ejecuta el algoritmo 2’’);

}

public static void main(String args[]) {Imprimir imprimir = new Imprimir();for(int i=0; i<args.length; i++) {if (args[i].equals(’’-alg1’’)) {imprimir.algoritmo1();

} else if (args[i].equals(’’-alg2’’)) {imprimir.algoritmo2();

} else {}

}}

}

Si el usuario introduce como unico argumento -alg1, el programa ejecuta el metodoalgoritmo1.

Si se introduce el argumento -alg2 se ejecuta el metodo algoritmo2.En el caso de que se introduzcan ambos argumentos, se ejecutarıan los dos algoritmos

de la aplicacion.Al introducir cualquier otro argumento, la aplicacion no realiza ninguna accion.

Practica 3.14 (Cambio de la base de numeracion). El programa siguiente permiteobtener la expresion de un numero entero en cualquier base de numeracion comprendidaentre 2 y 16. El resultado es guardado en una cadena de caracteres que puede estar formadapor dıgitos y las letras A, B, C, D, E y F dependiendo del numero entero y la base elegida.

En el programa se define la clase CambioBase con dos metodos:

El metodo digito() permite obtener el dıgito asociado a un numero entre 0 y 16 perotratado como un caracter.

El metodo main(), en el que se encuentra implementado el algoritmo, recibira dosargumentos: el numero entero y la base de numeracion. El algoritmo consta de unbucle while en el que se van calculando los sucesivos restos de dividir el numero entrela base y obtener de esta forma los diferentes dıgitos. Finalmente, es preciso invertirla cadena de caracteres resultante antes de presentarla en el monitor.

La forma de pasar los argumentos al metodo main() de una clase depende del entornoy del compilador Java sobre el que se este trabajando. En algunos casos, cuando se declarael metodo main() con argumentos, aparece automaticamente un cuadro de dialogo paraintroducirlos. Tambien puede utilizarse la utilidad javai que forma parte del entorno dedesarrollo Java. Una vez pasados los argumentos, son tratados como cadenas de caracteresy almacenados en una matriz de objetos de la clase String, el primero sera args[0],


el segundo args[1], y ası sucesivamente. Se puede saber cuantos argumentos han sidopasados al metodo main() por el valor de la expresion args.length. Cuando se quierentratar los argumentos recibidos no como cadenas de caracteres sino de otra forma, debenser convertidos explıcitamente. En este programa, los dos argumentos representan numerosenteros y son convertidos a ese tipo con el constructor de la clase Integer y el metodointValue() de esa misma clase.

Solucion:

import Java.io.*;

public class CambioBase {

public static char digito(int c) {char a;if(c<10) {a=(char)(’0’+c);

} else {switch (c) {case 10: a=’A’; break;case 11: a=’B’; break;case 12: a=’C’; break;case 13: a=’D’; break;case 14: a=’E’; break;case 15: a=’F’; break;default: a=’X’;

}}return(a);

}

public static void main(String args[]) {int num, base, c, i=0, j, len;char caux;if(args.length>=2) {Integer argumento1 = new Integer(args[0]);Integer argumento2 = new Integer(args[1]);char resultado[] = new char[50];num = argumento1.intValue();base = argumento2.intValue();while (num/base!=0) {c=num%base;resultado[i++] = digito(c);num = num/base;

}resultado[i] = digito(num);len = i+1;for(i=0,j=len-1;i<len/2;i++,j--) {caux=resultado[j];resultado[j]=resultado[i];


resultado[i]=caux;}System.out.println( argumento1 + " en base " +

argumento2 + " = " + resultado);}elseSystem.out.println(’’Datos incompletos’’);

}}

Convenios para los argumentos de la lınea de comandos

Existen tres tipos de argumentos de la lınea de comandos, siguiendo el convenio UNIX:

Palabras (opciones): arg1, −algoritmo. Pueden usarse como se ha visto en elejemplo anterior.

if (args[i].equals("alg1"))imprimir.algoritmo1();

Argumentos que requieren, a su vez, otros argumentos. Por ejemplo, el ar-gumento −resultado puede facilitar la impresion del resultado final de la aplicacionen algun fichero que habra que especificar. Normalmente, siempre que un argumentonecesite mas informacion, esta viene dada por el siguiente argumento.

“Flags”: son argumentos de un solo caracter, que modifican el comportamiento delprograma. Se pueden escribir separadamente en cualquier orden:−a−b o concatenados:−ab.

Ademas deben seguirse las reglas siguientes para el uso de estos argumentos:

El caracter − precede a las opciones, “flags” o series de “flags”.

Los argumentos se pueden dar en cualquier orden, excepto en el caso de que necesitenotros argumentos.

Los “flags” pueden enumerarse de cualquier manera, con o sin separacion.

Los nombres de ficheros se escriben generalmente al final.

El programa muestra un mensaje de error si no reconoce algun argumento.

Conviene tener tambien en cuenta que el sistema falla cuando se tiene un numero consider-able de argumentos.


3.12. Los Paquetes estandar de Java

Las clases e interfases implementadas en Java estan agrupadas en diferentes paquetes,los cuales se listan a continuacion:

Paquete java.lang: Se trata del paquete que contiene las clases basicas. Al contrarioque el resto de paquetes, para ser utilizado no necesita importarse, ya que Java loimporta automaticamente.

Paquete java.io: Se trata de un paquete que permite la lectura y escritura de datosprocedentes de diferentes fuentes, tales como ficheros, cadenas de caracteres, memoria,matrices de octetos, etc., de forma unificada.

Paquete java.util: Es un paquete que contiene clases varias, tales como clases quetratan estructuras de datos genericas, tratamiento de bits, consulta del tiempo, trabajocon fechas en diferentes formatos, manipulacion de cadenas de caracteres, generacionde numeros aleatorios, acceso a las propiedades del sistema, etc.

Paquete java.net: Es el paquete que soporta todo lo relacionado con la red, incluyen-do los URLs, TCP sockets, UDP sockets, direcciones IPC y un convertidor de binario atexto y viceversa.

Paquete java.awt: Es el paquete que suministra la interfase de comunicacion con elusuario, que se llama (Abstract Window Toolkit). De ahı su extension awt. Incluyelos elementos basicos, tales como ventanas, cuadros de dialogo, botones, marcas, listas,menus, barras de deslizamiento y campos de texto.

Paquete java.awt.image: Paquete que sirve para tratar los datos de imagenes. Per-mite fijar el modelo de color, cropping, filtrado del color, asignacion de puntos ygrabbing snapshots.

Paquete java.awt.peer: Es el paquete que conecta las componentes a sus corres-pondientes implementaciones independientes de la plataforma.

Paquete java.applet: Paquete que permite la construccion de pequenos programaso applets. Tambien suministra informacion sobre un documento de referencia deapplets, sobre otros applets en dicho documento y permite a un applet emitirsonidos.

3.13. Applets y aplicaciones

El lenguaje Java esta disenado para desarrollar tanto aplicaciones como pequenos progra-mas, llamados applets. Un applet solo puede ejecutarse mediante un programa auxiliar, yasea este un navegador, como Netscape Navigator, o un visor de applets, como AppletView-er. Por el contrario, una aplicacion puede ejecutarse independientemente. A continuacionse muestran dos ejemplos, uno de applet y otro de aplicacion, y se comentan las diferenciasentre ambos.


3.13.1. Applets

La implementacion de un Applet en una pagina web se hace mediante el comando<APPLET> siendo su sistaxis mınima:

<APPLET CODE=MiApplet.classWIDTH=n HEIGHT=m>

</APPLET>

Donde:

El valor del parametro CODE es el fichero donde se encuentra definido el applet.

Los parametros WIDTH y HEIGHT determinan las dimensiones en puntos de la regionreservada para el applet en la pagina Web.

La sintaxis completa del comando es la siguiente:

<APPLET CODEBASE=Ejemplos/AppletsCODE=MiApplet.classWIDTH=n HEIGHT=mALT="Texto alternativo"NAME=nombreALIGN=TipoAlineamientoVSPACE=v HSPACE=h>

<PARAM NAME=NombreParam1 VALUE=valor1><PARAM NAME=NombreParam2 VALUE=valor2><PARAM NAME=NombreParam3 VALUE=valor3>......................................</APPLET>

donde

CODEBASE indica el URL absoluto o relativo del fichero en el que se define el applet,cuando este se encuentra en un directorio diferente al que contiene el documentoHTML. Es posible tambien integrar applets definidos en maquinas remotas.

El comando <PARAM> se utiliza para pasar argumentos a los applets.

ALT permite indicar un texto alternativo a mostrar si el navegador utilizado no escompatible con Java.

NAME da un nombre al applet.

ALIGN indica el tipo de alineamiento con respecto a la pagina.

VSPACE y HSPACE indican las distancias en pixels entre la region reservada para elapplet y el resto de la pagina.

Cualquier texto o codigo HTML que se encuentre entre los comandos <APPLET> y</APPLET> y que no sea un comando <PARAM> se entiende como codigo alternativoa interpretar cuando el navegador no soporte Java.


A continuacion se muestra un ejemplo de applet. Como puede verse, basta crear unasubclase de la clase Applet e incorporar en ella el metodo init(), en el que debera indicarselo que hace dicho applet (en nuestro ejemplo simplemente se anade un boton).

Programa 3.8 (Ejemplo de applet).

import java.applet.Applet;import java.awt.*;

public class EjemploApplet extends Applet{Button boton;public void init(){boton=new Button(’’OK’’);add(’’South’’,boton);

}}

Este codigo debe escribirse primero en un fichero llamado EjemploApplet.java, y a con-tinuacion compilarse (en el caso del paquete de desarrollo de SUN arrastrando el iconoEjemploApplet.java sobre el icono Java Compiler). La compilacion crea un fichero llama-do EjemploApplet.class, que contiene la clase compilada. Para poder ejecutarlo hace faltacrear tambien un fichero EjemploApplet.html, en el mismo directorio que el de la claseEjemploApplet.class, que se encargue de arrancar el applet. Por ejemplo, dicho ficheropodrıa tener el contenido siguiente:

<HTML><HEAD>

<TITLE> </TITLE></HEAD><BODY>

<APPLET CODE=’’EjemploApplet.class’’ WIDTH=100 HEIGHT=100></APPLET></BODY>

</HTML>

Para ejecutar el applet hay distintas opciones:

1. Arrastrar el fichero HTML sobre el icono Applet Viewer.

2. Dar el URL del fichero HTML creado. Por ejemplo, si el fichero “EjemploApplet.html”estuviera en la carpeta “Ejemplos” del disco “Disco Rigido” bastarıa dar el URL:

file:/Disco Rigido/Ejemplos/EjemploApplet.html

Practica 3.15 (Transformacion de aplicacion a Applet). Transformar la aplicacionde la Practica 3.2 en un applet. A continuacion se muestra el codigo del Applet que sustituyea la clase Principal:


package rectangulo;

import java.awt.*;import java.awt.event.*;import java.applet.*;

public class Applet1 extends Applet {private boolean isStandalone = false;

//Get a parameter valuepublic String getParameter(String key, String def) {return isStandalone ? System.getProperty(key, def) :(getParameter(key) != null ? getParameter(key) : def);

}

//Construct the appletpublic Applet1() {}

//Initialize the appletpublic void init() {try {jbInit();Rectangulo cuadro1=new Rectangulo(0.0,20.0,0.0,30.0);System.out.println("Las coordenadas del cuadro1 son (" + cuadro1.xi+", "

+ cuadro1.yi + ") y (" + cuadro1.xs + ", " + cuadro1.ys + ")");System.out.println("El ancho del rectangulo es " + cuadro1.ancho);System.out.println("El alto del rectangulo es " + cuadro1.alto);Rectangulo cuadro2=new Rectangulo(10.0,10.0,10,10);System.out.println("Las coordenadas del cuadro2 son (" + cuadro2.xi + ", "

+ cuadro2.yi + ") y (" + cuadro2.xs + ", " + cuadro2.ys + ")");cuadro1.mover(5.0,10.0);System.out.println("Las nuevas coordenadas del cuadro1 son (" + cuadro1.xi

+ ", " + cuadro1.yi + ") y (" + cuadro1.xs + ", " + cuadro1.ys + ")");if(cuadro1.dentro(cuadro2.xi, cuadro2.yi)){System.out.println("La esquina inferior izquierda del cuadro 2 "

+ "esta dentro del cuadro1");}else{System.out.println("La esquina inferior izquierda del cuadro 2 "

+ "esta fuera del cuadro1");}Rectangulo cuadro3=new Rectangulo();Rectangulo cuadro4=new Rectangulo();cuadro3=cuadro1.menorrec(cuadro2);System.out.println("El cuadro 2 lo constituyen los puntos (" + cuadro2.xi +

", " + cuadro2.yi + ") y (" + cuadro2.xs + ", " + cuadro2.ys + ")");cuadro4=cuadro2.menorrec(cuadro1);System.out.println("El menor rectangulo que contiene los cuadros 1 y 2 es");System.out.println("El cuadro 3 lo constituyen los puntos (" + cuadro3.xi +

", " + cuadro3.yi + ") y (" + cuadro3.xs + ", " + cuadro3.ys + ")");System.out.println("El cuadro 4 lo constituyen los puntos (" + cuadro4.xi +

", " + cuadro4.yi + ") y (" + cuadro4.xs + ", " + cuadro4.ys + ")");Rectangulo cuadro5=new Rectangulo();Rectangulo cuadro6=new Rectangulo();cuadro5=cuadro1.intersec(cuadro2);cuadro6=cuadro2.intersec(cuadro1);System.out.println("El rectangulo interseccion de los puntos 1 y 2 es");System.out.println("El cuadro 5 lo constituyen los puntos (" + cuadro5.xi +

", " + cuadro5.yi + ") y (" + cuadro5.xs + ", " + cuadro5.ys + ")");System.out.println("El cuadro 6 lo constituyen los puntos (" + cuadro6.xi +

", " + cuadro6.yi + ") y (" + cuadro6.xs + ", " + cuadro6.ys + ")");

}catch(Exception e) {e.printStackTrace();

}}

//Component initializationprivate void jbInit() throws Exception {}

//Start the appletpublic void start() {}

//Stop the appletpublic void stop() {}

//Destroy the appletpublic void destroy() {}

//Get Applet informationpublic String getAppletInfo() {return "Applet Information";

}

//Get parameter infopublic String[][] getParameterInfo() {return null;

}}


La clase generada se introduce en una pagina web de la siguiente manera:

<html><head><title>HTML Test Page</title></head><body>applet.Applet1 will appear below in a Java enabled browser. <appletcodebase = "."code = "rectangulo.Applet1.class"name = "TestApplet"width = "400"height = "300"hspace = "0"vspace = "0"align = "middle"

></applet></body></html>

Restricciones de los applets

Por razones de seguridad los applets tienen varias restricciones. Un applet no puede:

1. Cargar librerıas o definir metodos nativos.

2. Leer ni escribir ficheros en el sistema anfitrion que esta ejecutandolo.

3. Hacer conexiones de red, excepto al sistema anfitrion del que procede.

4. Ejecutar cualquier programa en el sistema anfitrion que esta ejecutandolo.

5. Leer ciertas propiedades del sistema.

Cada navegador tiene un objeto de tipo SecurityManager que implementa sus medidas deseguridad. Cuando un objeto de este tipo detecta una violacion de tales medidas, envıa unaexcepcion de tipo SecurityException para que el sistema proceda en consecuencia.

3.13.2. Aplicaciones

A continuacion se muestra un ejemplo de aplicacion. Para crearla hay que crear unfichero con el nombre EjemploAplicacion.java, y entre sus clases debe encontrarse unaclase public class EjemploAplicacion en la cual hay que definir el metodo main(), quees necesario para arrancar la aplicacion.Anteriormente en este capıtulo se ha descrito condetalle este metodo. En dicho metodo main() es necesario crear un ejemplar de dicha clase,


puesto que este no se crea automaticamente, tal como sucede al ejecutar un applet en unnavegador o en un visor de applets. Puesto que, al contrario de lo que sucede en el caso delos applets, en una aplicacion, tampoco se crea automaticamente un lugar donde mostrar lainterfase, es necesario crear explıcitamente una ventana en la que se muestre dicha interfase.Para ello se crea una subclase de la clase Frame. Mientras que en el caso de los applets, lasdimensiones de la ventana en la que se muestra se dan en el fichero HTML, dando valores alos parametros WIDTH y HEIGHT, en una aplicacion estas dimensiones se dan medianteel metodo resize de la clase Frame. Ademas, para que se muestre la ventana es necesarioinvocar el metodo show().

Programa 3.9 (Ejemplo de aplicacion).

import java.awt.*;

public class EjemploAplicacion extends Frame{Button boton;public EjemploAplicacion(){boton=new Button(’’OK’’);add(’’South’’,boton);}public static void main(String[] args){EjemploAplicacion ejem=new EjemploAplicacion();ejem.resize(100,100);ejem.show();

}}

Una vez creado el fichero EjemploAplicacion.java, este se compila arrastrando el iconocorrespondiente sobre el icono Java Compiler, con lo cual se crea el fichero EjemploAplicacion.class.Finalmente, pulsando dos veces sobre su icono se arranca la aplicacion.

Por tanto, las principales diferencias entre los applets y las aplicaciones pueden resumirseen:

1. Mientras que las aplicaciones arrancan solas, los applets necesitan programas auxil-iares (otras aplicaciones) para su arranque.

2. Mientras que las aplicaciones no tienen limitaciones en cuanto a las operaciones arealizar, los applets estan sometidos a restricciones por motivos de seguridad.

3. Las aplicaciones arrancan con el metodo main y los applets con el metodo init.

4. Al ejecutar un applet se crea automaticamente un ejemplar de la clase que lo imple-menta, cosa que no ocurre con las aplicaciones, que deben crear sus ejemplares en elmetodo main.

5. Al ejecutar un applet se crea automaticamente una ventana donde mostrar el applet,mientras que en las aplicaciones esta debe ser creada explıcitamente.


6. Las dimensiones de la ventana en la que se muestra un applet se definen en el ficheroHTML que lo arranca, mientras que en el caso de las aplicaciones debe hacerse en elprograma Java, mediante el metodo resize.

3.14. Mas practicas resueltas

Practica 3.16 (Eliminacion de caracteres). Escribir un programa que elimine carac-teres consecutivos iguales de una cadena de entrada. Tendra las caracterısticas siguientes:

1. Usad s.toCharArray() para convertir una cadena de caracteres s en una matriz decaracteres.

2. Usad new String(t,offset,length) para convertir una matriz de caracteres t enuna cadena de caracteres.

3. Recordad que t.length es el tamano del array.

4. Comprobar que el numero de argumentos es uno y que la longitud de la cadena no escero.

Solucion:

import java.io.*;

class Eliminar {static char t[];

static public void eliminar() {int n = t.length;int j = 0;for (int i = 0; i < n ; i++) {

char c = t[j++] = t[i];while (i < n && c == t[i] ) i++;

}t = new String(t,0,j).toCharArray();

}

public static void main(String args[]) {

if (args.length != 1) {System.out.println("eliminar

necesita un argumento de tipo string");}if (args[0].length() <= 0) {System.out.println("eliminar

necesita un argumento no vacio");}

t = args[0].toCharArray();


System.out.println(t + " -> ");eliminar();System.out.println(t + "\n");

}

Ejercicios

Ejercicio 1.Escribir un programa Java que permita convertir horas en notacion de 24 horas a su

equivalente en notacion de 12 horas. Por ejemplo, 23:50 debe ser convertida en 11:50 PM.Ejercicio 2.

Escribir un pequeno programa Java que permita convertir numeros romanos a su equiv-alente en cifras arabigas.Ejercicio 3.

Escribir un programa que reciba una fecha en formato dd/mm/aa (20/08/92) y sea de-vuelta como texto (20 de Agosto de 1992).Ejercicio 4.

Desarrollar un pequeno programa que lea la fecha de nacimento de una persona y calculesu edad en anos, meses y dıas.Ejercicio 5.

Construir un programa que lea una cadena de texto y devuelva otra cadena formadapor todas las letras mayusculas que aparecen en la primera.

Capıtulo 4

Programa JBuilder

En este curso se va a emplear para la compilacion de codigo Java el programa JBuilder,cuya version educacional es gratuita y permita la creacion sensilla de paquetes y programasmediante clases. En este capıtulo se va a proceder a explicar como se crearıa un programaque implemente el ejemplo de numeros complejos de la Seccion 3.1.

En primer lugar se procede a abrir el programa JBuilder con lo cual aparecera unapantalla similar a la siguiente:

88

CAPITULO 4. PROGRAMA JBUILDER 89

en caso de que no sea ası, posiblemente aparezca un proyecto por defecto, si se cierra sellegara a la pantalla anterior.

El siguiente paso es la creacion de un proyecto que gestionara todas las clases asociadasal problema y las integrara en un paquete con el mismo nombre que el nombre que ledemos al proyecto. El fichero creado tendra extension *.jpx, y llevara asociado una seriede carpetas con sus correspondientes ficheros. Ası en el menu file seleccionamos la opcionNew Proyect... tal y como se muestra en la siguiente ilustracion:

Una vez seleccionada la opcion New Proyect... se despliega una ventana como la dela grafica a continuacion en la que seleccionamos el nombre del proyecto que en este caso sellamara NumeroComplejo, a continuacion se vera como ese nombre afecta al nombre delpaquete en el que se almacenaran todas las clases que creemos. Notese que en el directoriohay que seleccionar la ubicacion dentro del disco duro en la que se desea almacenar la


carpeta con todos los ficheros para el proyecto.


A continuacion se pulsa el boton next y end hasta que aparece la pantalla mostradaen el grafico a continuacion:

Ya hemos creado el proyecto, a continuacion se procede a la creacion de las clases enficheros con extension *.java. Hay dos procedimientos para hacerlo, el primero consiste enutilizar la opcion New File... del menu File tal y como se muestra en la grafica siguiente.


Con lo que aparece el siguiente menu desplegable:

En el que escribimos el nombre de la clase Complejo, en este caso, que sera un ficherotipo Java y que se almacenara en el directorio por defecto, que es el mismo del proyecto.

La segunda opcion y mas util desde el punto de vista practico consiste en emplear laopcion New Class... del menu File tal y como se muestra en la figura siguiente:


Al pulsar la opcion aparece el siguiente menu en el que se le da nombre a la clase, se ledice el paquete al que va a pertenecer, notese que por defecto el nombre del paquete es elnombre del proyecto pero con minusculas, y luego da la opcion de crear el metodo main(),y dar varias caracterısticas de las clases.

Comentario 4.1 Recuerdese que en este curso todas las clases se consideraran publicas(public) o sin adjetivo, lo que implica que son friendly.


En el fichero generado se pega el codigo mostrado en el programa 3.1 de la pagina 24 yse graba el fichero pulsando el boton grabar, tal y como se muestra en la grafica siguiente:

Para compilar las clases dentro del proyecto y generar los codigos compilados, es decir,los ficheros *.class se pulsa la opcion Make Project “NumeroComplejo.jpx” dentro delmenu Project:

Siguiendo un procedimiento analogo se crea la clase Principal que sera la que contengael metodo main() y en la que se operaran con objetos de la clase Complejo. Notese que elcodigo de este fichero sera el mismo que el del programa 3.2, de la pagina 27:



Dado que hemos anadido una nueva clase al paquete, reconstruimos el proyecto y compil-amos de nuevo empleando la opcion Rebuild Project “NumeroComplejo.jpx” dentrodel menu Project:

Ya se esta en disposicion de ejecutar el programa mediante el fichero Principal.class,esto se puede hacer con el JBuilder sin mas que pulsar la opcion Run “Principal.java”using defaults dentro del menu Run. Notese que tiene que estar activa la ventana asociadaal fichero Principal.java para que esa opcion este disponible.

Inmediatamente aparece una ventana de salida en la que se genera la salida escritagenerada por el programa, tal y como se muestra en el grafico siguiente:


Es interesante saber como el programa almacena los ficheros. Inicialmente se crea unacarpeta con el mismo nombre que el fichero *.jpx del proyecto en la que se almacena, porun lado el fichero NumeroComplejo.jpx y tres carpetas con los nombres back, classesy src:

En la primera se guarda una copia de seguridad, en la segunda se almacenan los ficherosjava compilados, es decir, los ficheros con extension *.class como se muestra a continuacion:


Mientras que en la carpeta src se almacenan los ficheros fuente con extension *.java:

Apendice A

Examenes Resueltos

Practica A.1 (Parcial de 2 de Diciembre de 2005). Se va a proceder a elaborar unprograma de gestion de alumnos en un instituto. Para ello se generara una clase Alumnoque viene definida por las siguientes variables y metodos que deberan estar en la definicionde la clase. La seleccion del tipo de variables sera decision vuestra. La clase ha de tener lassiguientes caracterısticas:

1. Las variables principales que caracterizan a un alumno son su numero de dni (docu-mento nacional de identidad) (dni), su nombre (nombre), su primer apellido (apel-lido1) y su segundo apellido (apellido1). (2 puntos)

2. Se generara un constructor para permitir la inicializacion de un objeto de esta clasesin dar ningun tipo de argumento mediante la siguiente sentencia (2 puntos)

super();

3. Tambien se generara un segundo constructor cuyos argumentos son el dni, nombre,primer apellido y segundo apellido. De esta forma se inicializaran todas las variablesprincipales de la clase alumno definidas en el apartado 1. (8 puntos)

4. El numero maximo de asignaturas sera de 7 para todos los alumnos y no podra sercambiado. Ese valor maximo ha de fijarse dentro de la clase y no podra modificarsede ninguna forma. (2 puntos)

5. La clase tambien contendra dos variables que contengan los nombres de las asignaturasen las que cada alumno esta matriculado (asignaturas) y las notas (notas) de cadaasignatura. Se inicializaran al comienzo reservando espacio en memoria para almace-narlas y solo se asignaran sus valores mediante los metodos matricular y puntuar.Tengase en cuenta el numero maximo de asignaturas para definir las dimensiones deestas variables. (2 puntos)

6. El metodo matricular asignara valores a la variable asignaturas y recibira como ar-gumento un vector que contenga los nombres de las asignaturas en las que se matriculael alumno. Para la asignacion de las variables se procedera componente a componente.(7 puntos)

99

APENDICE A. EXAMENES RESUELTOS 100

7. El metodo puntuar asignara valor a la nota de alguna de las asignaturas, para ellorecibira como argumentos el nombre de la asignatura para la cual se va a asignarla nota y la puntuacion obtenida. A continuacion se debera de buscar la posicionadecuada en la que insertar la nota teniendo en cuenta que hay una correspondenciaentre el orden del listado de asignaturas que se encuentra almacenado en la variableasignaturas y el orden del listado de notas (almacenado en la variable notas). En elmomento que se haya localizado la asignatura correcta se parara el procedimiento debusqueda y se asignara la nota. NOTA: El metodo equals(String arg) de la claseString permite comparar si dos cadenas de caracteres son iguales. Devuelve el valortrue si son iguales y false si son distintos. En este caso arg es la variable con la quese quiere comparar. (12 puntos)

8. Se generara un metodo llamado aprobado que me permita saber si un alumno haaprobado una asignatura o no. Recibira como argumentos el nombre de la asignaturade la que se quiere saber si aprobo o no. Devolvera true o false. Al igual que enel metodo anterior una vez que se sepa si la asignatura se ha aprobado o no, no secontinuara buscando en la lista de asignaturas. En caso de que no se localize la asig-natura de la que se quiere hacer la consulta se devolvera el valor false y se escribira elsiguiente mensaje: (13 puntos)

“En alumno no esta matriculado en la asignatura que esta consultando.”

9. El ultimo metodo llamado media me permitira calcular la nota media de todas lasasignaturas como

xm =

n∑i=1

xi

n,

donde xm es la media, n es el numero de asignaturas y xi es la nota de la asignaturai-esima. (12 puntos)

A continuacion se generara una segunda clase llamada Matriculacion que contendra elmetodo main() en el que realizaran las siguientes acciones:

1. Se generara un objeto de la clase Alumno creada anteriormente y lo almacenareis enuna variable que sea vuestro nombre con minusculas. Por ejemplo si te llamas Robertoel nombre de la variable sera roberto. Para la generacion se empleara el constructorque requiere los datos del dni, nombre, primer apellido y segundo apellido. Utilizadvuestros datos personales (el numero de dni os lo podeis inventar). (4 puntos)

2. A continuacion creareis un array de “strings” almacenado en una variable llamadaasignaturas y reservareis espacio en memoria para almacenar tantos elementos comonumero maximo de asignaturas de la clase alumno. Ese numero maximo ha de serrelativo a la clase alumno, no vale poner 7 directamente. (4 puntos)

3. Almacenar en ese vector la lista con las siguientes asignaturas “Fısica”, “Matematicas”,“Lenguaje”, “Algebra”, “Historia”, “Literatura” “Dibujo”. (4 puntos)


4. Matricular al objeto de la clase Alumno que creasteis en el primer apartado en lasasignaturas contenidas en la variable asignaturas mediante el metodo correspondi-ente. (4 puntos)

5. A continuacion se va a proceder a asignar notas a todas las asignaturas. Para elloempleareis el metodo puntuar creado en la clase Alumno anteriormente. La notanumerica se generara de forma aleatoria para cada asignatura utilizando la siguienteexpresion: (10 puntos)

10*Math.random()

El resultado de esta expresion es una variable tipo double cuyo valor oscila entre 0 y10.

6. Escribir para todas las asignaturas del objeto Alumno la frase: (10 puntos)

“La asignatura” nombre de la asignatura “esta aprobada con una nota de”valor numerico “.“

si la asignatura correspondiente esta aprobada (nota≥ 5), o

“La asignatura” nombre de la asignatura “esta suspensa con una nota de”valor numerico “.“

si esta suspensa.

7. Por ultimo calcula la nota media mediante el metodo que generaste en la clase Alum-no y escrıbela. (4 puntos)

Tiempo: 1h 45 min.

Solucion:

Se va a proceder a elaborar un programa de gestion de alumnos en un instituto. Paraello se generara una clase Alumno que viene definida por las siguientes variables y metodosque deberan estar en la definicion de la clase. La seleccion del tipo de variables sera decisionvuestra. La clase ha de tener las siguientes caracterısticas:

1. Las variables principales que caracterizan a un alumno son su numero de dni (docu-mento nacional de identidad) (dni), su nombre (nombre), su primer apellido (apel-lido1) y su segundo apellido (apellido1). (2 puntos)

package alumno;

public class Alumno {int dni;String nombre,apellido1,apellido2;


2. Se generara un constructor para permitir la inicializacion de un objeto de esta clasesin dar ningun tipo de argumento mediante la siguiente sentencia (2 puntos)

super();

public Alumno() {super();

}

3. Tambien se generara un segundo constructor cuyos argumentos son el dni, nombre,primer apellido y segundo apellido. De esta forma se inicializaran todas las variablesprincipales de la clase alumno definidas en el apartado 1. (8 puntos)

public Alumno(int dni,String nombre, String apellido1,String apellido2) {

super();this.dni=dni;this.nombre=nombre;this.apellido1=apellido1;this.apellido2=apellido2;}

4. El numero maximo de asignaturas sera de 7 para todos los alumnos y no podra sercambiado. Ese valor maximo ha de fijarse dentro de la clase y no podra modificarsede ninguna forma. (2 puntos)

static final int numasi=7;

5. La clase tambien contendra dos variables que contengan los nombres de las asignaturasen las que cada alumno esta matriculado (asignaturas) y las notas (notas) de cadaasignatura. Se inicializaran al comienzo reservando espacio en memoria para almace-narlas y solo se asignaran sus valores mediante los metodos matricular y puntuar.Tengase en cuenta el numero maximo de asignaturas para definir las dimensiones deestas variables. (2 puntos)

String asignaturas[]=new String[numasi];float notas[]=new float[numasi];

6. El metodo matricular asignara valores a la variable asignaturas y recibira como ar-gumento un vector que contenga los nombres de las asignaturas en las que se matriculael alumno. Para la asignacion de las variables se procedera componente a componente.(7 puntos)


public void matricular(String asignatura[]){asignaturas=asignatura;int i;for(i=0;i<asignatura.length;i++){

asignaturas[i]=asignatura[i];}

}

7. El metodo puntuar asignara valor a la nota de alguna de las asignaturas, para ellorecibira como argumentos el nombre de la asignatura para la cual se va a asignarla nota y la puntuacion obtenida. A continuacion se debera de buscar la posicionadecuada en la que insertar la nota teniendo en cuenta que hay una correspondenciaentre el orden del listado de asignaturas que se encuentra almacenado en la variableasignaturas y el orden del listado de notas (almacenado en la variable notas). En elmomento que se haya localizado la asignatura correcta se parara el procedimiento debusqueda y se asignara la nota. NOTA: El metodo equals(String arg) de la claseString permite comparar si dos cadenas de caracteres son iguales. Devuelve el valortrue si son iguales y false si son distintos. En este caso arg es la variable con la quese quiere comparar. (12 puntos)

public void puntuar(String asigna,float puntuacion){boolean encontrado = false;short i = 0;while (!encontrado & i<asignaturas.length) {

if (asigna.equals(asignaturas[i])) {notas[i] = puntuacion;encontrado = true;

}else {

i++;}

}if(!encontrado){

System.out.println("El alumno no esta matriculadode esa asignatura"+asigna);

}}

8. Se generara un metodo llamado aprobado que me permita saber si un alumno haaprobado una asignatura o no. Recibira como argumentos el nombre de la asignaturade la que se quiere saber si aprobo o no. Devolvera true o false. Al igual que enel metodo anterior una vez que se sepa si la asignatura se ha aprobado o no, no secontinuara buscando en la lista de asignaturas. En caso de que no se localize la asig-natura de la que se quiere hacer la consulta se devolvera el valor false y se escribira elsiguiente mensaje: (13 puntos)

“En alumno no esta matriculado en la asignatura que esta consultando.”


public boolean aprobado(String asigna){boolean encontrado = false;boolean si=false;short i=0;while(!encontrado & i<asignaturas.length){

if(asigna.equals(asignaturas[i])){if(notas[i]>=5){

si=true;}encontrado=true;

}else{i++;

}}if(!encontrado){

System.out.println("El alumno no esta matriculado de esaasignatura"+asigna);

}return(si);

}

9. El ultimo metodo llamado media me permitira calcular la nota media de todas lasasignaturas como

xm =

n∑i=1

xi

n,

donde xm es la media, n es el numero de asignaturas y xi es la nota de la asignaturai-esima. (12 puntos)

public float media(){float med=0;int i;for(i=0;i<notas.length;i++){

med+=notas[i];}return(med/notas.length);

}

}// Fin de la clase Alumno

A continuacion se generara una segunda clase llamada Matriculacion que contendra elmetodo main() en el que realizaran las siguientes acciones:

package alumno;

public class Matriculacion {



1. Se generara un objeto de la clase Alumno creada anteriormente y lo almacenareis enuna variable que sea vuestro nombre con minusculas. Por ejemplo si te llamas Robertoel nombre de la variable sera roberto. Para la generacion se empleara el constructorque requiere los datos del dni, nombre, primer apellido y segundo apellido. Utilizadvuestros datos personales (el numero de dni os lo podeis inventar). (4 puntos)

Alumno roberto=new Alumno(20202192,"Roberto","Mınguez","Solana");System.out.println("Alumno "+roberto.nombre+" "+roberto.apellido1+" "+roberto.apellido2+" con DNI "+roberto.dni);

2. A continuacion creareis un array de “strings” almacenado en una variable llamadaasignaturas y reservareis espacio en memoria para almacenar tantos elementos comonumero maximo de asignaturas de la clase alumno. Ese numero maximo ha de serrelativo a la clase alumno, no vale poner 7 directamente. (4 puntos)

String asignaturas[]=new String[Alumno.numasi];

3. Almacenar en ese vector la lista con las siguientes asignaturas “Fısica”, “Matematicas”,“Lenguaje”, “Algebra”, “Historia”, “Literatura” “Dibujo”. (4 puntos)

asignaturas[0]="Fisica";asignaturas[1]="Matematicas";asignaturas[2]="Lenguaje";asignaturas[3]="Algebra";asignaturas[4]="Historia";asignaturas[5]="Literatura";asignaturas[6]="Dibujo";

4. Matricular al objeto de la clase Alumno que creasteis en el primer apartado en lasasignaturas contenidas en la variable asignaturas mediante el metodo correspondi-ente. (4 puntos)

roberto.matricular(asignaturas);

5. A continuacion se va a proceder a asignar notas a todas las asignaturas. Para elloempleareis el metodo puntuar creado en la clase Alumno anteriormente. La notanumerica se generara de forma aleatoria para cada asignatura utilizando la siguienteexpresion: (10 puntos)

10*Math.random()

El resultado de esta expresion es una variable tipo double cuyo valor oscila entre 0 y10.


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

roberto.puntuar(asignaturas[i],10*(float)Math.random());}

6. Escribir para todas las asignaturas del objeto Alumno la frase: (10 puntos)

“La asignatura” nombre de la asignatura “esta aprobada con una nota de”valor numerico “.“

si la asignatura correspondiente esta aprobada (nota≥ 5), o

“La asignatura” nombre de la asignatura “esta suspensa con una nota de”valor numerico “.“

si esta suspensa.

for(i=0;i<asignaturas.length;i++){if(roberto.aprobado(asignaturas[i])){

System.out.println("La asignatura "+asignaturas[i]+" esta aprobada con una nota de "+roberto.notas[i]);

}else{System.out.println("La asignatura "+asignaturas[i]+" esta suspensa con una nota de "+roberto.notas[i]);

}}

7. Por ultimo calcula la nota media mediante el metodo que generaste en la clase Alum-no y escrıbela. (4 puntos)

System.out.println("La nota media es de "+roberto.media());}// Fin del metodo main

}// Fin de la clase matriculacion

Tiempo: 1h 45 min.

\\ Metodo de ordenacion de mayor a menor puntuacionfloat notord[]=roberto.notas;String asiord[]=roberto.asignaturas;

int j;float auxnot;


String auxasig;for(i=0;i<notord.length-1;i++){for(j=i+1;j<notord.length;j++){if(notord[j]>notord[i]){auxnot=notord[j];notord[j]=notord[i];notord[i]=auxnot;auxasig=asiord[j];asiord[j]=asiord[i];asiord[i]=auxasig;

}}

}

for(i=0;i<notord.length-1;i++){System.out.println("Posicion "+(i+1)+": "+asiord[i]+"; nota= "+notord[i]);

}

Practica A.2 (Final de 16 de diciembre de 2005). La empresa Telefonica Espanava a proceder a la implantacion de un nuevo sistema de gestion telefonica mediante el cualpueda tener almacenada la informacion de todos sus usuarios, con la posibilidad de dar dealta a nuevos usuarios, consultar numeros para usuarios dados de alta, etc. Dada la compleji-dad del problema ha decidido encargaros el trabajo. Partiendo de unas pautas muy precisasdadas por la empresa elabora un programa en JAVA con las siguientes caracterısticas:

1. Todas las clases necesarias formaran parte de un paquete llamado telefonica.

2. La primera de las clases se llamara Usuario, las variables principales que caracterizana un usuario son su nombre (nombre), su primer apellido (apellido1), su segundoapellido (apellido1) y la provincia en donde viven provincia. (4 puntos)

3. Se generaran dos constructores. El primero, uno por defecto sin argumentos que permi-ta la inicializacion de un objeto de esta clase, y el segundo recibira como argumentos elnombre, primer apellido, segundo apellido y provincia en la que vive el nuevo usuario.De esta forma se inicializaran todas las variables principales de la clase Usuariodefinidas en el apartado 1. (8 puntos)

4. La segunda de las clases, que tambien pertenece al paquete telefonica se llamara Datausuar-ios y permitira crear una base de datos para una region en la que se almacenara todala informacion relativa a provincias, prefijos de provincia, usuarios, y sus numeros detelefono. Por tanto se crearan variables para almacenar el numero de provincias dela region (numprov), el numero maximo de usuarios que soportara el sistema (nu-musuarios), otra variable en la que se almacenen los nombres de las provincias de laregion (provincias), y otra para los prefijos (prefijos) asociados a las provincias. Adi-cionalmente, se crearan variables para almacenar a los usuarios (usuarios) (utilizarla clase Usuario creada anteriormente) y sus numeros de telefono (numtelefono),


respectivamente. Nota: Se crearan instancias de las variables pero sin reservar aunespacio en memoria en el caso de utilizar vectores (arrays). (4 puntos)

5. Dado que el sistema podra actualizarse dando de alta a nuevos usuarios con nuevosnumeros de telefono, se creara una variable que controle el numero de usuarios dadosde alta de la clase (numerousuario). Notese que cada vez que se de de alta un usuarionuevo este numero tendra que actualizarse. (2 puntos)

6. Al igual que en el apartado 3 se generaran dos constructores, uno sin argumentos yotro que reciba como argumentos el numero de provincias de la region de la cual se vaa crear la base de datos, y el numero de usuarios que soportara el sistema. Con ellosse inicializaran los valores de las variables de clase pertinentes y se reservara espacioen memoria para aquellos vectores de los cuales se sepa ya la dimension. Ademas,se inicializara el valor de la variable creada en el apartado anterior a cero en los dosconstructores. (6 puntos)

7. Dentro de la clase Datausuarios se generara un metodo llamado asignapref queasigne valores aleatorios a los prefijos de las provincias, para ello se tendran en cuentalas siguientes consideraciones: (16 puntos)

a) No recibira ningun argumento.

b) Los prefijos seran numeros enteros comprendidos entre 0 y 999, para crearlosse dispone de la sentencia (int)(999*Math.random()) que devuelve un numeroentero aleatorio comprendido entre 0 y 999.

c) No puede haber dos provincias con el mismo codigo o prefijo.

8. Para dar valores concretos a los nombres de las provincias se generara otro metodoque se llamara generacionprovincias que reciba como argumentos un vector arrayque contiene los nombres de las provincias. De esta forma se realizara la asignacion deprovincias de la clase componente a componente. A su vez, este metodo procedera aasignar prefijos a cada una de las provincias utilizando el metodo asignapref creadoen el apartado anterior. (6 puntos)

9. Para permitir la inclusion de nuevos usuarios se generara un metodo llamado al-tausuario que recibira como argumento un objeto de la clase Usuario que au-tomaticamente pasara a formar parte de los usuarios asociados a la clase Datausuar-ios. Ademas, se le asignara un numero de telefono que tendra las siguientes carac-terısticas: (12 puntos)

a) Se almacenara tambien en la base de datos.

b) Sera un numero entero comprendido entre 0 y 9999999, para crearlos se disponede la sentencia (int)(9999999*Math.random()) que devuelve un numero enteroaleatorio en ese rango.

c) No puede haber dos usuarios con el mismo numero de telefono. Para este apartadose dispone del metodo public boolean existenumero(int num) dentro de laclase Datausuarios que devuelve que comprueba si el numero num que se da


como argumento se corresponde con alguno de los numeros que hay en la basede datos.

d) Habra que actualizar la informacion del numero de usuarios disponibles.

10. El sistema permitira consultar el numero de telefono de un determinado usuario. Paraello se generara un metodo llamado consultanumero que recibira como argumentosun objeto tipo Usuario que busque dentro de los usuarios. Devolvera el numero detelefono de aquel usuario dentro de la base de datos tal que coincida su nombre, primerapellido y segundo apellido con el del usuario dato. NOTA: El metodo equals(Stringarg) de la clase String permite comparar si dos cadenas de caracteres son iguales.Devuelve el valor true si son iguales y false si son distintos. En este caso arg es lavariable con la que se quiere comparar. (12 puntos)

11. Para probar el programa telefonica os pide que creeis otra clase llamada Gestion quecontenga el metodo main() y que realice las siguientes acciones:

a) Crear una base de datos llamada espana con dos provincias y un numero maximode usuarios de 500000. (4 puntos)

b) Crear una variable que contenga las cadenas de caracteres siguientes: “Cantabria”y “Ciudad real”. (4 puntos)

c) Asignar a las provincias de la base de datos espana los valores de las provinciasalmacenadas en la variable creada en el apartado anterior. (4 puntos)

d) Escribir el siguiente texto: (6 puntos)

“Los prefijos de las provincias correspondientes a Espana son: ”

y a continuacion

“ Provincia ” nombre de la provincia “; Prefijo (” su prefijo “)”

para cada una de las provincias de la variable espana. Se debe haber utilizandoalgun procedimiento de control de flujo.

e) Se generara un objeto de la clase Usuario creada anteriormente y lo almacenareisen una variable que sea vuestro nombre con minusculas. Por ejemplo si te llamasRoberto el nombre de la variable sera roberto. Para la generacion se empleara elconstructor que requiere los datos del nombre, primer apellido, segundo apellido yla provincia. Utilizad vuestros datos personales, para la provicia utilizad “Ciudadreal”. (4 puntos)

f ) Dad de alta al usuario que habeis generado en el apartado anterior para la regionespana usando alguno de los metodos de los apartados anteriores. (4 puntos)

g) Escribir el telefono que el sistema ha asignado a vuestro usuario al darlo de alta.(4 puntos)

Tiempo: 1h 30 min.


Solucion:

La empresa Telefonica Espana va a proceder a la implantacion de un nuevo sistemade gestion telefonica mediante el cual pueda tener almacenada la informacion de todossus usuarios, con la posibilidad de dar de alta a nuevos usuarios, consultar numeros parausuarios dados de alta, etc. Dada la complejidad del problema ha decidido encargaros eltrabajo. Partiendo de unas pautas muy precisas dadas por la empresa elabora un programaen JAVA con las siguientes caracterısticas:

1. Todas las clases necesarias formaran parte de un paquete llamado telefonica.

2. La primera de las clases se llamara Usuario, las variables principales que caracterizana un usuario son su nombre (nombre), su primer apellido (apellido1), su segundoapellido (apellido2) y la provincia en donde viven provincia. (4 puntos)

package telefonica;

public class Usuario {

String nombre,apellido1,apellido2,provincia;

3. Se generaran dos constructores. El primero, uno por defecto sin argumentos que permi-ta la inicializacion de un objeto de esta clase, y el segundo recibira como argumentos elnombre, primer apellido, segundo apellido y provincia en la que vive el nuevo usuario.De esta forma se inicializaran todas las variables principales de la clase Usuariodefinidas en el apartado 1. (8 puntos)

public Usuario() {super();

}

public Usuario(String nombre, String apellido1, String apellido2,String provincia) {

super();this.nombre=nombre;this.apellido1=apellido1;this.apellido2=apellido2;this.provincia=provincia;

}

}// Fin de la clase Usuario

4. La segunda de las clases, que tambien pertenece al paquete telefonica se llamara Datausuar-ios y permitira crear una base de datos para una region en la que se almacenara todala informacion relativa a provincias, prefijos de provincia, usuarios, y sus numeros detelefono. Por tanto se crearan variables para almacenar el numero de provincias dela region (numprov), el numero maximo de usuarios que soportara el sistema (nu-musuarios), otra variable en la que se almacenen los nombres de las provincias de la


region (provincias), y otra para los prefijos (prefijos) asociados a las provincias. Adi-cionalmente, se crearan variables para almacenar a los usuarios (usuarios) (utilizarla clase Usuario creada anteriormente) y sus numeros de telefono (numtelefono),respectivamente. Nota: Se crearan instancias de las variables pero sin reservar aunespacio en memoria en el caso de utilizar vectores (arrays). (4 puntos)

package telefonica;

public class Datausuarios {

int numprov;int numusuarios;

String provincias [];int prefijos [];

Usuario usuarios [];int numtelefono[];

5. Dado que el sistema podra actualizarse dando de alta a nuevos usuarios con nuevosnumeros de telefono, se creara una variable que controle el numero de usuarios dadosde alta de la clase (numerousuario). Notese que cada vez que se de de alta un usuarionuevo este numero tendra que actualizarse. (2 puntos)

int numerousuario;

6. Al igual que en el apartado 3 se generaran dos constructores, uno sin argumentos yotro que reciba como argumentos el numero de provincias de la region de la cual se vaa crear la base de datos, y el numero de usuarios que soportara el sistema. Con ellosse inicializaran los valores de las variables de clase pertinentes y se reservara espacioen memoria para aquellos vectores de los cuales se sepa ya la dimension. Ademas,se inicializara el valor de la variable creada en el apartado anterior a cero en los dosconstructores. (6 puntos)

public Datausuarios() {super();numerousuario=0;

}

public Datausuarios(int numprov,int numusuarios) {super();this.numprov=numprov;this.numusuarios=numusuarios;this.provincias=new String [numprov];this.prefijos=new int [numprov];

this.usuarios=new Usuario [numusuarios];this.numtelefono=new int [numusuarios];

numerousuario=0;}


7. Dentro de la clase Datausuarios se generara un metodo llamado asignapref queasigne valores aleatorios a los prefijos de las provincias, para ello se tendran en cuentalas siguientes consideraciones: (16 puntos)

a) No recibira ningun argumento.

b) Los prefijos seran numeros enteros comprendidos entre 0 y 999, para crearlosse dispone de la sentencia (int)(999*Math.random()) que devuelve un numeroentero aleatorio comprendido entre 0 y 999.

c) No puede haber dos provincias con el mismo codigo o prefijo.

public void asignapref (){int aux=0;boolean prefok;for(int i=0;i<provincias.length;i++){

prefok=false;while(!prefok){

prefok=true;aux=(int)(999*Math.random());for(int j=0;j<i;j++){

if(prefijos[j]==aux){prefok=false;break;

}}

}prefijos[i]=aux;

}}

8. Para dar valores concretos a los nombres de las provincias se generara otro metodoque se llamara generacionprovincias que reciba como argumentos un vector arrayque contiene los nombres de las provincias. De esta forma se realizara la asignacion deprovincias de la clase componente a componente. A su vez, este metodo procedera aasignar prefijos a cada una de las provincias utilizando el metodo asignapref creadoen el apartado anterior. (6 puntos)

public void generacionprovincias (String provincia[]){for(int i=0;i<provincias.length;i++){

provincias[i]=provincia[i];}this.asignapref ();

}

9. Para permitir la inclusion de nuevos usuarios se generara un metodo llamado al-tausuario que recibira como argumento un objeto de la clase Usuario que au-tomaticamente pasara a formar parte de los usuarios asociados a la clase Datausuar-ios. Ademas, se le asignara un numero de telefono que tendra las siguientes carac-terısticas: (12 puntos)


a) Se almacenara tambien en la base de datos.

b) Sera un numero entero comprendido entre 0 y 9999999, para crearlos se disponede la sentencia (int)(9999999*Math.random()) que devuelve un numero enteroaleatorio en ese rango.

c) No puede haber dos usuarios con el mismo numero de telefono. Para este apartadose dispone del metodo public boolean existenumero(int num) dentro de laclase Datausuarios que devuelve que comprueba si el numero num que se dacomo argumento se corresponde con alguno de los numeros que hay en la basede datos.

d) Habra que actualizar la informacion del numero de usuarios disponibles.

public void altausuario (Usuario nuevo){boolean numcorrecto=false;while(!numcorrecto){

int aux=(int)(9999999*Math.random());if(!this.existenumero(aux)){

numtelefono[numerousuario]=aux;numcorrecto=true;

}}

usuarios[numerousuario]=nuevo;numerousuario++;

}

10. El sistema permitira consultar el numero de telefono de un determinado usuario. Paraello se generara un metodo llamado consultanumero que recibira como argumentosun objeto tipo Usuario que busque dentro de los usuarios. Devolvera el numero detelefono de aquel usuario dentro de la base de datos tal que coincida su nombre, primerapellido y segundo apellido con el del usuario dato. NOTA: El metodo equals(Stringarg) de la clase String permite comparar si dos cadenas de caracteres son iguales.Devuelve el valor true si son iguales y false si son distintos. En este caso arg es lavariable con la que se quiere comparar. (12 puntos)

public int consultanumero(Usuario dato){int num=0;if(numerousuario>0){

for(int i=0;i<numerousuario;i++){if(dato.nombre.equals(usuarios[i].nombre) &

dato.apellido1.equals(usuarios[i].apellido1) &dato.apellido2.equals(usuarios[i].apellido2) &dato.provincia.equals(usuarios[i].provincia)){

num=numtelefono[i];break;

}}

}


return(num);}

}// Fin de la clase Datausuarios

11. Para probar el programa telefonica os pide que creeis otra clase llamada Gestion quecontenga el metodo main() y que realice las siguientes acciones:

a) Crear una base de datos llamada espana con dos provincias y un numero maximode usuarios de 500000. (4 puntos)

package telefonica;

public class Gestion {


Datausuarios espa~na = new Datausuarios(2, 500000);

b) Crear una variable que contenga las cadenas de caracteres siguientes: “Cantabria”y “Ciudad Real”.

String provinciases[]={"Cantabria", "Ciudad Real"};

c) Asignar a las provincias de la base de datos espana los valores de las provinciasalmacenadas en la variable creada en el apartado anterior. (4 puntos)

espa~na.generacionprovincias(provinciases);

d) Escribir el siguiente texto: (6 puntos)

“Los prefijos de las provincias correspondientes a Espana son: ”

y a continuacion

“ Provincia ” nombre de la provincia “; Prefijo (” su prefijo “)”para cada una de las provincias de la variable espana. Se debe haber utilizandoalgun procedimiento de control de flujo.

System.out.println("Los prefijos de las provinciascorrespondientes a Espa~na son: ");for(int i=0;i<espa~na.provincias.length;i++){

System.out.println(" Provincia "+espa~na.provincias[i]+"; Prefijo ("+espa~na.prefijos[i]+")");

}

e) Se generara un objeto de la clase Usuario creada anteriormente y lo almacenareisen una variable que sea vuestro nombre con minusculas. Por ejemplo si te llamasRoberto el nombre de la variable sera roberto. Para la generacion se empleara elconstructor que requiere los datos del nombre, primer apellido, segundo apellido yla provincia. Utilizad vuestros datos personales, para la provicia utilizad “Ciudadreal”. (4 puntos)

Usuario roberto=new Usuario("Roberto","Mınguez","Solana","Ciudad Real");

f ) Dad de alta al usuario que habeis generado en el apartado anterior para la regionespana usando alguno de los metodos de los apartados anteriores. (4 puntos)


espa~na.altausuario(roberto);

g) Escribir el telefono que el sistema ha asignado a vuestro usuario al darlo de alta.(4 puntos)

System.out.println(" El numero de telefono asignado a "+roberto.nombre+" es "+espa~na.consultanumero(roberto));

Practica A.3 (Extraordinario de 13 de enero de 2006). En ingenierıa existen mu-chos sistemas que estan compuestos por “elementos” diferentes, fısicamente diferenciables,conectados por sus extremidades o “nudos”. Ejemplos de dichos sistemas abundan en inge-nierıa, por ejemplo, relacionados con las estructuras tenemos los sistemas constituidos porbarras, tales como, porticos, celosıas, entramados de edificacion, forjados, etc. A todos estossistemas se les conoce con el nombre de sistemas discretos.

La mayorıa de los sistemas discretos pueden analizarse utilizando tecnicas de calculomatricial para las cuales el trabajo mediante matrices es imprescindible.

Una matriz consiste en un conjunto ordenado de elementos (numeros) dispuestos yorganizados por filas y por columnas. Suponiendo que los elementos de las matrices que sevan a emplear son numeros reales, se denotara el espacio vectorial de las matrices reales dedimension m× n como IRm×n:

A ∈ IRm×n ⇔ A = (aij) =

a11 a12 · · · a1n

a21 a22 · · · a2n

· · · · · · · · · · · ·an1 an2 · · · amn

. (A.1)

donde m es el numero de filas y n es el numero de columnas.Para poder tratar de forma eficiente este tipo de elementos se pide crear una clase

llamada Matrix, que tenga las caracterısticas siguientes:

1. La clase generada pertenecera al paquete matrices (4 puntos).

2. Una matriz estara definida por una variable llamada A en la que se almacenen loselementos de la matriz y dos variables llamadas m y n que representan el numerode filas y el numero de columnas que componen la matriz, respectivamente. En esteapartado se creara una instancia para cada una de las variables pero sin reservarespacio en memoria ni asignar valores (8 puntos).

3. El primero de los constructores recibira como argumentos el numero de filas y elnumero de columnas de la matriz con lo cual se podran asignar esos valores a lasvariables de la clase. Adicionalmente se reservara memoria suficiente para almacenaren A la matriz de m× n elementos (8 puntos).

4. El segundo de los constructores recibira como argumentos el numero de filas y elnumero de columnas de la matriz y un numero real almacenado en la variable s de


forma que se generara una matriz A de m×n elementos todos iguales al numero reals (8 puntos):

aij = s; i = 1, . . . ,m; j = 1, . . . ,m.

5. Se crearan dos metodos publicos que se llamaran getRowDimension y getColum-nDimension que devuelvan el numero de filas y el numero de columnas de un ele-mento de la clase, respectivamente (8 puntos).

6. Dispondra de un metodo llamado get que reciba como argumentos dos numeros indi-cando una posicion de fila i y una posicion de columna j y que devuelva el elementoaij (8 puntos).

7. Para permitir la extraccion de submatrices, habra un metodo llamada getMatrixque permitira extraer una submatriz. Recibira como argumentos los indices inicial yfinal tanto de fila como de columna (i0, i1, j0, j1) que abarcara la submatriz. Ası, porejemplo, si (i0, i1, j0, j1) = (1, 2, 2, 4) entonces (12 puntos):

[a12 a13 a14

a22 a23 a24

], es la submatriz de

a11 a12 a13 a14

a21 a22 a23 a24

a31 a32 a33 a34

a41 a42 a43 a4n

. (A.2)

8. Otro de los metodos que se llamara set permitira hacer que un elemento de un objetomatriz, definido por su posicion (i, j) sea igual a un cierto valor (s) considerado dato:aij = s (8 puntos).

9. Se dispondra del metodo transpose que devuelva la matriz traspuesta de la original.Se recuerda que la matriz traspuesta AT de una matriz dada A es aquella tal que suselementos aT

ij = aji (8 puntos).

10. Para poder calcular la norma infinito ||A||∞ de la matriz A definida como:

||A||∞ = Maximoi; i = 1, . . . ,m

n∑j=1

|aij | ,

donde | • | es el valor absoluto. Es decir, para cada una de las filas de la matrizA calculo la suma de los valores absolutos de todos sus elementos y me quedo conel maximo valor de todos. Nota: El valor absoluto en JAVA se calcula mediante elmetodo Math.abs(). (12 puntos)

11. Tambien se dispondra de un metodo (plus) que dada otra matriz con las mismasdimensiones devuelva una matriz cuyos elementos son la suma de los elementos delas dos matrices. Nota: No es necesaria ninguna comprobacion sobre el tamano delas matrices, se supone que la matriz que se da como argumento tiene las mismasdimensiones que la matriz desde la que se llama al metodo (8 puntos).


12. Por ultimo, se desea crear un metodo llamado random que pueda llamarse a travesde la clase sin necesidad de crear un objeto y que devuelva una matriz de dimensionesm×n que seran dadas como argumento del metodo. Los elementos de la matriz serannumeros aleatorios entre 0 y 1. La funcion Math.random() devuelve un numero realaleatorio entre 0 y 1. (8 puntos)

Tiempo: 1h 30 min.

Solucion:

En ingenierıa existen muchos sistemas que estan compuestos por “elementos” diferentes,fısicamente diferenciables, conectados por sus extremidades o “nudos”. Ejemplos de dichossistemas abundan en ingenierıa, por ejemplo, relacionados con las estructuras tenemos lossistemas constituidos por barras, tales como, porticos, celosıas, entramados de edificacion,forjados, etc. A todos estos sistemas se les conoce con el nombre de sistemas discretos.

La mayorıa de los sistemas discretos pueden analizarse utilizando tecnicas de calculomatricial para las cuales el trabajo mediante matrices es imprescindible.

Una matriz consiste en un conjunto ordenado de elementos (numeros) dispuestos yorganizados por filas y por columnas. Suponiendo que los elementos de las matrices que sevan a emplear son numeros reales, se denotara el espacio vectorial de las matrices reales dedimension m× n como IRm×n:

A ∈ IRm×n ⇔ A = (aij) =

a11 a12 · · · a1n

a21 a22 · · · a2n

· · · · · · · · · · · ·an1 an2 · · · amn

. (A.3)

donde m es el numero de filas y n es el numero de columnas.Para poder tratar de forma eficiente este tipo de elementos se pide crear una clase

llamada Matrix, que tenga las caracterısticas siguientes:

1. La clase generada pertenecera al paquete matrices (4 puntos).

package matrices;

2. Una matriz estara definida por una variable llamada A en la que se almacenen loselementos de la matriz y dos variables llamadas m y n que representan el numerode filas y el numero de columnas que componen la matriz, respectivamente. En esteapartado se creara una instancia para cada una de las variables pero sin reservarespacio en memoria ni asignar valores (8 puntos).

public class Matrix {

double[][] A;int m, n;

3. El primero de los constructores recibira como argumentos el numero de filas y elnumero de columnas de la matriz con lo cual se podran asignar esos valores a lasvariables de la clase. Adicionalmente se reservara memoria suficiente para almacenaren A la matriz de m× n elementos (8 puntos).


public Matrix (int m, int n) {this.m = m;this.n = n;A = new double[m][n];

}

4. El segundo de los constructores recibira como argumentos el numero de filas y elnumero de columnas de la matriz y un numero real almacenado en la variable s deforma que se generara una matriz A de m×n elementos todos iguales al numero reals (8 puntos):

aij = s; i = 1, . . . ,m; j = 1, . . . ,m.

public Matrix (int m, int n, double s) {this.m = m;this.n = n;A = new double[m][n];for (int i = 0; i < m; i++) {

for (int j = 0; j < n; j++) {A[i][j] = s;}

}}

5. Se crearan dos metodos publicos que se llamaran getRowDimension y getColum-nDimension que devuelvan el numero de filas y el numero de columnas de un ele-mento de la clase, respectivamente (8 puntos).

public int getRowDimension () {return m;

}

public int getColumnDimension () {return n;

}

6. Dispondra de un metodo llamado get que reciba como argumentos dos numeros indi-cando una posicion de fila i y una posicion de columna j y que devuelva el elementoaij (8 puntos).

public double get (int i, int j) {return A[i][j];

}

7. Para permitir la extraccion de submatrices, habra un metodo llamada getMatrixque permitira extraer una submatriz. Recibira como argumentos los indices inicial yfinal tanto de fila como de columna (i0, i1, j0, j1) que abarcara la submatriz. Ası, porejemplo, si (i0, i1, j0, j1) = (1, 2, 2, 4) entonces (12 puntos):

[a12 a13 a14

a22 a23 a24

], es la submatriz de

a11 a12 a13 a14

a21 a22 a23 a24

a31 a32 a33 a34

a41 a42 a43 a4n

. (A.4)


public Matrix getMatrix (int i0, int i1, int j0, int j1) {Matrix X = new Matrix(i1-i0+1,j1-j0+1);for (int i = i0; i <= i1; i++) {for (int j = j0; j <= j1; j++) {

X.A[i-i0][j-j0] = A[i-1][j-1];}}return X;

}

8. Otro de los metodos que se llamara set permitira hacer que un elemento de un objetomatriz, definido por su posicion (i, j) sea igual a un cierto valor (s) considerado dato:aij = s (8 puntos).

public void set (int i, int j, double s) {A[i][j] = s;

}

9. Se dispondra del metodo transpose que devuelva la matriz traspuesta de la original.Se recuerda que la matriz traspuesta AT de una matriz dada A es aquella tal que suselementos aT

ij = aji (8 puntos).

public Matrix transpose () {Matrix X = new Matrix(n,m);for (int i = 0; i < m; i++) {

for (int j = 0; j < n; j++) {X.A[j][i] = A[i][j];}

}return X;

}

10. Para poder calcular la norma infinito ||A||∞ de la matriz A definida como:

||A||∞ = Maximoi; i = 1, . . . ,m

n∑j=1

|aij | ,

donde | • | es el valor absoluto. Es decir, para cada una de las filas de la matrizA calculo la suma de los valores absolutos de todos sus elementos y me quedo conel maximo valor de todos. Nota: El valor absoluto en JAVA se calcula mediante elmetodo Math.abs(). (12 puntos)

public double normInf () {double f = 0;for (int i = 0; i < m; i++) {

double s = 0;for (int j = 0; j < n; j++) {

s += Math.abs(A[i][j]);}f = Math.max(f,s);


}return f;

}

11. Tambien se dispondra de un metodo (plus) que dada otra matriz con las mismasdimensiones devuelva una matriz cuyos elementos son la suma de los elementos delas dos matrices. Nota: No es necesaria ninguna comprobacion sobre el tamano delas matrices, se supone que la matriz que se da como argumento tiene las mismasdimensiones que la matriz desde la que se llama al metodo (8 puntos).

public Matrix plus (Matrix B) {Matrix X = new Matrix(m,n);for (int i = 0; i < m; i++) {

for (int j = 0; j < n; j++) {X.A[i][j] = A[i][j] + B.A[i][j];

}}return X;

}

12. Por ultimo, se desea crear un metodo llamado random que pueda llamarse a travesde la clase sin necesidad de crear un objeto y que devuelva una matriz de dimensionesm×n que seran dadas como argumento del metodo. Los elementos de la matriz serannumeros aleatorios entre 0 y 1. La funcion Math.random() devuelve un numero realaleatorio entre 0 y 1. (8 puntos)

public static Matrix random (int m, int n) {Matrix X = new Matrix(m,n);for (int i = 0; i < m; i++) {

for (int j = 0; j < n; j++) {X.A[i][j] = Math.random();

}}return X;

}}

Practica A.4 (Parcial de 1 de Diciembre de 2006). Se va a proceder a elaborar unprograma para la resolucion y gestion de Su Dokus en una revista. Un Su Doku consisteen un tablero generalmente de 9 × 9 casillas divididas a su vez en bloques de 3 × 3 tal ycomo se muestra en la Figura A.1. El proposito del juego consiste en ubicar 9 sımboloscualesquiera en el tablero de forma que tanto en las 9 filas, como en las 9 columnas, comoen los 9 bloques de 3×3 no haya ninguno repetido, respectivamente. Por simplicidad y parafacilitar el manejo se emplean como sımbolos los numeros enteros 1, 2, 3, 4, 5, 6, 7, 8, 9. Enla Figura A.1 se puede observar que en todas las filas, columnas y bloques de 3 × 3 estancontenidos los numeros enteros del 1 al 9 sin repetir.

Obviamente este Su Doku esta resuelto y el objetivo del programa es resolver un SuDoku del que solo se conocen los valores de algunas de las casillas, tal y como se muestra


Figura A.1: Representacion del problema del Su Doku una vez resuelto.

en la Figura A.2. Notese que a la hora de resolver el Su Doku en el programa una casilla enla que se desconoce su valor contendra un cero (0).

Figura A.2: Ejemplo de datos iniciales para la resolucion del Su Doku.

Para la elaboracion del programa se comienza creando una clase denominada Sudokuque tiene las caracterısticas siguientes:

1. La clase pertenece al paquete misudoku. (2 puntos)

2. Las variables de instancia que caracterizan un objeto de la clase Sudoku son el numerode filas y el numero de columnas, que deben de ser declaradas de forma que no puedanmodificarse de forma alguna, y una matriz que almacene el valor de cada una de lascasillas del Su Doku, su nombre es cells. Inicialmente solo se declara la variable sininicializarla. (4 puntos)


3. Se genera un constructor para permitir la inicializacion de un objeto de esta clase sindar ningun tipo de argumento mediante la siguiente sentencia (2 puntos)

super();

4. El segundo constructor recibe una matriz que se llama celda cuyos elementos son delmismo tipo que los elementos de la variable cells, y se encarga de: (10 puntos)

a) Reservar espacio en memoria para la variable cells.b) Comprobar si las dimensiones de la matriz celda (numero de filas y de columnas)

son iguales a las variables de instancia en las que esta almacenada el numero defilas y de columnas de los objetos de la clase Sudoku, respectivamente. En casode que sean correctas se continua la ejecucion, si no lo son se escribe un mensajeen pantalla que diga:

"Las dimensiones de los datos no se ajustan a las dimensiones de Sudoku, compruebelo."

c) Si las dimensiones son correctas se procede a asignar valores a la variable cellsteniendo en cuenta que los valores de los datos estan en la variable celda. Parala asignacion (vease la Figura A.3) se comprueba que cada uno de los datos tomavalores entre 0 y 9, en caso de que alguno de ellos no lo cumpla se escribe unmensaje en pantalla que diga:

"Alguno de los datos esta fuera del rango."

Figura A.3: Distribucion por filas, columnas y bloques.

Y posteriormente se detiene el procedimiento de asignacion, ya que no tienesentido seguir asignando valores si alguno esta mal.Nota: El comando break solo sale del ciclo o bucle desde el que se le invoca.

5. El tercer constructor recibe una lista que se llama cadena compuesta por elementosString y se encarga de: (10 puntos)

a) Reservar espacio en memoria para la variable cells.


b) Comprobar si la dimension de la lista cadena concuerda con el numero de ele-mentos total del Su Doku. En caso de que sea correcta se continua la ejecucion,si no lo son se escribe un mensaje en pantalla que diga:

La dimension de los datos no se ajusta a las dimensiones de Sudoku, compruebelo.

c) Si la dimension es correcta se procedera a asignar valores a la variable cellsteniendo en cuenta que se asignan valores comenzando por la primera fila del SuDoku, luego la segunda fila, y ası sucesivamente hasta haber asignado todos loselementos de la lista cadena. Para la asignacion hay que tener en cuenta queexiste un metodo tipo static de la clase Integer llamado parseInt(String a)que devuelve el numero representado por “a” pero de tipo int. Ademas se ha decomprobar que cada uno de los datos toma valores entre 0 y 9, en caso de quealguno de ellos no lo cumpla se escribe un mensaje en pantalla que diga:



6. La clase contiene un metodo que se llama contarblancos que devuelve el numero deelementos sin resolver en el Su Doku correspondiente, es decir, el numero de elementosque son cero. (7 puntos)

7. Para ayudar a la resolucion se crea un metodo llamado elementline que compruebasi en una fila determinada dada como argumento con el nombre i es posible poner elnumero num dado tambien como argumento. Por ejemplo, tal y como se muestra en laFigura A.4, con esta rutina se podrıa comprobar si en la fila tercera se puede colocarel numero 6 en alguno de sus elementos. En este caso el metodo deberıa que contestarque sı ya que no existe ningun otro 6 en esa fila. (10 puntos)

Figura A.4: Ejemplo para mostrar la utilidad de los metodos elementline y elementcol-umn.


8. Analogamente, se crea un metodo llamado elementcolumn que comprueba si enuna columna determinada dada como argumento con el nombre j es posible poner elnumero num dado tambien como argumento. Por ejemplo, tal y como se muestra enla Figura A.4, con esta rutina se podrıa comprobar si en la columna cuarta se puedecolocar el numero 6 en alguno de sus elementos. En este caso el metodo deberıa quecontestar que sı ya que no existe ningun otro 6 en esa columna. (10 puntos)

9. A continuacion vamos a proceder a generar un metodo llamado resolver que supues-tamente se encarga de sustituir los ceros del Su Doku por los elementos correctosde forma que se cumpla la condicion de no repeticion de los numeros ni por filas, nipor columnas, ni por bloques. Debido a la complejidad de la resolucion, lo unico quehara el metodo sera escribir el siguiente mensaje cada vez que se invoque:

"Problema resuelto."

Aun ası definiremos el metodo y se supone que ademas de la escritura se incluyen lassentencias necesarias para resolverlo, es decir, que pese a que no anadıs el codigo pararesolverlo, si invocais el metodo se tendra en la variable correspondiente la solucion.(5 puntos)

10. Por ultimo, se crea un metodo que escribe los valores actuales de las casillas del SuDoku. La rutina ha de escribir cada fila en una lınea distinta y para distinguir losbloques se dejara una lınea en blanco entre bloques consecutivos, ya sea por filas opor columnas. Dentro de cada bloque de 3 × 3 y si el elemento es cero, se sustituyepor un blanco. A continuacion se describe un ejemplo del resultado final deseado:

9 8 2 6

9 3

3 7 6 4 8

2 5 7 8

4 3

6 1 4 2

2 8 1 3

3 9

6 4 8 2

Para este apartado puede ser de utilidad el metodo System.out.print("texto")que escribe lo que haya entre parentesis sin pasar de lınea, es decir, lo que se escribadespues se escribe inmediatamente despues de texto en la misma lınea. (10 puntos)

A continuacion se genera una segunda clase llamada Principal que contiene el metodomain. Todo lo que se pide a continuacion se supone dentro del metodo main y no hace faltaque genereis el codigo correspondiente:

1. Se crea una matriz en la que se almacenan los elementos del Su Doku mostrado enla Figura A.2. Recuerdese que las casillas en blanco se corresponden con ceros. (4puntos)

2. Se crea un objeto de la clase Sudoku en una variable que se llame como vuestronombre. Hay que utilizar uno de los dos constructores de la clase Sudoku. (4 puntos)


3. Escribir en pantalla el Su Doku empleando una unica sentencia. (4 puntos)

4. Escribir en pantalla el numero de elementos blancos que tiene el Su Doku de la si-guiente manera:(4 puntos)

El numero de elementos a resolver es 51.

5. Comprobar si se puede colocar el numero 6 en la fila tercera, columna cuarta y en casode que la respuesta sea positiva asignar el valor 6 a la correspondiente fila y columnay escribir el siguiente mensaje: (6 puntos)

El numero 6 es un posible candidato para ocupar la posicion (3,4).

En caso contrario escribir el siguiente mensaje:

En numero 6 no es valido, ya esta repetido en la fila 3 y/o en la columna 4.

6. Resolver el Su Doku. (4 puntos)

7. Escribir la solucion final en pantalla en un unico comando. (4 puntos)

Tiempo: 2h.

Solucion:

Se va a proceder a elaborar un programa para la resolucion y gestion de Su Dokus en unarevista. Un Su Doku consiste en un tablero generalmente de 9×9 casillas divididas a su vezen bloques de 3× 3 tal y como se muestra en la Figura A.5. El proposito del juego consisteen ubicar 9 sımbolos cualesquiera en el tablero de forma que tanto en las 9 filas, como enlas 9 columnas, como en los 9 bloques de 3× 3 no haya ninguno repetido, respectivamente.Por simplicidad y para facilitar el manejo se emplean como sımbolos los numeros enteros1, 2, 3, 4, 5, 6, 7, 8, 9. En la Figura A.5 se puede observar que en todas las filas, columnas ybloques de 3× 3 estan contenidos los numeros enteros del 1 al 9 sin repetir.

Obviamente este Su Doku esta resuelto y el objetivo del programa es resolver un SuDoku del que solo se conocen los valores de algunas de las casillas, tal y como se muestraen la Figura A.6. Notese que a la hora de resolver el Su Doku en el programa una casilla enla que se desconoce su valor contendra un cero (0).

Para la elaboracion del programa se comienza creando una clase denominada Sudokuque tiene las caracterısticas siguientes:

1. La clase pertenece al paquete misudoku. (2 puntos)

package misudoku;

2. Las variables de instancia que caracterizan un objeto de la clase Sudoku son el numerode filas y el numero de columnas, que deben de ser declaradas de forma que no puedanmodificarse de forma alguna, y una matriz que almacene el valor de cada una de lascasillas del Su Doku, su nombre es cells. Inicialmente solo se declara la variable sininicializarla. (4 puntos)


Figura A.5: Representacion del problema del Su Doku una vez resuelto.

Figura A.6: Ejemplo de datos iniciales para la resolucion del Su Doku.

public class Sudoku {

final int nrows = 9;final int ncols = 9;

int cells [][];

3. Se genera un constructor para permitir la inicializacion de un objeto de esta clase sindar ningun tipo de argumento mediante la siguiente sentencia (2 puntos)

public Sudoku() {super();


}

4. El segundo constructor recibe una matriz que se llama celda cuyos elementos son delmismo tipo que los elementos de la variable cells, y se encarga de: (10 puntos)

a) Reservar espacio en memoria para la variable cells.b) Comprobar si las dimensiones de la matriz celda (numero de filas y de columnas)

son iguales a las variables de instancia en las que esta almacenada el numero defilas y de columnas de los objetos de la clase Sudoku, respectivamente. En casode que sean correctas se continua la ejecucion, si no lo son se escribe un mensajeen pantalla que diga:

"Las dimensiones de los datos no se ajustan a las dimensiones de Sudoku, compruebelo."

c) Si las dimensiones son correctas se procede a asignar valores a la variable cellsteniendo en cuenta que los valores de los datos estan en la variable celda. Parala asignacion (vease la Figura A.7) se comprueba que cada uno de los datos tomavalores entre 0 y 9, en caso de que alguno de ellos no lo cumpla se escribe unmensaje en pantalla que diga:


Figura A.7: Distribucion por filas, columnas y bloques.


public Sudoku(int[][] celda){cells = new int[nrows][ncols];int nr = celda.length;int nc = celda[0].length;boolean incorrecto = false;if(nr != nrows || nc != ncols){

System.out.println("La dimension de los datos no se ajusta a las"


+ " dimensiones de Sudoku, compruebelo.");} else {

for(int i=1;i<=nr;i++){for(int j=1;j<=nr;j++){

if(celda[i-1][j-1]>=0 && celda[i-1][j-1]<=9){cells[i-1][j-1]=celda[i-1][j-1];}else{System.out.println("Alguno de los datos esta fuera del rango.");incorrecto = true;break;}

}if (incorrecto) break;}

}}

5. El tercer constructor recibe una lista que se llama cadena compuesta por elementosString y se encarga de: (10 puntos)

a) Reservar espacio en memoria para la variable cells.b) Comprobar si la dimension de la lista cadena concuerda con el numero de ele-

mentos total del Su Doku. En caso de que sea correcta se continua la ejecucion,si no lo son se escribe un mensaje en pantalla que diga:

La dimension de los datos no se ajusta a las dimensiones de Sudoku, compruebelo.

c) Si la dimension es correcta se procedera a asignar valores a la variable cellsteniendo en cuenta que se asignan valores comenzando por la primera fila del SuDoku, luego la segunda fila, y ası sucesivamente hasta haber asignado todos loselementos de la lista cadena. Para la asignacion hay que tener en cuenta queexiste un metodo tipo static de la clase Integer llamado parseInt(String a)que devuelve el numero representado por “a” pero de tipo int. Ademas se ha decomprobar que cada uno de los datos toma valores entre 0 y 9, en caso de quealguno de ellos no lo cumpla se escribe un mensaje en pantalla que diga:



public Sudoku(String [] cadena){cells = new int[nrows][ncols];int n = cadena.length;int val;if(n != (nrows*ncols)){

System.out.println("Las dimensiones de los datos no se ajustan "+ " a las dimensiones de Sudoku, compruebelo");

} else {for(int i=1;i<=nrows;i++){for(int j=1;j<=ncols;j++){


val=Integer.parseInt(cadena[(i-1)*nrows+j-1]);if(val>=0 && val<=9){cells[i-1][j-1]=val;}else{System.out.println("El dato numero "+((i-1)*nrows+j)

+ " de la cadena de entrada esta fuera de rango");break;}

}}

}}

6. La clase contiene un metodo que se llama contarblancos que devuelve el numero deelementos sin resolver en el Su Doku correspondiente, es decir, el numero de elementosque son cero. (7 puntos)

public int contarblancos (){int numb = 0;for(int i=1;i<=nrows;i++){

for(int j=1;j<=ncols;j++){if(cells[i-1][j-1]==0){numb+=1;}

}}return(numb);

}

7. Para ayudar a la resolucion se crea un metodo llamado elementline que compruebasi en una fila determinada dada como argumento con el nombre i es posible poner elnumero num dado tambien como argumento. Por ejemplo, tal y como se muestra en laFigura A.8, con esta rutina se podrıa comprobar si en la fila tercera se puede colocarel numero 6 en alguno de sus elementos. En este caso el metodo deberıa que contestarque sı ya que no existe ningun otro 6 en esa fila. (10 puntos)

public boolean elementline (int i, int num){boolean encontrado=false;int contador = 1;while (!encontrado && contador<=ncols){

if(cells[i-1][contador-1]==num){encontrado = true;break;}contador +=1;

}


Figura A.8: Ejemplo para mostrar la utilidad de los metodos elementline y elementcol-umn.

return(!encontrado);}

8. Analogamente, se crea un metodo llamado elementcolumn que comprueba si enuna columna determinada dada como argumento con el nombre j es posible poner elnumero num dado tambien como argumento. Por ejemplo, tal y como se muestra enla Figura A.8, con esta rutina se podrıa comprobar si en la columna cuarta se puedecolocar el numero 6 en alguno de sus elementos. En este caso el metodo deberıa quecontestar que sı ya que no existe ningun otro 6 en esa columna. (10 puntos)

public boolean elementcolumn (int j, int num){boolean encontrado=false;int contador = 1;while (!encontrado && contador<=nrows){if(cells[contador-1][j-1]==num){

encontrado = true;break;

}contador +=1;

}return(!encontrado);

}

9. A continuacion vamos a proceder a generar un metodo llamado resolver que supues-tamente se encarga de sustituir los ceros del Su Doku por los elementos correctosde forma que se cumpla la condicion de no repeticion de los numeros ni por filas, nipor columnas, ni por bloques. Debido a la complejidad de la resolucion, lo unico quehara el metodo sera escribir el siguiente mensaje cada vez que se invoque:


"Problema resuelto."

Aun ası definiremos el metodo y se supone que ademas de la escritura se incluyen lassentencias necesarias para resolverlo, es decir, que pese a que no anadıs el codigo pararesolverlo, si invocais el metodo se tendra en la variable correspondiente la solucion.(5 puntos)

public void resolver (){System.out.println("Problema resuelto.");

}

10. Por ultimo, se crea un metodo que escribe los valores actuales de las casillas del SuDoku. La rutina ha de escribir cada fila en una lınea distinta y para distinguir losbloques se dejara una lınea en blanco entre bloques consecutivos, ya sea por filas opor columnas (). Dentro de cada bloque de 3× 3 y si el elemento es cero, se sustituyepor un blanco (). A continuacion se describe un ejemplo del resultado final deseado:

9 8 2 6

9 3

3 7 6 4 8

2 5 7 8

4 3

6 1 4 2

2 8 1 3

3 9

6 4 8 2

Para este apartado puede ser de utilidad el metodo System.out.print("texto")que escribe lo que haya entre parentesis sin pasar de lınea, es decir, lo que se escribadespues se escribe inmediatamente despues de texto en la misma lınea. (10 puntos)

public void writeMatrix() {for (int i = 0; i < nrows; ++i) {

if (i % 3 == 0){System.out.println();

}for (int j = 0; j < ncols; ++j) {

if (j % 3 == 0) {System.out.print(" ");

}if (cells[i][j]==0){System.out.print(" ");

} else {System.out.print(cells[i][j] + " ");

}}


System.out.println("");}System.out.println(" ");

}

}// Fin la clase Sudoku

A continuacion se genera una segunda clase llamada Principal que contiene el metodomain. Todo lo que se pide a continuacion se supone dentro del metodo main y no hace faltaque genereis el codigo correspondiente:

1. Se crea una matriz en la que se almacenan los elementos del Su Doku mostrado enla Figura A.6. Recuerdese que las casillas en blanco se corresponden con ceros. (4puntos)

int a [][]={{9,0,0,8,0,2,0,0,6},{0,0,0,9,0,3,0,0,0},{3,0,7,0,0,0,4,0,8},{0,0,2,5,0,7,8,0,0},{0,4,0,0,0,0,0,3,0},{0,0,6,1,0,4,2,0,0},{2,0,8,0,0,0,1,0,3},{0,0,0,3,0,9,0,0,0},{6,0,0,4,0,8,0,0,2}};

2. Se crea un objeto de la clase Sudoku en una variable que se llame como vuestronombre. Hay que utilizar uno de los dos constructores de la clase Sudoku. (4 puntos)

Sudoku roberto = new Sudoku(a);

3. Escribir en pantalla el Su Doku empleando una unica sentencia. (4 puntos)

roberto.writeMatrix();

4. Escribir en pantalla el numero de elementos blancos que tiene el Su Doku de la si-guiente manera:(4 puntos)

El numero de elementos a resolver es ?.

System.out.println("El numero de elementos a resolver es "+ roberto.contarblancos()+".");

5. Comprobar si se puede colocar el numero 6 en la fila tercera, columna cuarta y en casode que la respuesta sea positiva asignar el valor 6 a la correspondiente fila y columnay escribir el siguiente mensaje: (6 puntos)


El numero 6 es un posible candidato para ocupar la posicion (3,4).

En caso contrario escribir el siguiente mensaje:

En numero 6 no es valido, ya esta repetido en la fila 3 y/o en la columna 4.

if(roberto.elementline (3,6) && roberto.elementcolumn (4,6)){System.out.println("El numero 6 es un posible candidato para"

+ " ocupar la posicion (3,4).");roberto.cells[2][3]=6;

} else {System.out.println("En numero 6 no es valido, ya esta repetido"

+ " en la fila 3 y/o en la columna 4.");}

6. Resolver el Su Doku. (4 puntos)

roberto.resolver ();

7. Escribir la solucion final en pantalla en un unico comando. (4 puntos)

System.out.println("La solucion del Sudoku actual es:");roberto.writeMatrix();

Tiempo: 2h.

Practica A.5 (Final de 16 de diciembre de 2006). Se va a proceder a generar unprograma para la gestion de las quinielas de futbol. Cada una de las quinielas tiene 14partidos mas el pleno al quince. Para los primeros 14 partidos hay un total de 8 pronosticoscomo maximo (no es necesario completar todos), y dentro de cada pronostico el resultado delpartido puede ser ‘1’, ‘X’ y ‘2’, tal y como se muestra en la Figura A.9. Se puede seleccionarpara cada partido un unico resultado (apuesta simple), dos resultados (apuesta doble) otres resultados (apuesta triple).

Para la elaboracion del programa se comienza creando una clase denominada Quinielaque tiene las caracterısticas siguientes:

1. La clase pertenece al paquete quiniela. (2 puntos)

2. Las variables de instancia que caracterizan un objeto de la clase Quiniela son elnumero de partidos sin contar el pleno al quince, y el numero maximo de pronosticos,las variables se llamaran partidos y pronosticos, respectivamente. Tendran un valorfijo que no se puede modificar y que debera fijarse en el momento de la declaracionde las variables, y seran comunes para todos los elementos de la clase Quiniela. (4puntos)


Figura A.9: Representacion de la quiniela, con sus 14 partidos, 8 pronosticos y su pleno alquince.

3. Dado que no es necesario completar todos los pronosticos, se declarara una variablellamada numeropronosticos en el que posteriormente se almacenara el numero depronosticos para una quiniela sellada. Ademas, para almacenar la informacion de cadaquiniela se declarara la variable apuestas (vease la Figura A.10) que tendra tantasfilas como numero de partidos sin contar el pleno al quince y de columnas el numerode pronosticos multiplicado por tres posibles resultados para cada partido. El sistemareconocera cada apuesta si en la casilla correspondiente hay un 1, en caso contrariohabra un cero, lo que implica que no hay apuesta en esa casilla. Para almacenar elnumero de partidos en los que se acierta el resultado para cada pronostico, se declarauna variable llamada aciertos. Y por ultimo para almacenar el pleno se declara einicializa la variable pleno que contendra la informacion de que resultado se seleccionapara el partido del pleno al quince. Inicialmente se supone que no se ha seleccionadoningun resultado. (4 puntos)


Figura A.10: Representacion de la variable apuestas para el caso de la quiniela de laFigura A.9.

NOTA: Para la realizacion del examen puede ser especialmente util la siguiente ex-presion

(k − 1) ∗ 3 + j,

que permite conocer la columna de la matriz almacenada en la variable apuestassuponiendo que se esta en el bloque numero k y que j toma valores 1, 2, o 3, corres-pondientes, respectivamente, con los valores ‘1’, ‘X’ y ‘2’. Ası por ejemplo, el resultadoasociado a la ‘X’ del pronostico 3 esta en la columna (3−1)∗3+2 = 8 (octava columna).

4. Se genera un constructor para permitir la inicializacion de un objeto de esta clase sindar ningun tipo de argumento mediante la sentencia super(). (2 puntos)

5. El segundo constructor recibe un numero entero que se corresponde con el numero depronosticos que se quieren rellenar, y se encarga de: (10 puntos)

a) Reservar espacio en memoria para la variable apuestas.

b) En segundo lugar se inicializaran los valores de las apuestas para el numero depronosticos dado como argumento, de forma que se seleccionara para cada par-tido una unica apuesta (apuesta simple). Para escoger el resultado se emplea la


expresion (int) Math.ceil(3*Math.random()) que devuelve un numero alea-torio entre 1 y 3, de forma que si sale 1 significa que se ha seleccionado el ‘1’y ha de ponerse un uno en la primera columna correspondiente al pronostico,si sale 2 significa que se ha seleccionado la ‘X’ y ha de ponerse un uno en lasegunda columna correspondiente al pronostico, y si sale 3 significa que se ha se-leccionado el ‘2’ y ha de ponerse un uno en la tercera columna correspondienteal pronostico. Para los resultados no elegidos su valor correspondiente es cero.

c) Por ultimo se selecciona el resultado del pleno al quince empleando la mismaexpresion (int) Math.ceil(3*Math.random()), poniendo un 1 en la posicionindicada por ese valor y cero en las otras dos casillas.

6. El tercer constructor recibe como argumentos una lista de listas con las apuestas, yuna lista de tres elementos con la informacion del pleno al quince. (10 puntos)

a) Reservar espacio en memoria para la variable apuestas de la clase.b) Comprobar si el numero de filas de la variable con la informacion de las apuestas

concuerda con el numero de partidos de la clase Quiniela. En caso de que seacorrecto se continua la ejecucion, si no lo es se escribe un mensaje en pantallaque diga:

El numero de partidos es incorrecto.

c) Si la dimension es correcta se procedera a asignar valores a la variable apuestaspero solo con los datos disponibles.

d) Asignar valores a la variable pleno de la clase Quiniela.

7. La clase contiene un metodo que se llama aciertospronosticos que recibe como argu-mento una lista con 14 cadenas de caracteres en los que esta la solucion de la quiniela‘1’, ‘X’ o ‘2’ para cada uno de los partidos. Con esa informacion se recorreran to-dos los pronosticos y se contaran el numero de acietos, almacenandolos en la variableaciertos. (8 puntos)

8. Se creara otro metodo llamado aciertopleno que recibe como argumento un stringcon el resultado ‘1’, ‘X’ o ‘2’ correcto del pleno al quince, que devuelve “verdadero”si se ha acertado, y “falso” en caso contrario. (8 puntos)

9. Otro de los metodos calcula el numero maximo de aciertos almacenado en la variableaciertos para los pronosticos en los que hay apuestas. (8 puntos)

10. El siguiente de los metodos llamado numsimples calcula el numero de apuestassencillas de la quiniela. (5 puntos)

11. El metodo numdobles calcula el numero de apuestas dobles de la quiniela. (5 puntos)

12. El metodo numtriples calcula el numero de apuestas triples de la quiniela. (5 puntos)

13. Por ultimo, el metodo precio calcula el precio de la quiniela teniendo en cuenta queel precio de la apuesta simple es de 0,5 euros, el de la doble 2 euros, y 5 euros el de latriple. Emplear los metodos creados anteriormente. (5 puntos)


A continuacion se genera una segunda clase llamada Apuesta que contiene el metodomain y que pertenece al mismo paquete quiniela:

1. Crear un objeto quiniela con 5 pronosticos en los que los resultados sean aleatorios yalmacenarlo en una variable con tu mismo nombre. (4 puntos)

2. Escribir el precio de la quiniela creada en una unica lınea. (4 puntos)

3. Almacenar en una lista de Strings 14 resultados cualesquiera para suponer que sonlos valores correctos de los partidos de la quiniela. (4 puntos)

4. Calcular los aciertos de cada uno de los pronosticos.(4 puntos)

5. Escribir en pantalla el numero maximo de aciertos. (4 puntos)

6. Escribir en pantalla si se ha acertado el pleno o no suponiendo que el valor correctodel partido asociado al pleno es ‘1’. (4 puntos)

Tiempo: 2h.

Solucion:

Se va a proceder a generar un programa para la gestion de las quinielas de futbol. Cadauna de las quinielas tiene 14 partidos mas el pleno al quince. Para los primeros 14 partidoshay un total de 8 pronosticos como maximo (no es necesario completar todos), y dentro decada pronostico el resultado del partido puede ser ‘1’, ‘X’ y ‘2’, tal y como se muestra en laFigura A.11. Se puede seleccionar para cada partido un unico resultado (apuesta simple),dos resultados (apuesta doble) o tres resultados (apuesta triple).

Para la elaboracion del programa se comienza creando una clase denominada Quinielaque tiene las caracterısticas siguientes:

1. La clase pertenece al paquete quiniela. (2 puntos)

package quiniela;

2. Las variables de instancia que caracterizan un objeto de la clase Quiniela son elnumero de partidos sin contar el pleno al quince, y el numero maximo de pronosticos,las variables se llamaran partidos y pronosticos, respectivamente. Tendran un valorfijo que no se puede modificar y que debera fijarse en el momento de la declaracionde las variables, y seran comunes para todos los elementos de la clase Quiniela. (4puntos)

public class Quiniela {

final static int partidos = 14;final static int pronosticos = 8;


Figura A.11: Representacion de la quiniela, con sus 14 partidos, 8 pronosticos y su plenoal quince.

3. Dado que no es necesario completar todos los pronosticos, se declarara una variablellamada numeropronosticos en el que posteriormente se almacenara el numero depronosticos para una quiniela sellada. Ademas, para almacenar la informacion de cadaquiniela se declarara la variable apuestas (vease la Figura A.12) que tendra tantasfilas como numero de partidos sin contar el pleno al quince y de columnas el numerode pronosticos multiplicado por tres posibles resultados para cada partido. El sistemareconocera cada apuesta si en la casilla correspondiente hay un 1, en caso contrariohabra un cero, lo que implica que no hay apuesta en esa casilla. Para almacenar elnumero de partidos en los que se acierta el resultado para cada pronostico, se declarauna variable llamada aciertos. Y por ultimo para almacenar el pleno se declara einicializa la variable pleno que contendra la informacion de que resultado se seleccionapara el partido del pleno al quince. Inicialmente se supone que no se ha seleccionadoningun resultado. (4 puntos)


Figura A.12: Representacion de la variable apuestas para el caso de la quiniela de laFigura A.11.

NOTA: Para la realizacion del examen puede ser especialmente util la siguiente ex-presion

(k − 1) ∗ 3 + j,

que permite conocer la columna de la matriz almacenada en la variable apuestassuponiendo que se esta en el bloque numero k y que j toma valores 1, 2, o 3, corres-pondientes, respectivamente, con los valores ‘1’, ‘X’ y ‘2’. Ası por ejemplo, el resultadoasociado a la ‘X’ del pronostico 3 esta en la columna (3−1)∗3+2 = 8 (octava columna).

int numeropronosticos;int apuestas [][];int aciertos [];int pleno [] = new int[3];


public Quiniela() {


super();}

5. El segundo constructor recibe un numero entero que se corresponde con el numero depronosticos que se quieren rellenar, y se encarga de: (10 puntos)

a) Reservar espacio en memoria para la variable apuestas.b) En segundo lugar se inicializaran los valores de las apuestas para el numero de

pronosticos dado como argumento, de forma que se seleccionara para cada par-tido una unica apuesta (apuesta simple). Para escoger el resultado se emplea laexpresion (int) Math.ceil(3*Math.random()) que devuelve un numero alea-torio entre 1 y 3, de forma que si sale 1 significa que se ha seleccionado el ‘1’y ha de ponerse un uno en la primera columna correspondiente al pronostico,si sale 2 significa que se ha seleccionado la ‘X’ y ha de ponerse un uno en lasegunda columna correspondiente al pronostico, y si sale 3 significa que se ha se-leccionado el ‘2’ y ha de ponerse un uno en la tercera columna correspondienteal pronostico. Para los resultados no elegidos su valor correspondiente es cero.

c) Por ultimo se selecciona el resultado del pleno al quince empleando la mismaexpresion (int) Math.ceil(3*Math.random()), poniendo un 1 en la posicionindicada por ese valor y cero en las otras dos casillas.

public Quiniela(int numeropronosticos) {int posicion;this.numeropronosticos = numeropronosticos;apuestas = new int [partidos][3*pronosticos];for(int j=0;j<numeropronosticos;j++){for(int i=0;i<partidos;i++){for(int k=1;k<=3;k++){posicion = (int) Math.ceil(3*Math.random());if(posicion==k){apuestas[i][3*j+k-1] = 1;

}else{apuestas[i][3*j+k-1] = 0;

}}

}}posicion = (int) Math.ceil(3*Math.random());for(int k=1;k<=3;k++){if(posicion==k){pleno[k-1] = 1;

}else{pleno[k-1] = 0;

}}

}

6. El tercer constructor recibe como argumentos una lista de listas con las apuestas, yuna lista de tres elementos con la informacion del pleno al quince. (10 puntos)


a) Reservar espacio en memoria para la variable apuestas de la clase.b) Comprobar si el numero de filas de la variable con la informacion de las apuestas

concuerda con el numero de partidos de la clase Quiniela. En caso de que seacorrecto se continua la ejecucion, si no lo es se escribe un mensaje en pantallaque diga:

El numero de partidos es incorrecto.

c) Si la dimension es correcta se procedera a asignar valores a la variable apuestaspero solo con los datos disponibles.

d) Asignar valores a la variable pleno de la clase Quiniela.

public Quiniela(int apuestas [][], int pleno []) {this.apuestas = new int [partidos][3*pronosticos];int npar, npro;npar = apuestas.length;npro = (int) apuestas[0].length / 3;numeropronosticos = npro;if (npar != partidos) {System.out.println("El numero de partidos es incorrecto.");

}else {for (int j = 0; j < npro; j++) {for (int i = 0; i < npar; i++) {this.apuestas[i][3 * j] = apuestas[i][3 * j];this.apuestas[i][3 * j + 1] = apuestas[i][3 * j + 1];this.apuestas[i][3 * j + 2] = apuestas[i][3 * j + 2];

}}this.pleno = pleno;

}}

7. La clase contiene un metodo que se llama aciertospronosticos que recibe como argu-mento una lista con 14 cadenas de caracteres en los que esta la solucion de la quiniela‘1’, ‘X’ o ‘2’ para cada uno de los partidos. Con esa informacion se recorreran to-dos los pronosticos y se contaran el numero de acietos, almacenandolos en la variableaciertos. (8 puntos)

public void aciertospronosticos (String resultados[]){aciertos=new int[pronosticos];for(int j=0;j<numeropronosticos;j++){aciertos[j] =0;

}for(int i=0;i<partidos;i++){for(int j=0;j<numeropronosticos;j++){if(resultados[i]=="1" && apuestas[i][3*j]==1){aciertos[j] += 1;

} else if (resultados[i]=="X" && apuestas[i][3*j+1]==1){aciertos[j] += 1;

} else if (resultados[i]=="2" && apuestas[i][3*j+2]==1){


aciertos[j] += 1;}

}}

}

8. Se creara otro metodo llamado aciertopleno que recibe como argumento un stringcon el resultado ‘1’, ‘X’ o ‘2’ correcto del pleno al quince, que devuelve “verdadero”si se ha acertado, y “falso” en caso contrario. (8 puntos)

public boolean aciertopleno(String plenores){boolean plenotrue = false;if(plenores=="1" && pleno[0]==1){plenotrue = true;

} else if (plenores=="X" && pleno[1]==1){plenotrue = true;

} else if (plenores=="2" && pleno[2]==1){plenotrue = true;

}return(plenotrue);

}

9. Otro de los metodos calcula el numero maximo de aciertos almacenado en la variableaciertos para los pronosticos en los que hay apuestas. (8 puntos)

public int maxacierto (){int maximo = aciertos[0];for(int j=1;j<numeropronosticos;j++){if(aciertos[j]>maximo){

maximo = aciertos[j];}

}return(maximo);

}

10. El siguiente de los metodos llamado numsimples calcula el numero de apuestassencillas de la quiniela. (5 puntos)

public int numsimples (){int contador = 0;int aux;for(int i=0;i<partidos;i++){for(int j=0;j<numeropronosticos;j++){

aux = apuestas[i][3*j]+apuestas[i][3*j+1]+apuestas[i][3*j+2];if(aux==1){


contador++;}

}}return(contador);

}

11. El metodo numdobles calcula el numero de apuestas dobles de la quiniela. (5 puntos)

public int numdobles (){int contador = 0;int aux;for(int i=0;i<partidos;i++){for(int j=0;j<numeropronosticos;j++){

aux = apuestas[i][3*j]+apuestas[i][3*j+1]+apuestas[i][3*j+2];if(aux==2){contador++;

}}

}return(contador);

}

12. El metodo numtriples calcula el numero de apuestas triples de la quiniela. (5 puntos)

public int numtriples (){int contador = 0;int aux;for(int i=0;i<partidos;i++){for(int j=0;j<numeropronosticos;j++){

aux = apuestas[i][3*j]+apuestas[i][3*j+1]+apuestas[i][3*j+2];if(aux==3){contador++;

}}

}return(contador);

}

13. Por ultimo, el metodo precio calcula el precio de la quiniela teniendo en cuenta queel precio de la apuesta simple es de 0,5 euros, el de la doble 2 euros, y 5 euros el de latriple. Emplear los metodos creados anteriormente. (5 puntos)

public double precio () {double coste;


coste = this.numsimples()*0.5+this.numdobles()*2+this.numsimples()*5;return(coste);

}

}// Fin la clase Sudoku

A continuacion se genera una segunda clase llamada Apuesta que contiene el metodomain y que pertenece al mismo paquete quiniela:

1. Crear un objeto quiniela con 5 pronosticos en los que los resultados sean aleatorios yalmacenarlo en una variable con tu mismo nombre. (4 puntos)

Quiniela roberto = new Quiniela(5);


System.out.println("El precio de la Quiniela es de "+roberto.precio()+" euros.");

3. Almacenar en una lista de Strings 14 resultados cualesquiera para suponer que sonlos valores correctos de los partidos de la quiniela. (4 puntos)

String resultado []= {"X","1","1","2","X","2","1","X","1","1","1","2","X","X"};

4. Calcular los aciertos de cada uno de los pronosticos:(4 puntos)

roberto.aciertospronosticos(resultado);


System.out.println("El numero maximo de aciertos es de "+roberto.maxacierto());

6. Escribir en pantalla si se ha acertado el pleno o no suponiendo que el valor correctodel partido asociado al pleno es ‘1’. (4 puntos)

if(roberto.aciertopleno("1")){System.out.println("Ha acertado el pleno.");

} else {System.out.println("No ha acertado el pleno.");

}

}

}

Tiempo: 2h.


Figura A.13: Boleto de Banda Verde que edita Loterıas y Apuestas del Estado para elsorteo de La Primitiva.

Practica A.6 (Extraordinario de 9 de enero de 2007). Se va a proceder a generarun programa para la gestion de La Primitiva. El funcionamiento del sorteo es el siguiente.Las Apuestas solo podran efectuarse en uno de los 2 boletos que edita Loterıas y Apuestasdel Estado, que se podran conseguir en los establecimientos autorizados. El boleto de BandaVerde mostrado en la Figura A.13 sirve para un solo Sorteo de los dos que hay, si se validade Lunes a Jueves entra a concursar para el Sorteo del Jueves, si se valida de Viernes aSabado, entra a concursar para el Sorteo del Sabado.

Se puede jugar sin necesidad de utilizar el boleto, siendo el Terminal de Juego, el quepor Azar, nos elige la combinacion segun el importe que se desee gastar.

Utilizando los boletos se puede jugar por varios sistemas, en este caso se opta por elMetodo directo sencillo: Se puede jugar de 1 a 8 Apuestas en un mismo boleto. Parajugar 1 apuesta se marcan las seis cruces en el primer bloque de los 8 que tiene el boleto,eligiendo los numeros que deseemos. Para jugar 2 Apuestas marcaremos 6 numeros en elprimer bloque y 6 en el segundo, y ası sucesivamente. Los bloques marcados seran siemprecorrelativos de izquierda a derecha, no pudiendo dejar ninguno en blanco.


Importe en eurosApuestas Un sorteo Dos sorteos

1 1,00 2,002 2,00 4,003 3,00 6,004 4,00 8,005 5,00 10,006 6,00 12,007 7,00 14,008 8,00 16,00

Concluido el Sorteo dara comienzo el escrutinio de todas las apuestas validadas queparticipan en el Concurso, para asignar los premios que correspondan a cada una por co-incidencia entre la Combinacion Ganadora y los pronosticos que constan en las apuestas.Solo se podra percibir un premio por apuesta.

EL PRIMER premio consiste en acertar los 6 numeros que salen del bombo, perodado que la Combinacion Ganadora consta de seis numeros.

Si acertamos unicamente 5 numeros de la Combinacion Ganadora hay premio.



Tambien se establece un premio complementario. Junto a los seis numeros que com-pone la Combinacion Ganadora se extrae un septimo denominado Complementariodestinado a ofrecer premio a los acertantes de 5 numeros que ademas acierten estenumero, se trata del premio de 5+Complementario.

Tambien se obtiene premio cuando el numero designado como Reintegro en nuestroboleto, coincida con la bola que se extrae en el sorteo destinada a ese premio, en esecaso sera abonado el importe de la apuesta jugada en el boleto.

Para la elaboracion del programa se comienza creando una clase denominada Primitivaque tiene las caracterısticas siguientes:

1. La clase pertenece al paquete primitiva. (2 puntos)

2. Las variables de instancia que caracterizan un objeto de la clase Primitiva son elnumero de numeros que se seleccionan para cada apuesta (6), el numero maximo deapuestas (8), y el numero de posibles valores enteros que pueden tomar los numeros(49). Las variables se llamaran numeros, napuestas y numeromaximo, respecti-vamente. Tendran un valor fijo que no se puede modificar y que debera fijarse en elmomento de la declaracion de las variables, y seran comunes para todos los elementosde la clase Primitiva. (4 puntos)


3. Dado que no es necesario completar todas las apuestas, se declarara una variablellamada numeroapuestas en la que posteriormente se almacenara el numero deapuestas para una primitiva sellada. Ademas, para almacenar la informacion de cadaprimitiva se declarara la variable apuestas que tendra tantas filas como numero deapuestas y de columnas el numero de numeros de cada apuesta (6). En cada una de lasfilas de la variable apuestas se almacenan los seis numeros seleccionados para cadaapuesta. Para almacenar el numero de aciertos de cada apuesta se declara una variablellamada aciertos. Y por ultimo para almacenar tanto el numero complementario comoel reintegro se declaran las variables complementario y reintegro. (4 puntos)


5. Se creara un metodo que se llamara apuestaleatoria, que no recibe ningun argumentoy que devuelve una lista con el numero de numeros (utilizar la informacion de lasvariables ya declaradas e inicializadas) necesario para realizar una apuesta, con lassiguientes caracterısticas: (8 puntos)

a) Los numeros han de generarse de forma aleatoria para ello se emplea la expresion(int) Math.ceil(numeromaximo*Math.random()) que devuelve un numero en-tero aleatorio entre 1 y numeromaximo.

b) Ninguno de los numeros se puede repetir.

6. El segundo constructor recibe un numero entero que se corresponde con el numero deapuestas que se quieren rellenar, y se encarga de: (8 puntos)


b) Se le asigna valor a la variable numeroapuestas.

c) En tercer lugar se inicializaran los valores de la variable apuestas empleando elmetodo creado en el apartado 5. Notese que el metodo devuelve una lista quese corresponde con cada una de las filas de la matriz almacenada en la variableapuestas.

d) A continuacion se le da un valor aleatorio entre 1 y numeromaximo a la variablecomplementario, en la que se almacena el numero complementario.

e) Analogamente, se le asigna un valor aleatorio entre 1 y numeromaximo a lavariable reintegro, en la que se almacena el numero correspondiente al reintegro.

7. El tercer constructor recibe como argumentos una lista de listas con las apuestas, ytienen las siguientes caracterısticas: (5 puntos)

a) Asignar valores a la variable apuestas.

b) A continuacion se le da un valor aleatorio entre 1 y numeromaximo a la variablecomplementario, en la que se almacena el numero complementario.

c) Analogamente, se le asigna un valor aleatorio entre 1 y numeromaximo a lavariable reintegro, en la que se almacena el numero correspondiente al reintegro.


8. La clase contiene un metodo que se llama aciertosapuestas que recibe como ar-gumento una lista con 6 numeros enteros que se corresponden con la combinacionganadora del sorteo. Con esa informacion se recorreran todas los apuestas y se con-taran el numero de aciertos, almacenandolos en la variable aciertos. (8 puntos)

9. Se creara otro metodo llamado aciertocomplementario que recibe como argumentoun numero que se corresponde con el numero complementario del sorteo, que devuelve“verdadero” si se ha acertado, y “falso” en caso contrario. (4 puntos)

10. Se creara otro metodo llamado aciertoreintegro que recibe como argumento unnumero que se corresponde con el numero del reintegro del sorteo, que devuelve “ver-dadero” si se ha acertado, y “falso” en caso contrario. (4 puntos)

11. Otro de los metodos calcula el numero maximo de aciertos almacenado en la variableaciertos para cada una de las apuestas. (5 puntos)

12. El siguiente de los metodos llamado cinco_comple comprueba si al menos en algu-na de las apuestas se han obtenido 5 aciertos y ademas se ha acertado el numerocomplementario, para ello se supone que en todas las variables ya esta la informacionnecesaria. (5 puntos)

13. Por ultimo, el metodo precio calcula el precio de la primitiva teniendo en cuenta quesolo se participa en un sorteo. (5 puntos)

A continuacion se genera una segunda clase llamada Apuesta que contiene el metodomain y que pertenece al mismo paquete primitiva:

1. Crear un objeto primitiva con 5 apuestas en las que los resultados sean aleatorios yalmacenarlo en una variable con tu mismo nombre. (4 puntos)

2. Escribe las los numeros de las apuestas creados anteriormente, escribiendo en cadafila los seis numeros de cada apuesta. (4 puntos)

3. Escribe el numero complementario y el reintegro de tu variable de tipo Primitiva. (4puntos)


5. Almacenar en una lista de enteros 6 resultados cualesquiera para suponer que son losvalores correctos del sorteo de la primitiva. (4 puntos)

6. Calcular los aciertos de cada una de las apuestas. (4 puntos)


8. Escribir en pantalla si se ha acertado el complementario o no suponiendo que el valorcorrecto del numero complementario es el 17. (4 puntos)

9. Escribir en pantalla si se ha acertado el reintegro o no suponiendo que el valor correctodel reintegro es el 31. (4 puntos)


Tiempo: 2h.

Solucion:

Se va a proceder a generar un programa para la gestion de La Primitiva. El funcionamien-to del sorteo es el siguiente. Las Apuestas solo podran efectuarse en uno de los 2 boletosque edita Loterıas y Apuestas del Estado, que se podran conseguir en los establecimientosautorizados. El boleto de Banda Verde mostrado en la Figura A.14 sirve para un solo Sorteode los dos que hay, si se valida de Lunes a Jueves entra a concursar para el Sorteo del Jueves,si se valida de Viernes a Sabado, entra a concursar para el Sorteo del Sabado.

Figura A.14: Boleto de Banda Verde que edita Loterıas y Apuestas del Estado para elsorteo de La Primitiva.

Se puede jugar sin necesidad de utilizar el boleto, siendo el Terminal de Juego, el quepor Azar, nos elige la combinacion segun el importe que se desee gastar.

Utilizando los boletos se puede jugar por varios sistemas, en este caso se opta por elMetodo directo sencillo: Se puede jugar de 1 a 8 Apuestas en un mismo boleto. Parajugar 1 apuesta se marcan las seis cruces en el primer bloque de los 8 que tiene el boleto,eligiendo los numeros que deseemos. Para jugar 2 Apuestas marcaremos 6 numeros en elprimer bloque y 6 en el segundo, y ası sucesivamente. Los bloques marcados seran siemprecorrelativos de izquierda a derecha, no pudiendo dejar ninguno en blanco.


Importe en eurosApuestas Un sorteo Dos sorteos

1 1,00 2,002 2,00 4,003 3,00 6,004 4,00 8,005 5,00 10,006 6,00 12,007 7,00 14,008 8,00 16,00

Concluido el Sorteo dara comienzo el escrutinio de todas las apuestas validadas queparticipan en el Concurso, para asignar los premios que correspondan a cada una por co-incidencia entre la Combinacion Ganadora y los pronosticos que constan en las apuestas.Solo se podra percibir un premio por apuesta.

EL PRIMER premio consiste en acertar los 6 numeros que salen del bombo, perodado que la Combinacion Ganadora consta de seis numeros.




Tambien se establece un premio complementario. Junto a los seis numeros que com-pone la Combinacion Ganadora se extrae un septimo denominado Complementariodestinado a ofrecer premio a los acertantes de 5 numeros que ademas acierten estenumero, se trata del premio de 5+Complementario.

Tambien se obtiene premio cuando el numero designado como Reintegro en nuestroboleto, coincida con la bola que se extrae en el sorteo destinada a ese premio, en esecaso sera abonado el importe de la apuesta jugada en el boleto.

Para la elaboracion del programa se comienza creando una clase denominada Primitivaque tiene las caracterısticas siguientes:

1. La clase pertenece al paquete primitiva. (2 puntos)

package primitiva;

2. Las variables de instancia que caracterizan un objeto de la clase Primitiva son elnumero de numeros que se seleccionan para cada apuesta (6), el numero maximo deapuestas (8), y el numero de posibles valores enteros que pueden tomar los numeros(49). Las variables se llamaran numeros, napuestas y numeromaximo, respecti-vamente. Tendran un valor fijo que no se puede modificar y que debera fijarse en elmomento de la declaracion de las variables, y seran comunes para todos los elementosde la clase Primitiva. (4 puntos)


public class Primitiva {

final static int numeros = 6;final static int napuestas = 8;final static int numeromaximo = 49;

3. Dado que no es necesario completar todas las apuestas, se declarara una variablellamada numeroapuestas en la que posteriormente se almacenara el numero deapuestas para una primitiva sellada. Ademas, para almacenar la informacion de cadaprimitiva se declarara la variable apuestas que tendra tantas filas como numero deapuestas y de columnas el numero de numeros de cada apuesta (6). En cada una de lasfilas de la variable apuestas se almacenan los seis numeros seleccionados para cadaapuesta. Para almacenar el numero de aciertos de cada apuesta se declara una variablellamada aciertos. Y por ultimo para almacenar tanto el numero complementario comoel reintegro se declaran las variables complementario y reintegro. (4 puntos)

int apuestas [][];int aciertos [];

int numeroapuestas,complementario, reintegro;


public Quiniela() {super();

}

5. Se creara un metodo que se llamara apuestaleatoria, que no recibe ningun argumentoy que devuelve una lista con el numero de numeros (utilizar la informacion de lasvariables ya declaradas e inicializadas) necesario para realizar una apuesta, con lassiguientes caracterısticas: (8 puntos)

a) Los numeros han de generarse de forma aleatoria para ello se emplea la expresion(int) Math.ceil(numeromaximo*Math.random()) que devuelve un numero en-tero aleatorio entre 1 y numeromaximo.

b) Ninguno de los numeros se puede repetir.

public int[] apuestaleatoria (){int lista[] = new int[numeros];int aux=0;boolean repetido;for(int i=1;i<=numeros;i++){repetido = true;while(repetido){


aux = (int) Math.ceil(numeromaximo*Math.random());repetido = false;for(int j=1;j<i;j++){if(aux==lista[j-1]){

repetido = true;break;

}}

}lista[i-1]=aux;

}return(lista);

}

6. El segundo constructor recibe un numero entero que se corresponde con el numero deapuestas que se quieren rellenar, y se encarga de: (8 puntos)


b) Se le asigna valor a la variable numeroapuestas.

c) En tercer lugar se inicializaran los valores de la variable apuestas empleando elmetodo creado en el apartado 5. Notese que el metodo devuelve una lista quese corresponde con cada una de las filas de la matriz almacenada en la variableapuestas.

d) A continuacion se le da un valor aleatorio entre 1 y numeromaximo a la variablecomplementario, en la que se almacena el numero complementario.

e) Analogamente, se le asigna un valor aleatorio entre 1 y numeromaximo a lavariable reintegro, en la que se almacena el numero correspondiente al reintegro.

public Primitiva(int numeroapuestas) {this.numeroapuestas = numeroapuestas;apuestas = new int[numeroapuestas][numeros];int lista[];for(int j=1;j<=numeroapuestas;j++){lista = this.apuestaleatoria();for(int i=1;i<=numeros;i++){

apuestas[j-1][i-1]=lista[i-1];}

}complementario = (int) Math.ceil(numeromaximo*Math.random());reintegro = (int) Math.ceil(numeromaximo*Math.random());

}

7. El tercer constructor recibe como argumentos una lista de listas con las apuestas, ytienen las siguientes caracterısticas: (5 puntos)


a) Asignar valores a la variable apuestas.

b) A continuacion se le da un valor aleatorio entre 1 y numeromaximo a la variablecomplementario, en la que se almacena el numero complementario.

c) Analogamente, se le asigna un valor aleatorio entre 1 y numeromaximo a lavariable reintegro, en la que se almacena el numero correspondiente al reintegro.

public Primitiva(int apuestas [][]) {this.apuestas = apuestas;complementario = (int) Math.ceil(numeromaximo*Math.random());reintegro = (int) Math.ceil(numeromaximo*Math.random());

}

8. La clase contiene un metodo que se llama aciertosapuestas que recibe como ar-gumento una lista con 6 numeros enteros que se corresponden con la combinacionganadora del sorteo. Con esa informacion se recorreran todas los apuestas y se con-taran el numero de aciertos, almacenandolos en la variable aciertos. (8 puntos)

public void aciertosapuestas (int resultados[]){aciertos=new int[numeroapuestas];for(int i=1;i<=numeroapuestas;i++){aciertos[i-1] =0;

}int k;boolean encontrado;for(int i=1;i<=numeroapuestas;i++){for(int j=1;j<=numeros;j++){k=1;encontrado = false;while(!encontrado && k<=numeros){if(apuestas[i-1][j-1]==resultados[k-1]){encontrado = true;aciertos[i-1]+=1;

}k++;

}}

}}

9. Se creara otro metodo llamado aciertocomplementario que recibe como argumentoun numero que se corresponde con el numero complementario del sorteo, que devuelve“verdadero” si se ha acertado, y “falso” en caso contrario. (4 puntos)

public boolean aciertocomplementario(int compleres){boolean completrue = false;if(complementario==compleres){completrue = true;


}return(completrue);

}

10. Se creara otro metodo llamado aciertoreintegro que recibe como argumento unnumero que se corresponde con el numero del reintegro del sorteo, que devuelve “ver-dadero” si se ha acertado, y “falso” en caso contrario. (4 puntos)

public boolean aciertoreintegro(int reinres){boolean reintrue = false;if(reintegro==reinres){reintrue = true;

}return(reintrue);

}

11. Otro de los metodos calcula el numero maximo de aciertos almacenado en la variableaciertos para cada una de las apuestas. (5 puntos)

public int maxacierto (){int maximo = aciertos[0];for(int j=1;j<numeroapuestas;j++){if(aciertos[j]>maximo){

maximo = aciertos[j];}

}return(maximo);

}

12. El siguiente de los metodos llamado cinco_comple comprueba si al menos en algu-na de las apuestas se han obtenido 5 aciertos y ademas se ha acertado el numerocomplementario, para ello se supone que en todas las variables ya esta la informacionnecesaria. (5 puntos)

public boolean cinco_comple (int compleres){boolean acierto = false;for(int i=1;i<=numeroapuestas;i++){if(aciertos[i-1]==5 && this.aciertocomplementario(compleres)){

acierto = true;break;

}}return(acierto);

}


13. Por ultimo, el metodo precio calcula el precio de la primitiva teniendo en cuenta quesolo se participa en un sorteo. (5 puntos)

public double precio () {double coste;coste = numeroapuestas*1;return(coste);

}

}// Fin la clase Primitiva

A continuacion se genera una segunda clase llamada Apuesta que contiene el metodomain y que pertenece al mismo paquete primitiva:

1. Crear un objeto primitiva con 5 apuestas en las que los resultados sean aleatorios yalmacenarlo en una variable con tu mismo nombre. (4 puntos)

Primitiva roberto = new Primitiva(5);

2. Escribe las los numeros de las apuestas creados anteriormente, escribiendo en cadafila los seis numeros de cada apuesta. (4 puntos)

System.out.println("Las apuestas por filas son las siguientes:");for(int i=1;i<=roberto.numeroapuestas;i++){for(int j=1;j<=Primitiva.numeros;j++){System.out.print(roberto.apuestas[i-1][j-1]+" ");

}System.out.println(" ");

}

3. Escribe el numero complementario y el reintegro de tu variable de tipo Primitiva. (4puntos)

System.out.println("El numero complementario es el "+roberto.complementario);

System.out.println("El numero de reintegro es "+roberto.reintegro);


System.out.println("El precio de la Quiniela es de "+roberto.precio()+" euros.");

5. Almacenar en una lista de enteros 6 resultados cualesquiera para suponer que son losvalores correctos del sorteo de la primitiva. (4 puntos)

int resultado []= {12,24,2,49,36,27};

6. Calcular los aciertos de cada una de las apuestas. (4 puntos)


roberto.aciertosapuestas(resultado);


System.out.println("El numero maximo de aciertos es de "+roberto.maxacierto());

8. Escribir en pantalla si se ha acertado el complementario o no suponiendo que el valorcorrecto del numero complementario es el 17. (4 puntos)

if(roberto.aciertocomplementario(17)){System.out.println("Ha acertado el complementario.");

} else {System.out.println("No ha acertado el complementario.");

}

9. Escribir en pantalla si se ha acertado el reintegro o no suponiendo que el valor correctodel reintegro es el 31. (4 puntos)

if(roberto.aciertocomplementario(17)){System.out.println("Ha acertado el complementario.");

} else {System.out.println("No ha acertado el complementario.");

}

Tiempo: 2h.

Bibliografıa

[1] E. Castillo, A. Cobo, P. Gomez, y C. Solares, JAVA TM Un lenguaje de programacionen Internet. Madrid, Espana: Paraninfo, 2000. Paraninfo, 1997. Libro que por suscontenidos puede ser considerado como basico para los alumnos. En este libro se de-sarrollan con gran detalle los temas del programa correspondientes a la parte de Java,excepto el tema de control de sucesos. Los distintos conceptos se explican de una formaclara y con gran numero de ejemplos, lo cual facilita su estudio. En cada capıtulo seplantea una coleccion de problemas relacionados con los conceptos vistos.

[2] D. Flanagan. Java Examples in a Nutshell. o’Reilly, 1997. Se trata de un libro muyinteresante del cual pueden ser extraidos gran cantidad de ejemplos y ejercicios que secorresponden con los contenidos de los Temas 1, 2, 3, 4, 5 y 6 de lenguaje Java.

[3] Cay S. Horstmann and Gary Cornell. Core Java. Volume 1. Mc Graw-Hill, 1999. Librode nivel avanzado, en este libro se tratan con rigor cada uno de los temas del programade Lenguaje Java. Ademas muestra ejemplos muy interesantes de utilizacion de dicholenguaje. Cabe destacar el tratamiento que hace de los Temas 4 y 5 del programa.

[4] C. Thomas Wu. An Introduction to Object-Oriented Programming with Java. SunMicrosystems, 1997. Libro muy interesante en el cual se exponen de forma muy claray concisa los temas de lenguaje orientado a objeto, lenguaje java y control de sucesos.Al principio de cada tema hace un esquema con los objetivos del mismo, la exposicionse hace de una forma muy clara con esquemas graficos que facilitan su comprensiony con gran numero de ejemplos. Al final de cada tema se presenta una coleccion mycompleta de ejercicios relativos al mismo.

[5] W. Savitch. Java. An Introduction to Computer Science and Programming. PrenticeHall, 1999. Se trata de un libro muy completo en el cual se tratan todos los temas delprograma de Java salvo los Temas 7 y 8 de procesos ligeros y desarrollo de animacionesen Java. La exposicion es muy clara y detallada, los conceptos y comandos nuevosde cada tema aparecen destacados respecto al resto del texto, lo mismo ocurre conlos distintos programas ejemplo que se muestran. Todos los conceptos y comandosaparecen ilustrados con programas de ejemplo, y al final de cada tema se presenta unacoleccion de ejercicios relativos al mismo.

157

Documents

PROGRAMACION EN LENGUAJE´ JAVArobertominguez.altervista.org/files/CursoJAVA.pdf · libro JAVA TM Un lenguaje de programaci´on en Internet escrito por E. Castillo, A. Cobo, P. G´omez,