Ejercicos en Java

Tarea para PROG01.
Detalles de la tarea de esta unidad.

Enunciado.
Esta unidad ha realizado un recorrido por numerosos conceptos teóricos sobre programación, paradigmas, ciclos de vida, etc. para posteriormente centrar nuestra
atención en el lenguaje de programación Java, sus características y ventajas. Seguidamente, se ha descrito cómo poder crear programas en Java, compilarlos y
ejecutarlos de manera básica. Para finalmente, llevar a cabo estas tareas a través de un entorno integrado de desarrollo fiable y profesional.
Pues bien, en esta tarea tendrás como objetivo realizar las operaciones necesarias para preparar tu ordenador de tal manera que pueda desarrollar programas en el
lenguaje Java, compilarlos y ejecutarlos de manera básica, y también a través de un entorno de desarrollo integrado como NetBeans.
Relación de apartados a realizar:
Apartado A:
Descarga desde la web recomendada en los contenidos, Java SE e instálalo en tu equipo.
Siguiendo las indicaciones dadas para configurar las variables PATH y CLASSPATH, lleva a cabo la configuración de las mismas.
Comprueba a través de consola de comandos, que has realizado correctamente la instalación y configuración del JDK y JRE.
Crea una carpeta en tu equipo para alojar los ejercicios y programas que se irán generando en cada una de las actividades que se planteen en las unidades de
trabajo. Te recomendamos que el nombre de esta carpeta sea sencillo, sin espacios en blanco (puedes sustituirlos por guiones bajos), ni caracteres especiales. Por
ejemplo: Ejercicios_Java.
En dicha carpeta, crea utilizando algún editor de texto un archivo con extensión “.java” al que debes llamar PROG01_programa1.java. En su interior, basándote en el
ejercicio resuelto de la unidad, inserta las líneas necesarias de código Java para obtener por pantalla el siguiente resultado:
Módulo Profesional – PROGRAMACIÓN. UNIDAD DE TRABAJO 01. Introducción a la programación. nombre y apellidos del alumno/a. Localidad y provincia. Fecha de
realización del ejercicio. programa1
Una vez creado el código fuente, guarda el archivo y, mediante línea de comandos, realiza la compilación del mismo.
Comprueba lo que ha ocurrido en la carpeta donde esta el archivo “.java” que acabas de compilar.
Realiza la ejecución del programa creado.
Visualiza en pantalla los resultados.
Si no se ajustan al ejemplo, realiza las modificaciones necesarias sobre el archivo fuente, vuelve a compilarlo y lanza su ejecución otra vez.
Apartado B:
Siguiendo las indicaciones de los contenidos de la unidad, descarga desde los enlaces ofrecidos el IDE NetBeans e instálalo en tu ordenador. Inicia NetBeans,
visualiza las partes del entorno y abre el archivo “.java” que habías creado anteriormente.
Añade alguna línea más al código fuente o un comentario aclaratorio, compila y ejecuta dicho programa.
Observa los resultados en el área reservada para tal efecto en el entorno.
Criterios de puntuación. Total 10 puntos. Apartado A – 5 puntos. Apartado B – 5 puntos. Total: 10 puntos.
Recursos necesarios para realizar la Tarea. Ordenador personal. Sistema operativo Windows o Linux. Conexión a Internet.
JDK y JRE de Java. Entorno NetBeans 7.0. Consejos y recomendaciones. La descarga de los archivos de instalación es recomendable que se realice a través de los
enlaces propuestos dentro de los contenidos de la unidad de trabajo. Para la creación de archivos “.java” es conveniente crear una carpeta donde ir alojándolos.
Puedes tomar como referencia el ejercicio resuelto de los contenidos de la unidad de trabajo. Las capturas de pantalla que se han de realizar se recomienda que se
guarden en formato “.jpg” para que su tamaño no sea demasiado grande. Indicaciones de entrega. Para cada uno de los apartados, hay que realizar una captura de
pantalla completa (no únicamente de la ventana donde está contenido el resultado a capturar) en la que puedan observarse los siguientes elementos:
Apartado A:
Diversas capturas de pantalla que acrediten el proceso de instalación del JDK y JRE de Java, configuración adecuada de las variables de entorno PATH y
CLASSPATH, así como comprobación del correcto funcionamiento del compilador a través de consola de comandos.
Contenido de la carpeta, a través de línea de comandos, donde se ha alojado el programa, visualizándose el archivo “.java” y el archivo “.class” correspondientes.
Resultado, a través de línea de comandos, de la ejecución del programa “.java”.
Apartado B:
Contenido de la carpeta a través del panel adecuado de NetBeans, donde se ha alojado el programa, visualizándose el archivo “.java” y el archivo “.class”
correspondientes. Resultado, a través de NetBeans, de la ejecución del programa creado. Las capturas de pantalla solicitadas deben reunirse en un único archivo
realizado con procesador de textos y comprimido con extensión zip o rar. El envío se realizará a través de la plataforma de la forma establecida para ello, y el archivo
se nombrará siguiendo las siguientes pautas:
apellido1_apellido2_nombre_SIGxx_Tarea.
Asegúrate que el nombre no contenga la letra ñ, tildes ni caracteres especiales extraños. Así por ejemplo la alumna Begoña Sánchez Mañas para la primera unidad
del MP de TEA, debería nombrar esta tarea como...
sanchez_manas_begona_TEA01_Tarea
Página 1 de 39
Tarea para PROG02.
Tarea para PROG02.
Enunciado.
En esta unidad hemos tenido la oportunidad de crear nuestro primer programa en Java. Hemos realizado pequeños ejemplos sobre cada apartado tratado, y ahora se
trata de ponerlos en práctica mediante la siguiente relación de ejercicios:
Relación de ejercicios a realizar:
1.- Dados los siguientes identificadores, indicar si son válidos o no. Justificar las respuestas.
mi variable:…………………. incorrecto, no se pueden utilizar espacios en blanco.

num_de_cte:……………….. correcto, tiene varias palabras unidas por guiones bajos, que sí son permitido;
evitando los espacios en blanco.
____programa:…………….. incorrecto, se admite un solo guión bajo al inicio.
$alguna:…………………….. Correcto, se puede usar $como primer carácter pero no es habitual.
3tema:………………………..Incorrecto, no puede empezar por numero.
cierto?.................................. Incorrecto, símbolo interrogación no se puede utilizar.
númerodeCliente:…………. Correcto.
jose~:?................................ Incorrecto,simbolos que no se pueden utilizar
año:…………………………. Incorrecto, la ñ no es válida
PI:…………………………….incorrecto palabra reservada es la cte PI
Int…………………………… palabra reservada número entero.
2.- Dado el siguiente programa, modifícalo para utilizar las variables que se indican. El tipo de dato elegido debe ser el de menos bits posibles que puedan
representar el valor. Justifica tu elección.
public class ejerciciovariables {
// Utilizamos tipos enumerados para crear la clase genero que puede tomar solo un conjunto
determinado de valores.
public enum genero {F, M};
public static void main(String[ ] args) {

boolean casado; // Utilizamos boolean que devuelve verdadero o falso
en función de si está casado o no.
final int MAXIMO=999999; // Al no ser un valor modificable utilizamos una constante.
byte diaSem; // Utilizamos tipo byte porque necesitamos almacenar
valores enteros hasta 7.
short diaAnual; // Utilizamos tipo short porque necesitamos
almacenar valores enteros hasta el 365.
long miliseg; // Utilizamos tipo long porque necesitamos almacenar
valores enteros hasta 1.419.120.000.000.
float totalFactura; // Utilizamos tipo float porque necesitamos
almacenar valores con coma flotante.
long poblacion; // Utilizamos tipo long porque necesitamos almacenar
valores enteros mayores de 7.000.000.000.
genero sexo=genero.M; // Utilizamos el tipo enumerado genero que hemos creado
para asignar a sexo uno de los valores de ese tipo.
}
}

public static void main(String[ ] args) {
}
}
a. Si un empleado está casado o no.
b. Valor máximo no modificable: 999999.
c. Día de la semana
d. Día del año.
e. Sexo: con dos valores posibles 'V' o 'M'
f. Milisegundos transcurridos desde el 01/01/1970 hasta nuestros días.
g. Almacenar el total de una factura
h. Población mundial del planeta tierra.
3.- Realiza las siguientes modificaciones en el programa anterior:
Página 2 de 39
a. Añade comentarios, entre otros:
o Nombre de clase, descripción y autor
o Comentario para la clase main y para cada una de las llaves de cierre
b. Utiliza el operador de asignación para inicializar las variables a los valores que se indican en los mensajes.
c. Utiliza la secuencia de escape correspondiente para generar un tabulador al principio de cada línea salvo de la primera
d. Mostrar el siguiente resultado:
o Usando sólo la orden println:
----- EJERCICIO DE VARIABLES Y TIPOS DE DATOS -----
El valor de la variable casado es true
El valor de la variable MAXIMO es 999999
El valor de la variable diasem es 1
El valor de la variable diaanual es 300
El valor de la variable miliseg es 1298332800000
El valor de la variable totalfactura es 10350.678
El valor de la variable poblacion es 6775235741
El valor de la variable sexo es M
o Usando sólo la orden print:
El valor de la variable totalfactura es 10350.678
o Usando sólo la orden printf:
El valor de la variable totalfactura es 10350,677734
El valor de la variable totalfactura en notación científica es 1.035068E+04
/**
* class ejerciciovariables
* tarea en la que practicamos las variables , comentarios y la salida por consola
* @author Eduardo Hortiguela Aparico
* en este primer comentario servirÃ¡ para generar documentaciÃ³n automÃ¡tica con javadoc
*/
//Declaramos las variables y las asignamos el valor correspondiente
public static void main(String[] args) {
boolean casado = true;
final int MAXIMO = 999999;
byte diasem = 1;
short diaanual = 300;
char sexo = 'M';
long miliseg = 1298332800000L , poblacion = 6775235741L;
float totalfactura = 10350.678F;
/**
* definimos las distintas variables
* imprimimos por pantalla
* con println nos da el salto de linea automÃ¡tico
* con print tenemos que darlo con \n el salto de linea
* con printf podemos dar distintos formatos a los datos
*/
// println aÃ±adimos \t para dar el tabulador
System.out.println("----- EJERCICIO DE VARIABLES Y TIPOS DE DATOS -----");
System.out.println("\tEl valor de la variable casado es "+ casado);
System.out.println("\tEl valor de la variable MAXIMO es "+ MAXIMO);
System.out.println("\tEl valor de la variable diasem es "+ diasem);
System.out.println("\tEl valor de la variable diaanual es "+ diaanual);
System.out.println("\tEl valor de la variable miliseg es "+ miliseg);
System.out.println("\tEl valor de la variable totalfactura es "+ totalfactura);
System.out.println("\tEl valor de la variable poblacion es "+ poblacion);
Página 3 de 39
System.out.println("\tEl valor de la variable sexo es "+ sexo);
//print utilizamos \n y \t para dar salto de linea y tabulaciÃ³n

System.out.print("----- EJERCICIO DE VARIABLES Y TIPOS DE DATOS -----");
System.out.print("\n\tEl valor de la variable casado es "+ casado);
System.out.print("\n\tEl valor de la variable MAXIMO es "+ MAXIMO);
System.out.print("\n\tEl valor de la variable diasem es "+ diasem);
System.out.print("\n\tEl valor de la variable diaanual es "+ diaanual);
System.out.print("\n\tEl valor de la variable miliseg es "+ miliseg);
System.out.print("\n\tEl valor de la variable totalfactura es "+ totalfactura);
System.out.print("\n\tEl valor de la variable poblacion es "+ poblacion);
System.out.print("\n\tEl valor de la variable sexo es "+ sexo+"\n");
/*printf este comentario no se utilizara en javadoc

\n y \t para salto de linea y tabulaciÃ³n luego para la poner el
decimal utilizamos %f flotante y le damos la precisiÃ³n .6
para darle 6 decimales ,%.6F, para la notaciÃ³n cientÃfica utilizamos %E*/
System.out.printf("----- EJERCICIO DE VARIABLES Y TIPOS DE DATOS -----");
System.out.printf("\n\tEl valor de la variable casado es "+ casado);
System.out.printf("\n\tEl valor de la variable MAXIMO es "+ MAXIMO);
System.out.printf("\n\tEl valor de la variable diasem es "+ diasem);
System.out.printf("\n\tEl valor de la variable diaanual es "+ diaanual);
System.out.printf("\n\tEl valor de la variable miliseg es "+ miliseg);
System.out.printf("\n\tEl valor de la variable totalfactura es %.6f", totalfactura);
System.out.printf("\n\tEl valor de la variable totalfactura en notaciÃ³n cientÃfica es %E",
totalfactura);
System.out.printf("\n\tEl valor de la variable poblacion es "+ poblacion);
System.out.printf("\n\tEl valor de la variable sexo es "+ sexo+"\n");
} // cierre del main
} //cierre de la clase
4.- Indica los errores presentes en el siguiente código:
Código del enunciado.

1. /
2. operadoresaritmeticos.java
3. Programa que muestra el uso de los operadores aritméticos
4. /
5. public class operadoresaritmeticos {
6. public static main(String[] args)
7. short x = 7;
8. int y = 5;
9. float f1 = 13.5;
10. float f2 = 8f;
11. System.out.println("El valor de x es ", x, " y el valor de y es ", y);
12. System.out.println("El resultado de x + y es " + (x + y));
13. System.out.println("El resultado de x - y es " + (x - y));
14. System.out.printf("\n%s%s\n","División entera:","x / y = ",(x/y));
15. System.out.println("Resto de la división entera: x % y = " + (x % y));
16. System.out.printf("El valor de f1 es %f y el de f2 es %f\n",f1,f2);
17. System.out.println("El resultado de f1 / f2 es " + (f1 / f2))
18. }
Solución línea a línea.
1. INCORRECTA: Para añadir comentarios que ocupen más de una línea se ha de comenzar por /*
2. CORRECTA
3. CORRECTA
4. INCORRECTA: Para terminar comentarios que ocupen más de una línea se debe poner */
5. CORRECTA
6. INCORRECTA: Falta incluir la palabra void y un { .La forma correcta sería public static void
main(String[] args) {
7. CORRECTA
8. CORRECTA
Página 4 de 39
9. INCORRECTA: Los valores de las variables float tienen que tener al final una letra f, la forma
correcta de declarar e iniciar f1 sería float f1 = 13.5f;
10. CORRECTA
11. INCORRECTA: Para concatenar elementos se utiliza el operador “+” y no “,” como aparece en el
código. La forma correcta de programar la línea sería System.out.println("El valor de x es "+ x+ " y
el valor de y es "+ y);
12. CORRECTA
13. CORRECTA
14. INCORRECTA: La línea de código incluye 3 argumentos, pero sólo se hace referencia a 2. La forma
correcta de programar la línea es System.out.printf("\n%s%s%d\n","División entera:","x / y = ",(x/y));
15. CORRECTA
16. CORRECTA
17. INCORRECTA: Al final de cada línea de código se debe poner “;” y esta línea no la tiene. Además en
la siguiente línea tendríamos que cerrar el corchete que abrimos (y que tampoco estaba en el código)
después del método main (línea 6).
18. CORRECTA
1. /
2. operadoresaritmeticos.java
3. Programa que muestra el uso de los operadores aritméticos
4. /
5. public class operadoresaritmeticos {

6. public static main(String[] args)
7. short x = 7;
8. int y = 5;
9. float f1 = 13.5;
10. float f2 = 8f;
11. System.out.println("El valor de x es ", x, " y el valor de y es ", y);
12. System.out.println("El resultado de x + y es " + (x + y));
13. System.out.println("El resultado de x - y es " + (x - y));
14. System.out.printf("\n%s%s\n","División entera:","x / y = ",(x/y));
15. System.out.println("Resto de la división entera: x % y = " + (x % y));
16. System.out.printf("El valor de f1 es %f y el de f2 es %f\n",f1,f2);
17. System.out.println("El resultado de f1 / f2 es " + (f1 / f2))
18. }
5.- Diseña un programa Java que pida dos números por teclado, determine si el primero es múltiplo del segundo y muestre el resultado.
import java.util.Scanner;
/*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
/**
*
* @author CarHerEst
* @date 13-nov-2016
*/
public class prog02_ejer05 {
public static void main(String[] args) { // Metodo principal que inicia el programa.
Scanner teclado = new Scanner(System.in); // Clase Scanner para la introduccion de tados por
teclado.
int x,y; // Declaracion de variables.
String multiplos; // Declaracion de variables.
System.out.println("Intruduce primer nÃºmero"); // PeticiÃ³n del primer nÃºmero.

x = teclado.nextInt(); // AsignaciÃ³n del valor introducido a la
variable x.
System.out.println("Introduce segundo nÃºmero"); // PeticiÃ³n del segundo nÃºmero.
Página 5 de 39
y = teclado.nextInt(); // AsignaciÃ³n del valor introducido a la
variable y.
// Para determinar si 2 nÃºmero son multiplos, el resto de su divisiÃ³n es 0

multiplos = x%y==0 ? " son multiplos" : " no son multiplos"; // Utilizamos el operador
condicional para determinar si son mÃºltiplos.
System.out.println("Los nÃºmeros " + x + " y " + y + multiplos); // Impresion por pantalla del
resultado.
6.- Diseña un programa Java que cree un tipo enumerado para los meses del año. El programa debe realizar las siguientes operaciones:
• Crear una variable m del tipo enumerado y asignarle el mes de marzo. Mostrar por pantalla su valor.
• Asignar a la variable m, la cadena de texto "MARZO". Mostrar por pantalla el valor de la variable de tipo enumerado tras realizar la asignación.
/*
*/
/**
*
* @author CarHerEst
* @date 13-nov-2016
*/
public enum meses {Enero, Febrero, Marzo, Abril, Mayo, Junio, Julio, Agosto, Septiembre, Octubre,
Noviembre, Dicimbre}; // CreaciÃ³n del tipo enumerado.
public static void main(String[] args) { // Metodo principal que inicia el programa.
meses m = meses.Marzo; // DeclaraciÃ³n e iniciaciÃ³n de una variable del tipo enumerado
meses.
System.out.println("El valor de la variable enumerada m es " + m); //Muestra por pantalla
el valor de la variable enumerada.
System.out.println("El valor de la variable m de tipo String es " + String.valueOf(m)); //
Valor de la variable m despues de realizar la asignaciÃ³n a String.
7.- Diseña un programa Java para resolver una ecuación de primer grado con una incógnita (x), suponiendo que los coeficientes de la ecuación (C1 y C2) se
introducen desde teclado.
C1x + C2 = 0
import java.util.Scanner; //ImportaciÃ³n del paquete necesario para el uso de la clase Scanner.
/*
*/
/**
*
* @author CarHerEst
* @date 13-nov-2016
*/
Página 6 de 39
public static void main(String[] args) { // Metodo main del programa.
Scanner teclado = new Scanner(System.in); // Clase Scanner para la introduccion de tados por
teclado.
double c1,c2,x; // Declaracion de variables.
System.out.println("Introducir coeficiente c1"); // Peticion de datos por pantallas.

c1 = teclado.nextDouble(); // Asignacion del valor introducido a la
variable c1.
System.out.println("Introducir coeficiente c2"); // Peticion de datos por pantalla.
c2 = teclado.nextDouble(); // Asignacion del valor introducido a la
variable c2.
x = -c2/c1; // Asignacion del valor de x despejando la ecuacion.

System.out.println("El valor de x en la ecuaciÃ³n " + c1 + "x + " + "c2 = 0 es: ");
//Impresion por pantalla de resultados.
System.out.println("x=" + x);
}
8.- Diseña un programa Java que calcule la suma, resta, multiplicación y división de dos números introducidos por teclado. Incorpora también las funciones que
permitan realizar la potencia de un número y la raíz cuadrada del otro. Salida del programa para x=9, y=3:
Introducir primer numero: 9
Introducir segundo numero: 3
import java.util.Scanner; //ImportaciÃ³n del paquete necesario para el uso de la

clase Scanner.
/*
*/
/**
*
* @author CarHerEst
* @date 13-nov-2016
*/
public static void main(String[] args) { // Metodo main del

programa.
Scanner teclado = new Scanner(System.in); // Clase Scanner para la

introduccion de tados por teclado.
double x,y; // Declaracion de
variables.
System.out.println("Introducir primer nÃºmero"); // Peticion de datos por

pantalla.
x = teclado.nextDouble(); // Asignacion del valor
introducido a la variable x.
System.out.println("Introducir segundo nÃºmero"); // Peticion de datos por
pantalla.
y = teclado.nextDouble(); // Asignacion del valor
introducido a la variable y.
System.out.println("x = "+ x +" y = "+ y); //ImpresiÃ³n de los valores

tecleados.
Página 7 de 39
System.out.println("x + y = "+ (x+y)); //ImpresiÃ³n del valor de la
suma de los nÃºmeros.
System.out.println("x - y = "+ (x-y)); //ImpresiÃ³n del valor de la
resta de los nÃºmeros.
System.out.println("x * y = "+ (x*y)); //ImpresiÃ³n del valor del
producto de los nÃºmeros.
System.out.println("x / y = "+ (x/y)); //Impresion del valor de la
divisiÃ³n entera de los nÃºmeros.
double cuadrado=Math.pow(x,2); //DeclaraciÃ³n e inicializaciÃ³n una variable

para el cÃ¡lculo de la potencia utilizando la clase Math.
double raiz=Math.sqrt(x); //DeclaraciÃ³n e inicializaciÃ³n una variable
para el cÃ¡lculo de la raiz cuadrada utilizando la clase Math.
System.out.println("x ^ 2 = "+ cuadrado); //ImpresiÃ³n del valor de la

potencia del primer nÃºmero.
System.out.println("âˆšx = "+ raiz); //ImpresiÃ³n del valor de
la raiz cuadrada del primer nÃºmero.
x = 9.0 y = 3.0
x + y = 12.0
x - y = 6.0
x * y = 27.0
x / y = 3.0
x ^ 2 = 81.0
√ x = 3.0
9.- Diseña un programa Java que solicite un número de 5 dígitos del teclado, separe el número en sus dígitos individuales y los muestre por pantalla. Por ejemplo, si
el número es 53123 que muestre:
53123
import java.util.Scanner; //ImportaciÃ³n del paquete necesario para el uso de la clase Scanner.
/*
*/
/**
*
* @author CarHerEst
* @date 13-nov-2016
*/
public static void main(String[] args) { // Metodo main del programa.
Scanner teclado = new Scanner(System.in); // Clase Scanner para la

introduccion de tados por teclado.
int digito, primero, segundo, tercero, cuarto, quinto; // Declaracion de variables.
System.out.println("Introduce un numero de 5 dÃgitos"); // Peticion por pantalla del

nÃºmero a descomponer.
digito = teclado.nextInt(); // AsignaciÃ³n del valor
introducido a la variable.
/* Para obtener los dÃgitos que forman el nÃºmero introducido, la operaciÃ³n que vamos a
realizar
* es utilizar el operador aritmÃ©tico resto de la divisiÃ³n entera para que al dividir entre
* 10 el resto que obtengamos sea el Ãºltimo dÃgito por la derecha. DespuÃ©s de cada
operaciÃ³n reasignamos a la
Página 8 de 39
* variable "num" el valor de la divisiÃ³n entera de el mismo ente 10. Repetimos estas
operaciones
* hasta tener todos los dÃgitos que forman el nÃºmero.
*/
quinto = digito % 10;
digito = digito / 10;
cuarto = digito % 10;

tercero = digito % 10;

segundo = digito % 10;

primero = digito;
System.out.println(primero + " " + segundo + " " + tercero + " " +cuarto + " " + quinto); //
PresetaciÃ³n por pantalla del resultado.
10.- Diseña un programa Java que realice las siguientes operaciones, en el orden que se muestran. Se indica la variable y el tipo de dato que recibe el valor o
resultado de la operación indicada:
Tipo_Variable Variable Valor / Operación

float x 4.5
float y 3.0
int i 2
int j i*x
double dx 2.0
double dz dx * y
byte bx 5
byte by 2
byte bz bx - by
byte bx -128
byte by 1
byte bz bx – by (resultado tipo byte)
byte bz bx – by (resultado tipo int)
short sx 5
short sy 2
short sz sx - sy
short sx 32767
short sy 1
short sz sx + sy
char cx \u000F
char cy \u0001
int z cx – cy
int z cx – 1
char cx \uFFFF
int z cx
short sx cx
short sx -32768
char cx sx
int z sx
short sx -1
char cx sx
int z cx
El resultado del programa debe ser el siguiente:

------- Conversiones entre enteros y coma flotante -------
Producto de int por float: j= i*x = 9
Producto de float por double: dz=dx * y = 6.0
------- Operaciones con byte -------
byte: 5 - 2 = 3
byte -128 - 1 = 127
(int)(-128 - 1) = -129
------- Operaciones con short -------
short: 10 - 1 = 3
Página 9 de 39
short 32767 + 1 = -32768
------- Operaciones con char -------

char: - = 14
char(0x000F) - 1 = 14
(int)( ) = 65535
(short)( ) = -1
-32768 short-char-int = 32768
-1 short-char-int = 65535
/*
*/
/**
*
* @author CarHerEst
* @date 14-nov-2016
*/
public static void main(String[] args) { //Inicio del metodo main.
float x = 4.5f; // DeclaraciÃ³n y asignacion de variables.

float y = 3.0f;
int i = 2;
int j = (int)(i * x);
System.out.println("----- COVERSIONES ENTRE ENTEROS Y COMA FLOTANTE -----"); // Impresion
por pantalla de resultados.
System.out.println("Producto de int por float: j = i * x = " + j);
double dx = 2.0;
double dz = dx * y;
System.out.println("Producto de float por double: dz = dx * y = " + dz);
byte bx = 5;
byte by = 2;
int bz = bx - by;
System.out.println("\n----- OPERACIONES CON BYTE -----");

System.out.println("byte: " + bx + " - " + by + " = " + bz);
bx = -128;
by = 1;
bz = (byte)(bx - by);
System.out.println("byte " + bx + " - " + by + " = " + bz);
bz = (int) (bx - by);

System.out.println("byte " + bx + " - " + by + " = " + bz);
short sx = 5;
short sy = 2;
short sz = (short) (sx - sy);
System.out.println("\n----- OPERACIONES CON SHORT -----");

System.out.println("short " + sx + " - " + sy + " = " + sz);
sx = 32767;
sy = 1;
sz = (short)(sx + sy);
System.out.println("short " + sx + " + " + sy + " = " + sz);
char cx = '\u000F';
char cy = '\u0001';
int z = cx - cy;
System.out.println("\n----- OPERACIONES CON CHAR -----");
Página 10 de 39
System.out.println("char " + cx + " - " + cy + " = " + z);
z = cx - 1;
System.out.println("char " + cx + " - 1 = " + z);
cx = '\uFFFF';
z = cx;
System.out.println("(int)" + cx + " = " + z);
sx = (short)cx;
System.out.println("(short)" + cx + " = " + sx);
Criterios de puntuación. Total 10 puntos.

1. 0,55
2. 0,50
3. 0,60
4. 0,35
5. 1,00
6. 1,00
7. 1,00
8. 1,50
9. 1,50
10. 2,00
Total 10
Recursos necesarios para realizar la Tarea.
NetBeans IDE 6.9.1 o superior

Indicaciones de entrega.
Te pedimos que cada ejercicio esté contenido en un fichero cuyo nombre sea similar a PROG02_EjerXX.java, donde la XX se sustituirá por el número del ejercicio.
Todos esos ficheros deben ser enviados al buzón de actividades. El tipo de archivo a entregar dependerá del ejercicio:
Documento procesador de textos: Ejercicios 1, 2, 4
Carpeta con el proyecto (código del programa): Ejercicios 3, 5, 6, 7, 8, 9, 10
En el documento escribirás la justificación de los ejercicios que así lo requieran. Debe ser de tipo ".doc" (Microsoft Word) o de tipo ".odt" (OpenOffice.org). El
documento debe tener tamaño de página A4, estilo de letra Times New Roman, tamaño 12 e interlineado normal.
Para subir la tarea al buzón de actividades, crea un único archivo comprimido que incluya todos los ficheros de los ejercicios, usando alguna aplicación de
compresión de archivos. El envío se realizará a través de la plataforma de la forma establecida para ello, y el archivo se nombrará siguiendo las siguientes pautas:
apellido1_apellido2_nombre_SIGxx_Tarea
Asegúrate que el nombre no contenga la letra ñ, tildes ni caracteres especiales extraños. Así por ejemplo la alumna Begoña Sánchez Mañas para la primera segunda
del PROG, debería nombrar esta tarea como...
sanchez_manas_begona_PROG02_Tarea
Tarea para PROG03.

Enunciado.
En esta unidad has visto las características fundamentales de la programación orientada a objetos y estudiado los conceptos más importantes de este modelo de
programación. Has aprendido a crear y manipular objetos, qué son los métodos y cómo se definen los parámetros. También has podido conocer cómo se estructura
la Biblioteca de Clases de Java, viendo algunas clases importantes, como por ejemplo las que nos permiten realizar la programación de la consola.
Para poder realizar la tarea de esta unidad vas a crear dos clases con una estructura básica. Las tareas a realizar se centrarán en la creación de instancias de esas
clases, la creación y utilización de unos métodos básicos, y el trabajo con constructores y parámetros.
Construye un proyecto en Java que utilice la clase Persona que se define a continuación:
public class Persona {

String nombre;
int edad;
Página 11 de 39
float altura;
String consulta_Nombre(){
return nombre;
}
void cambia_Nombre(String nom){
nombre=nom;
}
}
La clase debe incluir un método principal que solicite un valor al usuario y lo introduzca en el
atributo nombre, para posteriormente mostrar por pantalla el nuevo valor del atributo.
Añade a la clase Persona los métodos que faltan para poder consultar y modificar el valor de todos los
atributos. Para ello observa cómo se han creado los métodos del atributo nombre y determina los
parámetros y resultado de los demás atributos.

String nombre;
int edad;
float altura;
String consulta_Nombre() {
return nombre;
}
void cambia_Nombre(String nom) {
nombre = nom;
}
Scanner teclado = new Scanner(System.in);
String nombre;
Persona miPersona = new Persona();
System.out.println("Dame un nombre para cambiar ");

miPersona.cambia_Nombre(teclado.next());
System.out.println("El nuevo nombre es " + miPersona.consulta_Nombre());
} }
Después completa el programa para comprobar el funcionamiento de los nuevos métodos.

De la misma forma que has creado los métodos anteriores, crea ahora un método constructor para la
clase Persona que al declarar un objeto de tipo Persona asigne los siguientes valores a sus atributos:
nombre="tu nombre"
edad=17
altura=1,87
String nombre;
int edad;
float altura;
return nombre;
}
nombre = nom;
}
public int consulta_Edad() {
return edad;
}
public void cambia_Edad(int edad) {
this.edad = edad;
}
public float consulta_Altura() {
return altura;
}
public void cambia_Altura(float altura) {
this.altura = altura;
}
Página 12 de 39
String nombre;

System.out.println("Dame un nombre para cambiar ");
miPersona.cambia_Nombre(teclado.next());
System.out.println("El nuevo nombre es " + miPersona.consulta_Nombre());
System.out.println("Dame la edad");
miPersona.cambia_Edad(teclado.nextInt());
System.out.println("La nueva edad es " + miPersona.consulta_Edad());
System.out.println("Dame una altura");

miPersona.cambia_Altura(teclado.nextFloat());
System.out.println("La nueva altura es: "+miPersona.consulta_Altura());
} }
A continuación crea un proyecto que declare un objeto de tipo Persona utilizando el constructor, para
posteriormente mostrar el contenido de sus atributos por pantalla.
Crea un constructor con parámetros para la clase Persona que inicialice los atributos del objeto con
los valores indicados en los parámetros.

string nombre;
int edad;
float altura;
public Persona() {
nombre="Luisa Perez";
edad=22;
altura=1.7f;}
return nombre;
}
nombre = nom; }

return edad;}

this.edad = edad;}

return altura;}

}

String nombre;

System.out.println("La persona creada es "+miPersona.consulta_Nombre()+" de "+
miPersona.consulta_Edad()+" años y mide "+miPersona.consulta_Altura());
}}
A continuación crea un proyecto que declare un objeto de tipo Persona utilizando el constructor, para
posteriormente mostrar el contenido de los atributos por pantalla. Utiliza el operador this.
String nombre;
int edad;
Página 13 de 39
float altura;
public Persona(String nombre, int edad, float altura) {

this.nombre = nombre;
this.edad = edad;
}
return nombre;
nombre = nom;

return edad;
}

this.edad = edad;
}

return altura;
}

}

String nombre;
Persona miPersona = new Persona("Cristina",12,1.23f);

System.out.println("La persona creada es "+miPersona.consulta_Nombre()+" de "+
miPersona.consulta_Edad()+" años y mide "+miPersona.consulta_Altura());
}}
Construye una clase Complejo con dos atributos:
real: parte real del número complejo

imag: parte imaginaria del número complejo
Puedes consultar la estructura de una clase en el apartado correspondiente de la unidad, o bien partir de la definición de la clase Persona del apartado anterior. A
continuación crea los siguientes métodos dentro de la clase:
public Complejo(): Constructor que inicializa los atributos a cero.
public Complejo(double real, double imag): Constructor que inicializa los atributos a los valores indicados por los parámetros.
public double consulta_Real(): Devuelve la parte real del objeto.
public double consulta_Imag(): Devuelve la parte imaginaria del objeto.
public void cambia_Real(double real): Asigna a la parte real del objeto el valor indicado en el parámetro real.
public void cambia_Imag(double imag): Asigna a la parte imaginaria del objeto el valor indicado en el parámetro imag.
public String toString(): Convierte a String el número complejo, mediante la concatenación de sus atributos y devuelve como resultado la cadena de texto 3 + 4i, si 3
es la parte real y 4 la parte imaginaria.
public void sumar(Complejo b): Suma la parte real con la parte real del número complejo b y la parte imaginaria con la parte imaginaria del número complejo b.
Crea un proyecto que contenga la clase Complejo en un paquete llamado numeros y pruebe todos sus métodos.
/*
*/
package numeros;
Página 14 de 39
public class Complejo {
double real;
double imag;
public Complejo() {
real=0;
imag=0;
}
public Complejo(double real, double imag) {

this.real = real;
this.imag = imag;
}
public double consulta_Real() {

return real;
}
public double consulta_Imag() {

return imag;
}
public void cambia_Real(double real) {

this.real = real;
}
public void cambia_Imag(double imag) {

this.imag = imag;
}
@Override
public String toString() {
return "Complejo{ "+real + "+"+ imag + "i}";
}
public void sumar(Complejo b) {

double sumaReal, sumaImag;
sumaReal = real + b.consulta_Real();
sumaImag = imag + b.consulta_Imag();
System.out.println("La suma es el complejo " + sumaReal + " + " + sumaImag + "i");

Ejercicios del 1 al 4: 1,5 puntos cada uno.
Ejercicio 5: 4 puntos.
Total: 10 puntos.
Ordenador personal.
Sistema operativo Windows o Linux.
JDK y JRE de Java.
NetBeans IDE 6.9.1 o superior.
Consejos y recomendaciones.
Para una mejor organización de la tarea, crea una carpeta para cada ejercicio llamada EjercicioXX, donde la XX es el número del ejercicio. Sitúa dentro de cada
carpeta los ficheros de cada proyecto y cuando todos los ejercicios estén completos comprime esas carpetas en un sólo archivo para subirlo a la plataforma.
Una vez realizada la tarea elaborarás un único documento donde figuren las respuestas correspondientes. El envío se realizará a través de la plataforma de la forma
establecida para ello, y el archivo se nombrará siguiendo las siguientes pautas:
Asegúrate que el nombre no contenga la letra ñ, tildes ni caracteres especiales extraños. Así por ejemplo la alumna Begoña Sánchez Mañas para la tercera unidad
del MP de PROG, debería nombrar esta tarea como...
Página 15 de 39
Grupos separados: 34007007-CAMINO DE L
Sumario de calificaciones
package Tema03_Ejer01;
/**
*
* @author CarHerEst
* @date 11-nov-2018
*/
String nombre;
int edad;
float altura;
return nombre;
}

nombre=nom;
}
/**
*
* @author CarHerEst
* @date 11-nov-2018
*/
public class UsoPersona {

// TODO code application logic here
Scanner scn=new Scanner(System.in);
Persona miPersona=new Persona();
System.out.println("Introduce un nombre");
String nombre=scn.nextLine();
miPersona.cambia_Nombre(nombre);
System.out.println("El nombre de la persona es: " + miPersona.consulta_Nombre());
/**
*
* @author CarHerEst
* @date 15-nov-2018
*/
String nombre;
int edad;
float altura;
//Metodos getters para la consulta de las propiedades de la clase

return nombre;
}
Página 16 de 39
int getEdad(){
return edad;
}
float getAltura(){
return altura;
}
//Metodos setters para la modificacion de las propiedades de la clase

nombre=nom;
}
void setEdad(int años){

edad=años;
}
void setAltura(float alto){

altura=alto;
}
/**
*
* @author CarHerEst
* @date 15-nov-2018
*/

Scanner scn=new Scanner(System.in);
Persona miPersona=new Persona();
System.out.println("Introduce un nombre");
String nombre=scn.nextLine();
System.out.println("Introduce una edad");

int año=scn.nextInt();
System.out.println("Introduce una altura");

float alto=scn.nextFloat();
miPersona.cambia_Nombre(nombre);
miPersona.setEdad(año);
miPersona.setAltura(alto);
System.out.println("El nombre de la persona es " + miPersona.consulta_Nombre() + " , su edad

es " + miPersona.getEdad()
+ " años y su altura " + miPersona.getAltura() + (" metros"));
Página 17 de 39
/**
*
* @author CarHerEst
* @date 15-nov-2018
*/
String nombre;
int edad;
float altura;
//Metodo constructor de clase con valores asignados a los atributos.

public Persona(){
nombre="Luisa Perez";
edad=22;
altura=1.70f;
}
// Metodos getters para la consulta de las propiedades de la clase.

return nombre;
}
int getEdad(){
return edad;
}
float getAltura(){
return altura;
}
//Metodos setters para la modificacion de las propiedades de la clase.

nombre=nom;
}

edad=años;
}

altura=alto;
}
/**
*
* @author CarHerEst
* @date 15-nov-2018
*/

Persona miPersona=new Persona(); //Creacion de un objeto de la clase Persona.
System.out.println("Los atributos de la clase persona son:"); //Impresion por pantalla

de los valores de los atributos.
System.out.println("\nNombre: " + miPersona.consulta_Nombre());
System.out.println("Edad: " + miPersona.getEdad());
System.out.println("Altura: " + miPersona.getAltura());
Página 18 de 39
}
/**
*
* @author CarHerEst
* @date 15-nov-2018
*/
String nombre;
int edad;
float altura;
//Metodo constructor de clase con atributos.

public Persona(String nombre, int edad, float altura){
this.nombre=nombre;
this.edad=edad;
this.altura=altura;
}
// Metodos getters para la consulta de las propiedades de la clase.

return nombre;
}
int getEdad(){
return edad;
}
float getAltura(){
return altura;
}
//Metodos setters para la modificacion de las propiedades de la clase.

nombre=nom;
}

edad=años;
}

altura=alto;
}
/**
*
* @author CarHerEst
* @date 15-nov-2018
*/
Página 19 de 39
Scanner entrada=new Scanner(System.in); //Crea un objeto de la clase Scanner para

introducir datos por teclado,
System.out.println("Introduce un nombre"); //Solicita los datos y los almacena en variables

String nombre=entrada.nextLine();
System.out.println("Introduce edad");
int edad=entrada.nextInt();
System.out.println("Introduce altura");
float altura=entrada.nextFloat();
Persona miPersona=new Persona(nombre,edad,altura); //Crea una instancia de la clase

persona usando el constructor
System.out.println("Los atributos de la clase "+ Persona.class.getSimpleName() + " son:

"); // Muestra por pantalla los valores del objeto creado
System.out.println("\nNombre: " + miPersona.consulta_Nombre());
System.out.println("Edad: " + miPersona.getEdad());
System.out.println("Altura: " + miPersona.getAltura());
package Numeros;
/**
*
* @author CarHerEst
* @date 15-nov-2018
*/
public class Complejo {
//Atributos de la clase
double real;
double imag;
public Complejo(){ //Constructor que inicia los atributos a cero

}
public Complejo(double real, double imag){ //Constructor que inicia los atributos con los
valores de los parametros.
this.real=real;
this.imag=imag;
}
/*
Metodos GETTER
*/
public double cosultaReal(){ // Devuelve la parte real del objeto.
return real;
}
public double consultaImaginaria(){ // Devuelve la parte imaginaria del objeto.
return imag;
}
public String toString(){
return real + " + " + imag + "i";
}
/*
Metodos SETTER
*/
public void cambiaReal(double real){ // Asigna a la parte real del objeto el valor indicado
en el parámetro real
this.real=real;
}
public void cambiaImaginaria(double imag){ // Asigna a la parte real del objeto el valor
indicado en el parámetro imag
this.imag=imag;
Página 20 de 39
}
public void sumar (Complejo b){ // Operacion suma de numero complejo. Suma la
parte real con la parte real del número complejo "b" y la parte imaginaria con la parte imaginaria del
número complejo "b".
real = real + b.real;
imag = imag + b.imag;
}
}
package Numeros;
/**
*
* @author CarHerEst
* @date 15-nov-2018
*/
public class Tema03_Ejer05 {

double aux1 = 2.3 , aux2 = 1.8; // Declaracion e iniciacion de dos variables de tipo double.
Complejo a = new Complejo(); // Creacion de un objeto de la clase complejo utilizando
uno de sus constructores, en este caso el que inicia sus atributos a cero.
Complejo b = new Complejo(4.5,2.0); // Creacion de un objeto de la clase complejo utilizando
uno de sus constructores, en este caso el que inicia sus atributos con los valores 4.5 y 2.0 para la
parte real e imaginaria respectivamente.
Scanner teclado = new Scanner(System.in); //Creacion de un objeto de la clase Scanner para
la entrada de datos por pantalla.
System.out.println("Intruduce la parte real de un numero complejo"); // Peticion de

datos por pantalla.
a.real = teclado.nextDouble(); // Asignacion del dato introducido a la parte real del
numero complejo a.
System.out.println("Intruduce la parte imaginaria de un numero complejo"); // Peticion de
datos por pantalla.
a.imag = teclado.nextDouble(); // Asignacion del dato introducido a la parte imaginaria
del numero complejo a.
System.out.println("El numero complejo \"a\" introducido es: " + a.toString()); // Mostrar
en pantalla el numero complejo introducido.
System.out.print("El numero complejo \"b\" es: " + b.toString()); // Mostrar en pantalla el

numero complejo introducido.
a.sumar(b); // Suma el valor de los
complejos a y b y asigna el resultado al complejo a.
System.out.println(" y la suma del numero complejo \"a\" y el \"b\" es: " + a.toString()); //
Muestra resultados por pantalla.
a.cambiaReal(aux1); // Cambiamos el valor de la parte real del nuemro complejo a

por el de la variable aux2
a.cambiaImaginaria(aux2); // Cambiamos el valor de la parte imaginaria del numero
complejo a por el de la variable aux1.
System.out.println("\nEl valor del complejo \"a\" despues de un cambio de valores es:" +
a.toString());
}
Página 21 de 39
Tarea para PROG04.
Enunciado.
A continuación, se enumeran varios supuestos que el alumnado debe solventar a través de la realización un programa por cada uno de los supuestos propuestos.
Supuesto 1: Realiza un programa que lea un número entero e indique si es par.
• Supuesto 2: Realiza un programa que lea un mes en formato numérico y un año e indique el número de días de ese mes. Para realizar este ejercicio hay
que tener en cuenta que un año es bisiesto si es divisible por cuatro, excepto cuando es divisible por 100, a no ser que sea divisible por 400.
• Supuesto 3: Escribe un programa que lea un número y lo descomponga en factores primos.
• Supuesto 4: Escribe un programa que solicite a un usuario su nombre y edad. Debe mostrarse cuantos años tendrá dentro de una década y clasificarle
según su edad en A[0-25], B[26-50], C[51-...].
Lo que debes entregar: En un único archivo, el código fuente de cada uno de los supuestos debidamente identificados.
Cómo lo debes entregar: En formato pdf.
• Supuesto 1: 1 punto.
• Supuesto 2: 3 puntos.
Total: 10 puntos
• Ordenador personal con un procesador de textos que pueda generar archivos pdf.
• Entorno de desarrollo NetBeans.
• Conexión a Internet.
• Navegador Web.
• Programa de impresión en formato pdf.
El orden de realización de los supuestos no importa.
Para el supuesto 2 y 3 debes documentarte adecuadamente para conocer en mayor detalle qué es lo que te solicita el enunciado.
El código fuente de cada uno de los supuestos debe estar debidamente identificado y separado de los demás.
Se recomienda que antes de enviar el código fuente hayas realizado la compilación y ejecución de los programas, de este modo evitarás posibles fallos.
Utiliza comentarios a lo largo de tu código.
Utiliza tabulaciones y estructura tu código para que sea lo más legible posible.
Asegúrate que el nombre no contenga la letra ñ, tildes ni caracteres especiales extraños. Así por ejemplo la alumna Begoña Sánchez Mañas para la cuarta unidad del
MP de PROG, debería nombrar esta tarea como...
Tarea para PROG05.

Tarea para PROG05.
Enunciado.
A lo largo de esta unidad has ido aprendiendo a crear tus propias clases así como sus distintos miembros (atributos y métodos). Has experimentando con la
encapsulación y accesibilidad (modificadores de acceso a miembros), has creado miembros estáticos (de clase) y de instancia (de objeto), has escrito constructores
para tus clases, has sobrecargado métodos y los has utilizado en pequeñas aplicaciones. También has tenido tu primer encuentro el concepto de herencia, que ya
desarrollarás en unidades más avanzadas junto con otros conceptos avanzados de la Programación Orientada a Objetos.
Una vez finalizada la unidad se puede decir que tienes un dominio adecuado del lenguaje Java como para desarrollar tus propias clases y utilizarlas en una
aplicación final que sea capaz de manipular un conjunto de datos simple. Dada esa premisa, esta tarea tendrá como objetivo escribir una pequeña aplicación en Java
empleando algunos de los elementos que has aprendido a utilizar.
Se trata de desarrollar una aplicación Java en consola que permita gestionar una cuenta bancaria. Mediante un menú se podrán realizar determinas operaciones:
1. Ver el número de cuenta completo (CCC - Código Cuenta Cliente).
2. Ver el titular de la cuenta.
3. Ver el código de la entidad.
4. Ver el código de la oficina.
5. Ver el número de la cuenta (solamente el número de cuenta, sin entidad, oficina ni dígitos de control).
6. Ver los dígitos de control de la cuenta.
7. Realizar un ingreso. Habrá que solicitar por teclado la cantidad que se desea ingresar.
8. Retirar efectivo. Habrá que solicitar por teclado la cantidad que se desea retirar.
9. Consultar saldo.
10. Salir de la aplicación.
Antes de que aparezca este menú, el programa tendrá que solicitar al usuario los siguientes datos:
• Nombre del titular de la cuenta (con un máximo de caracteres).
• Código cuenta cliente (CCC) de la cuenta completo (entidad-oficina-dígitos de control-cuenta).
El programa deberá asegurarse que el CCC es válido mediante la comprobación de:
• El formato (cuatro dígitos de entidad, cuatro dígitos de oficina, dos dígitos de control y diez dígitos de número de cuenta).
Página 22 de 39
• Los dígitos de control son válidos.
Además del programa principal de la aplicación (clase con una función main), habrá que escribir una clase CuentaBancaria que proporcione todas las herramientas
necesarias para trabajar con este tipo de información:
• Constructor (o constructores) adecuados.
• Almacenamiento del nombre del titular (atributos).
• Almacenamiento del código de cuenta (atributos).
• Almacenamiento del saldo actual (atributos).
• Gestión de ingresos y depósitos (métodos de interfaz pública).
• Obtención del saldo (métodos de interfaz pública).
• Obtención de información sobre la cuenta: número de la cuenta, entidad, oficina, titular, etc. (métodos de interfaz pública).
• Aquellas herramientas auxiliares necesarias para poder trabajar cómodamente con el objeto. Algunas de esas herramientas podrán ser públicos y otras
quizá no. Algunas podrán ser específicas de clase y otras podrán ser de objeto (métodos de objeto privados, métodos estáticos públicos, etc.).
Para trabajar con el número de cuenta debes utilizar el modelo de Código Cuenta Cliente (CCC), que está formado por cuatro campos: entidad - sucursal - dígito de
control - número de cuenta. La idea es que puedas introducir el código de cuenta completo y que la clase disponga de un mecanismo para comprobar que ese código
es válido. Si el código no es válido, se debería generar una excepción (y por supuesto no almacenar ese código de cuenta). Para ello podrías tener, por ejemplo, un
método estático que permita validar códigos de cuenta.
En general, deberías incluir excepciones para controlar aquellos casos en los que el uso de un método no sea posible (intentar sacar más dinero del que hay en el
saldo, intentar introducir un titular con más caracteres de los permitidos, intentar ingresar o retirar una cantidad negativa, etc.).
El código fuente Java de esta clase debería incluir comentarios en cada atributo (o en cada conjunto de atributos) y método (o en cada conjunto de métodos del
mismo tipo) indicando su utilidad. El programa principal también debería incluir algunos comentarios explicativos sobre su funcionamiento y la utilización de objetos
de la clase CuentaBancaria.
Además del programa deberás escribir también un informe con todas las consideraciones oportunas que se necesiten para entender cómo has realizado la tarea.
El proyecto deberá contener al menos dos archivos fuente Java:
• Programa principal (clase con método main: AplicacionCuentaBancaria.java).
• La clase CuentaBancaria (CuentaBancaria.java).
El documento que contendrá el informe lo elaborarás con un procesador de texto. Debe ser de tipo ".doc" (Microsoft Word) o de tipo ".odt" (OpenOffice.org). Debe
tener tamaño de página A4, estilo de letra Times New Roman, tamaño 12 e interlineado normal.
Para poder empezar a aplicar estos criterios es necesario que la aplicación compile y se ejecute correctamente en un emulador. En caso contrario la puntuación será
directamente de 0,00.
Criterios de puntuación.
La clase CuentaBancaria dispone de todos los atributos necesarios. 1,00
La clase CuentaBancaria dispone de al menos un constructor y funciona correctamente. 1,00
La clase CuentaBancaria dispone de los métodos públicos de interfaz necesarios y funcionan correctamente. 4,00
La clase CuentaBancaria es capaz de validar un CCC. 2,00
Los métodos de la clase CuentaBancaria son capaces de lanzar excepciones si se produce alguna situación anómala. 1,00
La clase CuentaBancaria dispone de métodos estáticos públicos para proporcionar herramientas de gestión útiles al código de fuera de la clase. 1,00
No se han incluido comentarios en la clase CuentaBancaria tal y como se ha pedido en el enunciado. -1,00
No se han incluido comentarios apropiados en el programa principal describiendo el funcionamiento de éste. -1,00
No se ha entregado el informe explicativo o se trata de un informe explicativo insuficiente. -2,00
El programa principal no es capaz de crear un objeto de la clase CuentaBancaria. -5,00
Alguna de las opciones de menú pedidas en el enunciado (menú del programa principal) no funciona correctamente. -1,00 por cada opción
Total 10,00
Dado que algunos criterios de puntuación son negativos, podría suceder que el balance final fuera negativo. En tal caso la puntuación final será simplemente de 0,00.
• Ordenador personal.
• JDK y JRE de Java SE.
• Entorno de desarrollo NetBeans con las funcionalidades necesarias para desarrollar y emular midlets.
Para realizar la aplicación te realizamos la siguiente serie de recomendaciones:
• Básate en los diferentes ejemplos que has tenido que probar durante el estudio de la unidad. Algunos de ellos te podrán servir de mucha ayuda, así que
aprovéchalos.
• El ejercicio resuelto de la clase DNI, en el cual se hacen comprobaciones de entrada, puede servirte de base para la comprobación de la validez de un
CCC.
• Puedes obtener información acerca del funcionamiento de la CCC y de cómo calcular los dígitos de control del siguiente artículo de Wikipedia:
Wikipedia: Código Cuenta Cliente.

• Puedes generar cuentas bancarias válidas (o comprobarlas) para hacer pruebas en tu programa desde el siguiente enlace:
Generador/validador de cuentas bancarias.
Una vez que tengas terminados el programa (carpeta de proyecto Netbeans, incluyendo todos los archivos fuente y todos los recursos) y el documento explicativo,
comprime ambos en un único archivo comprimido. El envío se realizará a través de la plataforma de la forma establecida para ello, y el archivo se nombrará
siguiendo las siguientes pautas:
Asegúrate que el nombre no contenga la letra ñ, tildes ni caracteres especiales extraños. Así por ejemplo la alumna Begoña Sánchez Mañas para la quinta unidad del
Página 23 de 39
package aplicacioncuentabancaria;import java.io.*;
//---------------------------------------------------------------
// CLASE AplicacionCuentaBancaria
//---------------------------------------------------------------
// Ejemplo de uso de la clase CuentaBancaria.
//---------------------------------------------------------------
public class AplicacionCuentaBancaria {
//---------------------------------------------------------------
// MÉTODO main: PROGRAMA PRINCIPAL
//---------------------------------------------------------------
public static void main(String[] args) throws Exception {
// PRESENTACIÓN
// ------------
System.out.printf ("PRUEBA DE USO DE LA CUENTA BANCARIA. \n");
System.out.printf ("------------------------------------\n\n");
// ENTRADA DE DATOS
// ----------------
// Titular
String titular= null;
boolean titularValido= false;
while (!titularValido) {
System.out.println("Nombre del titular de la cuenta: (máximo 20
caracteres)");
try {
titular= lecturaTeclado();
}
catch (Exception e) {
System.err.println(e.getMessage());
}
if (titular.length()>=CuentaBancaria.MIN_LOMG_TITULAR &&
titular.length()<=CuentaBancaria.MAX_LOMG_TITULAR) {
titularValido= true;
}
}
// Número de cuenta
String ccc= null;
boolean cuentaValida= false;
while (!cuentaValida) {
System.out.println("Número de cuenta: (debe ser una cuenta válida)");
ccc= lecturaTeclado ();
cuentaValida= CuentaBancaria.validarCuenta(ccc);
if (!cuentaValida)
System.err.println ("Cuenta no válida.");
// Creación de la cuenta
CuentaBancaria cuenta= null;
boolean fin = false;
try {
cuenta= cuenta= new CuentaBancaria (titular, ccc);
cuentaValida= true;
System.out.println("Cuenta creada");
Página 24 de 39
}
//System.out.println (e.getMessage());
System.err.println ("Cuenta no válida.");
fin= true;
}
// MENÚ, PROCESAMIENTO Y SALIDA DE RESULTADOS

// ------------------------------------
while (!fin) {
System.out.println("Seleccionar una opción:");
System.out.println("[1] Ver número de cuenta completo (CCC).");

System.out.println("[2] Ver titular de la cuenta.");
System.out.println("[3] Ver código de entidad de la cuenta.");
System.out.println("[4] Ver código de oficina de la cuenta.");
System.out.println("[5] Ver número de la cuenta.");
System.out.println("[6] Ver dígitos de control de la cuenta.");
System.out.println("[7] Realizar un ingreso.");
System.out.println("[8] Retirar efectivo.");
System.out.println("[9] Consultar saldo.");
System.out.println("[0] Salir.");
System.out.println("Escriba la selección: ");

int selec = 0 ;
selec = leeOpcion() ;
// Según la selección que se haya realizado se utilizarán unos

// u otros métodos del objeto de la clase CuentaBancaria
String stringCantidad;
double cantidad;
switch (selec){
case 1:
System.out.printf ("Número de cuenta completo (CCC): %s\n",
cuenta.obtenerCCCGuiones());
break;
case 2:
System.out.printf ("Titular de cuenta: %s\n",
cuenta.obtenerTitular());
break;
case 3:
System.out.printf ("Código de entidad: %s\n",
cuenta.obtenerEntidad());
break;
case 4:
System.out.printf ("Código de oficina: %s\n",
cuenta.obtenerOficina());
break;
case 5:
System.out.printf ("Número de cuenta: %s\n",
cuenta.obtenerCuenta());
break;
case 6:
System.out.printf ("Dígitos de control: %s\n",
cuenta.obtenerDC());
break;
case 7:
System.out.printf ("Realización de ingreso: \n");
System.out.printf ("Cantidad que desea ingresar: ");
stringCantidad= lecturaTeclado();
Página 25 de 39
cantidad= Double.parseDouble(stringCantidad);
try {
cuenta.ingresar(cantidad);
System.out.printf ("Cantidad de %10.2f euros ingresada.\
n", cantidad);
}
System.err.println (e.getMessage());
}
break;
case 8:
System.out.printf ("Retirada de efectivo:\n");
System.out.printf ("Cantidad que desea retirar: ");
stringCantidad= lecturaTeclado();
cantidad= Double.parseDouble(stringCantidad);
try {
cuenta.retirar(cantidad);
System.out.printf ("Cantidad de %10.2f euros retirada.\
n", cantidad);
}
System.err.println (e.getMessage());
}
break;
case 9:
System.out.printf ("Saldo actual: %10.2f\n",
cuenta.obtenerSaldo());
break;
case 0:
System.out.printf ("Fin de la aplicación...\n");
fin = true;
break ;
default:
System.out.println("Selecciona una opción válida.");
}
System.out.println ("Pulsa alguna tecla para continuar.\n");

pulsacionTecla();
//---------------------------------------------------------------
// MÉTODO lecturaTeclado: Captura de una cadena de teclado
//---------------------------------------------------------------
private static String lecturaTeclado () throws Exception {
try {
InputStreamReader inputStreamReader = new
InputStreamReader(System.in);
BufferedReader reader = new BufferedReader(inputStreamReader);
String line = reader.readLine();
return line;
}
throw e;
//---------------------------------------------------------------
Página 26 de 39
// MÉTODO pulsacionTecla: Captura de un tecla de teclado
//---------------------------------------------------------------
private static int pulsacionTecla () throws Exception {
try {
InputStreamReader inputStreamReader = new
InputStreamReader(System.in);
BufferedReader reader = new BufferedReader(inputStreamReader);
int c = reader.read();
return c;
}
throw e;
//---------------------------------------------------------------
// MÉTODO pulsacionTecla: Captura de un tecla numérica de teclado
// (opción del menú)
//---------------------------------------------------------------
private static int leeOpcion() {
int nOpcion = 10 ;
try {
// Leer desde teclado la opción

String cOpcion = lecturaTeclado();
nOpcion = Integer.parseInt(cOpcion) ;
} catch(NumberFormatException e) {
System.err.println("NO ES UN NÚMERO VÁLIDO: Vuelve a
intentarlo.");}
catch(IOException ex) {
intentarlo.");}
catch(Exception exc) {
intentarlo.");}
return (nOpcion) ;
}
package aplicacioncuentabancaria;
Página 27 de 39
//---------------------------------------------------------------
// CLASE CuentaBancaria
//---------------------------------------------------------------
public class CuentaBancaria {
//---------------------------------------------------------------
// ATRIBUTOS
//---------------------------------------------------------------
// Atributos privados que almacenan el "estado" del objeto
private double saldo;
private String titular;
private String entidad;
private String oficina;
private String cuenta;
// Atributos estátticos públicos que almacenan constantes

// relacionadas con características específicas de la clase
public static final int MIN_LOMG_TITULAR= 1;
public static final int MAX_LOMG_TITULAR= 20;
//---------------------------------------------------------------
// MÉTODOS PRIVADOS
//---------------------------------------------------------------
// Métodos privados que proporcionan funcionalidad auxiliar.
// Método establecerCuenta
private void establecerCuenta (String ccc) {
ccc= CuentaBancaria.normalizarCCC (ccc);
if (CuentaBancaria.validarCuenta(ccc)) {
this.entidad= ccc.substring(0,4);
this.oficina= ccc.substring(4,8);
this.cuenta= ccc.substring(10, 20);
}
}
// Método establecerTitular
private void establecerTitular (String titular) throws Exception {
if (titular!= null) {
if (titular.length() <= 20) {
this.titular= titular;
}
else {
throw new Exception ("Longitud excesiva.");
}
}
else {
throw new Exception ("Cadena vacía.");
}
}
//---------------------------------------------------------------
// CONSTRUCTORES
//---------------------------------------------------------------
// Constructores
public CuentaBancaria (String titular, String ccc) throws Exception {
this.establecerTitular(titular);
this.establecerCuenta(ccc);
}
Página 28 de 39
//---------------------------------------------------------------
// MÉTODOS ESTÁTICOS (DE CLASE) PÚBLICOS
//---------------------------------------------------------------
// utilidades que pueden ser usadas desde fuera
// Método calcular1DC
// Calcula un dígito de control (DC) para un código de 10 dígitos
public static String calcular1DC (String codigo) throws Exception {
String dc;
// Comprobación de que los parámetros son válidos

if (codigo == null) {
throw new Exception ("Elemento no válido.");
}

if (codigo.length() != 10 ) {
throw new Exception ("Elemento no válido.");
}
// Algoritmo de cálculo de 1 dígito de control para un código de 10

cifras
int n;
int suma=0;
for (n=0; n<10; n++) {
int factor, cifra;
factor= ((int)(Math.pow(2, n))) % 11;
cifra= Integer.parseInt(codigo.substring(n, n+1));
suma += cifra * factor;
}
suma= suma % 11;
suma= 11 - suma;
if (suma == 10)
suma= 1;
else if (suma == 11)
suma= 0;
// Se devuelve el DC calculado en forma de String

dc= String.valueOf(suma);
return dc;
}
// Método calcularDigitosControl
// Calcula los dígitos de control de una combinación entidad-oficina-cuenta
(18 dígitos)
public static String calcularDigitosControl (String entidad, String oficina,
String cuenta) throws Exception {
String dc;
String dc1, dc2;

if (entidad == null || oficina == null || cuenta == null) {
throw new Exception ("Elementos no válidos.");
}
if (entidad.length() != 4 || oficina.length() != 4 || cuenta.length() !=

10 ) {
throw new Exception ("Elementos no válidos.");
}
Página 29 de 39
// Una vez que los parámetros cumplen las reglas, calculamos los DC
// Cálculo del primer DC

String entidadoficina= "00" + entidad + oficina;
dc1= CuentaBancaria.calcular1DC(entidadoficina);
// Cálculo del segundo DC

dc2= CuentaBancaria.calcular1DC(cuenta);
// Unión de los dos DC

dc= dc1 + dc2;
return dc;
}
// Método ValidarCuenta
// Valida si un código cuenta cliente (entidad-oficina-dc-cuenta) es válido
o no
public static boolean validarCuenta (String ccc) {
boolean valido= true;
String entidad, oficina, dcExtraido, cuenta, dcCalculado="";
if (ccc == null) {
valido= false;
return valido;
}
ccc= CuentaBancaria.normalizarCCC(ccc);
if (ccc.length() == 20 && valido) {
entidad= ccc.substring(0,4);
oficina= ccc.substring(4,8);
dcExtraido= ccc.substring(8, 10);
cuenta= ccc.substring(10, 20);
try {
dcCalculado= CuentaBancaria.calcularDigitosControl(entidad,
oficina, cuenta);
}
valido= false;
}
if (valido) {
if (dcExtraido.compareTo(dcCalculado) != 0) {
valido= false;
}
}
}
else
valido= false;
return valido;
}
// Método normalizarCCC
// Elimina los posibles guiones de un CCC: entidad-oficina-dc-cuenta
public static String normalizarCCC (String ccc) {
String cccNormalizada;
if (ccc.length() == 23) {
cccNormalizada= ccc.substring(0,4) + ccc.substring(5,9) +
ccc.substring(10,12) + ccc.substring(13, 23);
}
else {
cccNormalizada= ccc;
}
Página 30 de 39
return cccNormalizada;
}
//---------------------------------------------------------------
// MÉTODOS DE INTERFAZ
//---------------------------------------------------------------
// Métodos públicos para manipular los objetos de esta clase
// Método obtenerSaldo
// Para consultar el saldo actual de la cuenta
public double obtenerSaldo () {
return this.saldo;
}
// Método obtenerTitular
public String obtenerTitular () {
return this.titular;
}
// Método obtenerEntidad
public String obtenerEntidad () {
return this.entidad;
}
// Método obtenerOficina
public String obtenerOficina () {
return this.oficina;
}
// Método obtenerCuenta
public String obtenerCuenta () {
return this.cuenta;
}
// Método obtenerDC
public String obtenerDC () throws Exception {
try {
return calcularDigitosControl (this.entidad, this.oficina,
this.cuenta);
}
throw new Exception ("Cuenta inválida.");
}
}
// Método obtenerCCC
public String obtenerCCC () throws Exception {
String numcuenta="";
try {
numcuenta= this.entidad + this.oficina +
CuentaBancaria.calcularDigitosControl(this.entidad, this.oficina, this. cuenta)
+ this.cuenta;
}
}
return numcuenta;
}
// Método obtenerCCCGuiones
// Obtiene el CCC completo de una cuenta en formato "con guiones": entidad-
oficina-dc-cuenta
public String obtenerCCCGuiones () throws Exception {
Página 31 de 39
String numcuenta="";
try {
numcuenta= this.entidad + "-" + this.oficina + "-" +
CuentaBancaria.calcularDigitosControl(this.entidad,
this.oficina, this. cuenta) + "-" + this.cuenta;
}
}
return numcuenta;
}
// Método ingresar
// Para ingresar una cantidad en la cuenta
public void ingresar (double cantidad) throws Exception {
if (cantidad >0) {
saldo += cantidad;
}
else {
throw new Exception ("Cantidad no válida.");
}
}
// Método retirar
// Para retirar una cantidad de la cuenta
public void retirar (double cantidad) throws Exception {
if (cantidad<0) {
throw new Exception ("Cantidad no válida.");
}
if (saldo>= cantidad) { // Si el saldo permite retirar esa cantidad
saldo -= cantidad; // Se retira esa cantidad
}
else {
throw new Exception ("Saldo insuficiente.");
}
}
Tarea para PROG06.

Tarea para PROG06.
Enunciado.
Se trata de hacer una aplicación en Java que gestione los clientes de una empresa. Esos datos, se almacenarán en un fichero serializado, denominado clientes.dat.
Los datos que se almacenarán sobre cada cliente son:
• NIF.
• Nombre.
• Teléfono.
• Dirección.
• Deuda.
Mediante un menú se podrán realizar determinadas operaciones:
• Añadir cliente. Esta opción pedirá los datos del cliente y añadirá el registro correspondiente en el fichero.
• Listar clientes. Recorrerá el fichero mostrando los clientes almacenados en el mismo.
• Buscar clientes. Pedirá al usuario el nif del cliente a buscar, y comprobará si existe en el fichero.
Página 32 de 39
• Borrar cliente. Pedirá al usuario el nif del cliente a borrar, y si existe, lo borrará del fichero.
• Borrar fichero de clientes completamente. Elimina del disco el fichero clientes.dat
• Salir de la aplicación.
Elabora el programa y un documento con un procesador de texto. El documento debe ser de tipo ".doc" (Microsoft Word) o de tipo ".odt" (OpenOffice.org). Debe tener
tamaño de página A4, estilo de letra Times New Roman, tamaño 12 e interlineado normal.
En el documento escribirás un informe sobre todas las consideraciones oportunas que se necesiten para entender cómo has realizado la tarea.
Asegúrate que el nombre no contenga la letra ñ, tildes ni caracteres especiales extraños. Así por ejemplo la alumna Begoña Sánchez Mañas para la sexta unidad del
Tarea para PROG07.

Tarea para PROG07.
Enunciado.
Con los conocimientos adquiridos durante la unidad vas a implementar un editor de textos de lo más simple, del estilo del bloc de notas de Windows. Utilizando
controles Java Swing.
En concreto las lista de requisitos mínimos de la aplicación es:
• La aplicación debe poder guardar a disco y recuperar desde disco el texto editado en el editor.
• Se tendrán al menos las opciones en el menú de Fichero: Nuevo, Abrir, Guardar, Guardar como y Salir.
• En el menú Editar se tendrá al menos las opciones Cortar, Copiar, Pegar.
• El juego desplegado cumple, como mínimo con las reglas expuestas y funciona: 5 puntos.
• Originalidad de la solución: de 0 a 2 puntos.
• Mejoras no incluidas en las reglas mínimas pero que mejoran los requisítos mínimos: de 0 a 3 puntos.
Solo son necesarios los contenidos de la unidad y los enlaces que en ella se proponen.
Aunque no es necesario, para hacer más vistosa la tarea puedes usar controles que no se han visto en los contenidos, pero que son fáciles de usar como:
Control JFileChooser
Más controles que pueden ser útiles.
Controles Swing (1.25 MB)
Una vez que tengas terminados el programa y el documento explicativo, comprime ambas cosas en un único fichero. El envío se realizará a través de la plataforma
de la forma establecida para ello, y el archivo se nombrará siguiendo las siguientes pautas:
Página 33 de 39
apellido1_apellido2_nombre_SIGxx_Tarea.zip
Asegúrate que el nombre no contenga la letra ñ, tildes ni caracteres especiales extraños. Así por ejemplo la alumna Begoña Sánchez Mañas para la septima unidad
sanchez_manas_begona_PROG07_Tarea.zip
Tarea para PROG08.

Tarea para PROG08.
Enunciado.
Imagina que te proporcionan, en el siguiente formato, los datos de un cliente, con todos sus teléfonos y todos sus direcciones de correo electrónico:
DNI, "nombre", "apellidos", teléfono 1, teléfono 2, email 1, teléfono 3, email 2,...
En una misma línea se encuentran, separados por comas, todos los datos del cliente: DNI (o NIE), nombre, apellidos, teléfonos y direcciones de correo electrónico.
Fijate que los teléfonos y los correos electrónicos pueden aparecer desordenados, y que pueden ser más de uno. La idea es meter dichos datos en un documento
XML que contenga los datos de contacto del cliente. No es necesario leer los datos de un archivo, basta con que se capturen del teclado. Además, el documento XML
solo contendrá los datos de un cliente, por lo que no debes preocuparte de procesar múltiples líneas (solo una).
A la hora de procesar los datos tienes que tener en cuenta los siguientes aspectos:
• El DNI o NIE siempre aparecerá en primer lugar.
• El nombre siempre aparecerá en segundo lugar, entre comillas. Las comillas habrá que quitarlas, no pueden aparecer en el documento XML.
• Los apellidos siempre aparecerán en tercer lugar, entre comillas. Nuevamente, las comillas habrá que quitarlas.
• Los teléfonos y los correos electrónicos aparecerán desordenados y mezclados entre sí, pero en el XML resultante deben aparecer separados en dos
partes: teléfonos y correos electrónicos por separado.
• Los teléfonos pueden tener paréntesis para simbolizar el prefijo ("(91)2345678") o en el código del país. Estos paréntesis habrá que eliminarlos al
almacenarlo en el documento XML.
• Los teléfonos además pueden tener el símbolo "+" delante. Este hay que dejarlo, dado que simboliza que el número es un número internacional.
• Los teléfonos deben aparecer ordenados. Primero aparecerán ordenados de mayor a menor los números locales (sin símbolo "+" delante) y después los
internacionales, también ordenados de mayor a menor.
• Los correos electrónicos deben almacenarse en minúsculas, aunque en la entrada vayan en mayúsculas.
• La lista de teléfonos y de correos no debería tener duplicados (tomando mayúsculas y minúsculas como lo mismo). Ten en cuenta que los paréntesis
sobre un mismo número de teléfono no deben provocar la existencia de teléfonos diferentes en el XML.
• Es importante eliminar espacios sobrantes antes y después de cada trozo de texto extraído para procesarlo adecuadamente.
Las características del documento XML a generar son las siguientes:
• El elemento raíz se llamará "datos_cliente".
• El DNI o el NIE se almacenará en un elemento llamado "id".
• El nombre siempre se almacenará en un elemento llamado "nombre".
• Los apellidos siempre se almacenarán en un elemento llamado "apellidos".
• Los teléfonos se almacenarán todos en un elemento llamado "telefonos" (sin acento). Dentro de dicho elemento, habrá sub-elementos, llamados
"telefono" (sin acento), cada uno de los cuales contendrá un único teléfono. Los teléfonos deberán aparecer ordenados tal y como se comentó en el párrafo anterior.
• La etiqueta "telefonos" deberá tener un atributo llamado "total" que contendrá el número total de teléfonos de la lista.
• Los correos electrónicos se almacenarán en un elemento llamado "mails". Dentro de dicho elemento, habrá sub-elementos llamados "mail" destinados a
almacenar cada uno de los correos electrónicos del usuario.
Puedes usar los siguientes datos de prueba en tu aplicación (cada línea debería generar un documento XML):
X12345678F,"nombre","apellidos",+(82)12345678, 612345678,test@TEST.com,(91)23456789 ,prueba@prueba.com
12345678Z,"nombre","apellidos", prueba@prueba.com,(952)333333,test@test.com ,952333333,test@TEST.com
No olvides ser descriptivo o descriptiva en los errores. Si la línea proporcionada contiene errores, el programa no debería quedarse bloqueado, sino que debería
informar de que se ha producido un error, e intentar ser descriptivo en el error detectado.
La tarea tiene una puntuación total de 10 puntos repartidos de la siguiente forma:
• Si el programa es capaz de procesar los datos de entrada y almacenarlos en un documento XML, separando la información de la forma descrita en el
enunciado: 4,5 puntos.
• Si el programa además elimina caracteres sobrantes (espacios, comillas y paréntesis) y convierte las direcciones de correo a minúsculas: 0,5 puntos.
• Si el programa además elimina duplicados de teléfonos y correos electrónicos: 1 punto.
• Si el programa además ordena los teléfonos de la forma descrita en el enunciado: 2 puntos.
• Si el programa además muestra los errores detectados en la cadena de entrada con un alto nivel de detalle (indicando en que lugar estuvo el error
encontrado, así como duplicidades existentes): 2 puntos.
Se valorará positivamente que el resultado se guarde en un archivo XML de disco preguntando al usuario dónde almacenarlo, aunque no es obligatorio.
Un ordenador con NetBeans u otro entorno de desarrollo Java 6 o superior instalado.
Te recomendamos, que para llegar a realizar con éxito la tarea, sigas las siguientes indicaciones:
1. Estudia con detenimiento el ejemplo proporcionado en los casos prácticos de los contenidos. El ejemplo proporcionado es algo más complicado que lo
que tienes que realizar, con lo que te servirá de gran ayuda.
2. Divide la cadena de entrada usando como separador la coma a través de la función split.
3. Crea expresiones regulares para detectar cuando se trata del DNI o NIE (esta la puedes encontrar en los contenidos), también para el nombre o los
apellidos entre comillas (recuerda que el uso de los caracteres de escape), y también para detectar teléfonos y correos electrónicos. No busques expresiones
regulares complicadas, sino aquellas que de forma básica detecten de que se trata, en especial para el correo electrónico, cuya expresión regular puede tener varios
niveles de complejidad.
4. Es mejor empezar comprobando si el primer campo es el DNI o NIE, si el segundo y tercero son los nombres y apellidos, y después, mirar con que
expresión regular encajan el resto de los campos (si con teléfono o con correo electrónico).
5. Usa listas para disponer de una capacidad de crecimiento dinámico, es lo más adecuado para almacenar y ordenar la lista de teléfonos y correos
electrónicos.
Página 34 de 39
6. Usa la interfaz Comparator para crear un comparador adecuado. Una opción para comparar los teléfonos es realizar conversión a entero en determinadas
situaciones. En dicho caso, no uses el tipo Integer, es mejor usar el tipo Long, dado que los teléfonos pueden ser números mayores que lo que el tipo Integer soporta.
7. Para ahorrate trabajo, puedes poner los errores detectados como comentarios en el documento XML.
8. Encontrar un teléfono o un correo duplicado no debería detener la ejecución del programa, sino simplemente no insertarlo en el documento XML final. Si
encuentras un duplicado, es conveniente insertar un comentario en el documento XML con la incidencia ocurrida, te servirá para depurar tu código.
9. La solución ronda las 200 líneas de código, aunque se puede hacer en menos de forma elegante. Si tu código supera esa cantidad de líneas, antes de
estar completamente operativo, posiblemente te estés complicando en sobremanera. Puedes usar JOptionPane para ahorrar trabajo de entrada y salida de
información.
10. Usa la clase DOMUtil facilitada en los contenidos para que te sea más fácil manejar el archivo XML.
Clase DOMUtil
Asegúrate que el nombre no contenga la letra ñ, tildes ni caracteres especiales extraños. Así por ejemplo la alumna Begoña Sánchez Mañas para la octava unidad del
Programación
1. Página Principal
2. Mis cursos
3. Programación
4. Tema 9
5. Tarea para PROG09.
Permisos
Registros
Ver libro de calificaciones
Ver/Calificar todas las entregas
Descargar todas las entregas
Tarea para PROG09.
Tarea para PROG09.
Enunciado.
A lo largo de esta unidad has terminado de familiarizarte con el resto de conceptos relacionados con la Programación Orientada a Objetos que faltaban por ver de
una manera más formal y con ejemplos explícitos: composición; herencia; clases y métodos abstractos; sobrescritura de métodos; interfaces; polimorfismo; ligadura
dinámica, etc.
Has experimentando con todos estos conceptos y los has utilizado en pequeñas aplicaciones para comprobar su funcionamiento y su utilidad.
Una vez finalizada la unidad se puede decir que tienes ya un dominio adecuado del lenguaje Java como un lenguaje que permite aplicar todas las posibilidades de la
Programación Orientada a Objetos. Dado ese supuesto, esta tarea tendrá como objetivo escribir una pequeña aplicación en Java empleando algunas de las
construcciones que has aprendido a utilizar.
Se trata de desarrollar una aplicación Java que permita gestionar varios tipos de cuentas bancarias. Mediante un menú se podrán elegir determinas operaciones:
1. Abrir una nueva cuenta.
2. Ver un listado de las cuentas disponibles (código de cuenta, titular y saldo actual).
3. Obtener los datos de una cuenta concreta.
4. Realizar un ingreso en una cuenta.
5. Retirar efectivo de una cuenta.
6. Consultar el saldo actual de una cuenta.
7. Salir de la aplicación.
Las cuentas se irán almacenando en alguna estructura en memoria según vayan siendo creadas. Cada cuenta será un objeto de una clase que contendrá la siguiente
información:
• Titular de la cuenta (un objeto de la clase Persona, la cual contendrá información sobre el titular: nombre, apellidos, fecha de nacimiento).
• Saldo actual de la cuenta (número real).
• Número de cuenta (CCC - Código Cuenta Cliente).
• Tipo de interés anual (si se trata de una cuenta de ahorro).
Página 35 de 39
• Lista de entidades autorizadas para cobrar recibos de la cuenta (si se trata de una cuenta corriente).
• Comisión de mantenimiento (para el caso de una cuenta corriente personal).
• Tipo de interés por descubierto (si es una cuenta corriente de empresa).
• Máximo descubierto permitido (si se trata de una cuenta corriente de empresa)
Las cuentas bancarias pueden ser de dos tipos: cuentas de ahorro o bien cuentas corrientes. Las cuentas de ahorro son remuneradas y tienen un determinado tipo
de interés. Las cuentas corrientes no son remuneradas, pero tienen asociada una lista de entidades autorizadas para cobrar recibos domiciliados en la cuenta.
Dentro de las cuentas corrientes podemos encontrar a su vez otros dos tipos: las cuentas corrientes personales, que tienen una comisión de mantenimiento (una
cantidad fija anual) y las cuentas corrientes de empresa, que no la tienen. Además, las cuentas de empresa permiten tener una cierta cantidad de descubierto
(máximo descubierto permitido) y por tanto un tipo de interés por descubierto y una comisión fija por cada descubierto que se tenga. Es el único tipo de cuenta que
permite tener descubiertos.
Cuando se vaya a abrir una nueva cuenta bancaria, el usuario de la aplicación (empleado del banco) tendrá que solicitar al cliente:
• Datos personales: nombre, apellidos, fecha de nacimiento.
• Tipo de cuenta que desea abrir: cuenta de ahorro, cuenta corriente personal o cuenta corriente de empresa.
• Saldo inicial.
Además de esa información, el usuario de la aplicación deberá también incluir:
• Número de cuenta (CCC) de la nueva cuenta. Debe ser válido (habrá que comprobarlo).
• Tipo de interés de remuneración, si se trata de una cuenta de ahorro.
• de mantenimiento, si es una cuenta corriente personal.
• Máximo descubierto permitido, si se trata de una cuenta corriente de empresa.
• Tipo de interés por descubierto, en el caso de una cuenta corriente de empresa.
• Comisión fija por cada descubierto, también para el caso de una cuenta corriente de empresa.
La aplicación deberá asegurarse que la información introducida sea válida y coherente (CCC válido; saldos, comisiones y tipos de interés positivos, etc.).
El programa que escribas debe cumplir al menos los siguientes requisitos:
• Para almacenar los objetos de tipo cuenta podrás utilizar cualquier estructura de almacenamiento que consideres oportuna (ArrayList, Hashtable, etc.).
• Para trabajar con los datos personales, debes utilizar una clase Persona que contenga la información sobre los datos personales básicos del cliente
(nombre, apellidos, fecha de nacimiento).
• Para trabajar con el número de cuenta debes utilizar el modelo de Código Cuenta Cliente (CCC), que es posible que también la ya hayas usado en otras
unidades.
• Para guardar las entidades autorizadas a cobrar recibos debes utilizar una Hashtable que contenga pares de tipo (código de entidad (String), máxima
cantidad autorizada para un recibo).
Aquí tienes un ejemplo de una posible estructura de clases para llevar a cabo la aplicación:
El código fuente Java de cada clase debería incluir comentarios en cada atributo (o en cada conjunto de atributos) y método (o en cada conjunto de métodos del
mismo tipo) indicando su utilidad. El programa principal (clase principal) también debería incluir algunos comentarios explicativos sobre su funcionamiento y la
utilización de objetos de las distintas clases utilizadas.
Además del programa deberás escribir también un informe con todas las consideraciones oportunas que se necesiten para entender cómo has realizado la tarea.
El proyecto deberá contener al menos los siguientes archivos fuente Java:
• Programa principal (clase con método main: AplicacionCuentaBancaria.java).
• Un archivo por cada clase o interfaz que hayas implementado.
El documento que contendrá el informe lo elaborarás con un procesador de texto. Debe ser de tipo ".doc" (Microsoft Word) o de tipo ".odt" (OpenOffice.org). Debe
tener tamaño de página A4, estilo de letra Times New Roman, tamaño 12 e interlineado normal.
Para poder empezar a aplicar estos criterios es necesario que la aplicación compile y se ejecute correctamente en un ordenador. En caso contrario la puntuación
será directamente de 0,00.
Criterios de puntuación.
Existe una clase CuentaBancaria base que proporciona los atributos y métodos necesarios para cualquier tipo de cuenta bancaria genérica. La clase funciona
correctamente. 2,00
Existe una clase CuentaAhorro que proporciona los atributos y métodos necesarios para trabajar con una cuenta de ahorro. La clase funciona correctamente. 2,00
Existe una clase CuentaCorrientePersonal que proporciona los atributos y métodos necesarios para trabajar con una cuenta de corriente personal. La clase funciona
correctamente. 2,00
Existe una clase CuentaCorrienteEmpresa que proporciona los atributos y métodos necesarios para trabajar con una cuenta de corriente de empresa. La clase
funciona correctamente. 2,00
Las clases de tipo cuenta corriente disponen de una colección que contiene la lista de entidades autorizadas para cobrar recibos en esa cuenta. 1,00
Se utiliza algún tipo de colección (Hashtable, ArrayList, etc.) para manipular las cuentas que se van creando durante la ejecución del programa. 1,00
La información de un titular no es almacenada en objetos de la clase Persona que a su vez son almacenados dentro de los objetos de cuenta bancaria. -
1,00
Las clases no son capaces de validar y gestionar correctamente un CCC. -1,00
Los métodos de las clases no son capaces de lanzar excepciones si se produce alguna situación anómala. -1,00
Se utiliza el polimorfismo y la ligadura dinámica para trabajar con las cuentas bancarias y funciona correctamente. 2,00
No se han incluido comentarios en las clases tal y como se ha pedido en el enunciado. -1,00
No se han incluido comentarios apropiados en el programa principal describiendo el funcionamiento de éste. -1,00
No se ha entregado el informe explicativo. -2,00
El programa principal no es capaz de crear objetos de alguno de los tres tipos de cuentas bancarias solicitados (cuenta de ahorro, cuenta corriente personal o cuenta
corriente de empresa). -5,00
Alguna de las opciones de menú pedidas en el enunciado (menú del programa principal) no funciona correctamente. -1,00 por cada opción
Total (máximo) 10,00
Dado que algunos criterios de puntuación son negativos, podría suceder que el balance final fuera negativo. En tal caso la puntuación final será simplemente de 0,00.
Si el balance final es positivo y mayor que 10,00, la puntuación final quedará como 10,00.
• Ordenador personal.
• JDK y JRE de Java SE.
Página 36 de 39
• Entorno de desarrollo NetBeans con las funcionalidades necesarias para desarrollar y emular aplicaciones Java.
Para realizar la aplicación te sugerimos las siguientes recomendaciones:
• Básate en los diferentes ejemplos que has tenido que probar durante el estudio de esta unidad y de unidades anteriores. Algunos de ellos te podrán servir
de mucha ayuda, así que aprovéchalos.
• Puedes obtener información sobre del funcionamiento del CCC y cómo calcular los dígitos de control del siguiente artículo de Wikipedia:
Wikipedia: Código Cuenta Cliente.
• Puedes generar cuentas bancarias válidas (o comprobarlas) para hacer pruebas en tu programa desde el siguiente enlace:
Generador/validador de cuentas bancarias.
Una vez que tengas terminados el programa (carpeta de proyecto Netbeans, incluyendo todos los archivos fuente y todos los recursos) y el documento explicativo,
comprime ambos en un único archivo comprimido. El envío se realizará a través de la plataforma de la forma establecida para ello, y el archivo se nombrará
siguiendo las siguientes pautas:
Asegúrate que el nombre no contenga la letra ñ, tildes ni caracteres especiales extraños. Así por ejemplo la alumna Begoña Sánchez Mañas para la novena unidad
Tarea para PROG10.

Tarea para PROG10.
Enunciado.
En la tarea de esta unidad puedes elegir: Caché u Oracle. Se trata de que realices una pequeña aplicación, que usando clases o tipos de dato objeto (según elijas),
almacene un pequeño diccionario de traducciones. La idea es la siguiente:
• En la aplicación debe almacenarse un término, en español, junto con una lista de traducciones en otros idiomas. Por ejemplo, para el término "silla"
podría almacenarse su traducción en francés: "chaise"; y su traducción en inglés: "chair". Un término puede tener un número indefinido de traducciones, puede variar
entre términos, para un término podemos tener la traducción para dos idiomas (inglés y francés, por ejemplo), y para otro, la traducción para tres idiomas
completamente diferentes.
• No podrá haber términos repetidos, cada término debe aparecer una única vez.
• En la aplicación se podrán insertar nuevos términos y las traducciones asociadas, sin límite de traducciones posibles.
• En la aplicación se podrán borrar los términos existentes, y obviamente, sus traducciones asociadas. Cuando se borra un término solo debe borrarse un
único término (como se ha dicho antes, no puede haber repetidos).
• En la aplicación se podrán consultar los términos existentes, pudiendo buscar por aproximación. Por ejemplo, si se buscase el término "illa", podría
aparecer "silla" u "orilla", si estuvieran obviamente en la lista de términos insertados. De cada término encontrado (pude ser más de uno), deben mostrarse por
pantalla todas las traducciones que contiene. Además, cada vez que se muestra un término por pantalla, debe mostrarse también el número de veces que ha sido
mostrado.
• El número de veces que ha sido mostrado un término debe ir actualizándose. Cada vez que se muestra, debe incrementarse en uno.
Como parte de esta tarea tendrás que realizar lo siguiente:
• Diseñar un esquema de base de datos de objetos, ya sea en Oracle o Caché. Solo se pueden usar objetos y colecciones de objetos.
• Implementar un programa en Java, que conecte con la base de datos, y permita hacer todas las operaciones antes descritas.
La tarea tiene una puntuación total de 10 puntos, repartidos de la siguiente forma:
• 1,5 puntos: realización del esquema de la base de datos (incluyendo la inclusión de restricciones y usos adecuados de los tipos de datos).
• 1,5 puntos: conexión con la base de datos.
• 2 puntos: almacenar un nuevo término en la base de datos, junto con sus traducciones.
• 1,5 puntos: eliminar un término de la base de datos.
• 1,5 puntos: actualizar el contador de consultas.
• 2 puntos: limpieza del código, comentarios explicativos y elegancia de la solución.
Para la realización de esta tarea necesitas:
• Un entorno de desarrollo de aplicaciones en Java como NetBeans.
• Un sistema gestor de base de datos orientado a objetos, como Intersystems Caché u OracleXE.
• Los drivers para conectarte vía JDBC a la base de datos.
A la hora de afrontar la tarea:
• Elige el sistema gestor de base de datos que te resulte más cómodo, después de leer los contenidos más o menos tendrás una idea hecha de cada uno.
• Diseña en primer lugar la base de datos, no empieces la casa por el tejado. Es recomendable utilizar colecciones tipo array de Caché o tablas anidadas de
Oracle.
• Una vez que hayas conseguido diseñar la base de datos, piensa en que mecanismo vas a utilizar para acceder a ella, si proyecciones Java o JDBC.
• Después empieza paso por paso a desarrollar la solución, ten en cuenta que cada pasito suma puntos.
Página 37 de 39
Asegúrate que el nombre no contenga la letra ñ, tildes ni caracteres especiales extraños. Así por ejemplo la alumna Begoña Sánchez Mañas para la decima unidad
Tarea para PROG11.
Tarea para PROG11.
Enunciado.
Se trata de hacer una aplicación en Java que acceda a una base de datos MySQL de una notaría y mediante un menú pueda realizar determinadas operaciones. La
base de datos a la que accederemos, por comodidad, será la correspondiente al esquema test, que ya viene por defecto en la instalación de MySQL, y ahí crearemos
las tablas necesarias.
Puedes utilizar un JOptionPane para presentar el menú con las opciones que permita realizar el programa:
• Crear tabla Clientes.
o Que contendrá los campos: Cod_Cliente, Nombre y Teléfono del mismo.

• Crear tabla Escrituras. Que contendrá los siguiente campos:
o Código, que representa el código único de escritura.

o Tipo, representa el tipo de escritura, almacenándose valores tales como: "TEST" para testamento, "CPVE" para compraventa, etc.
o Nom_fich, corresponde al nombre del fichero donde se guarda el texto íntegro de la escritura, de modo que tomará valores como:
"compraventa_AntonioBJ_10_12_2010.doc".
o Num_interv, que representa el número de intervinientes, o sea, de las personas que involucra la escritura, como 2 compradores y un vendedor, por tanto,
serían 3 los intervinientes.
• Crear la tabla EscCli, que sirve para relacionar las escrituras, con los intervinientes que participan en ella, por lo que contendrá los campos:
o codCli
o codEsc
• Insertar datos en la tabla Clientes.
o Inserta al menos tres clientes en la tabla de Clientes.

• Insertar datos en la tabla Escrituras y EscCli.
o Inserta algunos datos para que haya clientes con escrituras.

• Recuperar datos de la tabla Clientes.
o Recupera los datos de la tabla Clientes y los muestra al usuario.

• Recuperar datos de la tabla Escrituras.
o Recupera los datos de la tabla Escrituras y los muestra al usuario.

• Actualizar en tabla Clientes.
o Realizar una consulta de actualización, "Update", sobre un registro previamente insertado, por ejemplo cambiar el teléfono a un cliente, o el nombre.
• Listar el nombre de los clientes que hayan realizado una compraventa (tipo de escritura CPVE).
Elabora el programa y si además de esas opciones que se piden, realizas alguna o algunas otras, entonces elabora también un documento con un procesador de
texto. El documento debe ser de tipo ".doc" (Microsoft Word) o de tipo ".odt" (OpenOffice.org). El documento debe tener tamaño de página A4, estilo de letra Times
New Roman, tamaño 12 e interlineado normal.
En el documento escribirás un informe sobre las opciones adicionales que hayas incluido con las consideraciones oportunas que se necesiten para entender su
utilidad.
Una vez que tengas terminados el programa y el documento explicativo (si lo has elaborado), comprime ambas cosas en un único fichero. El nombre del fichero debe
ser del siguiente estilo: "PROG_T11_Apellido1Apellido2Nombre.zip". Por ejemplo para el alumno Juan Cruz García, el fichero se llamará:
PROG_T11_CruzGarciaJuan_E1.zip
No utilices espacios en blanco, la letra ñ o tildes en el nombre de archivo. Envía el fichero al buzón de tareas para que la corrija tu tutor del módulo.
La tarea es la actividad más importante de la unidad, por tanto debemos transmitir al alumnado la trascendencia de responder y elaborar dicha actividad con el
máximo de rigor e interés ya que esta es el principal mecanismo de consolidación de su aprendizaje.
La tarea se evalúa valorándola con 10 puntos.
Es suficiente con los contenidos y los enlaces que se proporcionan en la propia unidad. Ningún recurso adicional es necesario.
Te recomendamos que antes de abordar la tarea leas con detenimiento la unidad, consultando los enlaces para saber más y debes conocer que aparecen en la
misma, y aclarando las dudas que te surjan con tu tutor o tutora. Después realiza el examen online de la unidad, y consulta nuevamente las dudas que te surjan. Solo
cuando lo tengas todo claro, deberás abordar la realización de la tarea.
Asegúrate que el nombre no contenga la letra ñ, tildes ni caracteres especiales extraños. Así por ejemplo la alumna Begoña Sánchez Mañas para la décimo primera
unidad del MP de PROG, debería nombrar esta tarea como...
Página 38 de 39
Página 39 de 39

Ejercicos en Java

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Ejercicos en Java

Cargado por

Copyright:

Formatos disponibles

Tarea para PROG01.

Detalles de la tarea de esta unidad.

mi variable:…………………. incorrecto, no se pueden utilizar espacios en blanco.

public class ejerciciovariables {

public static void main(String[ ] args) {

public class ejerciciovariables {

3.- Realiza las siguientes modificaciones en el programa anterior:

//print utilizamos \n y \t para dar salto de linea y tabulaciÃ³n

/*printf este comentario no se utilizara en javadoc

4.- Indica los errores presentes en el siguiente código:

Código del enunciado.

Solución línea a línea.

5. public class operadoresaritmeticos {

System.out.println("Intruduce primer nÃºmero"); // PeticiÃ³n del primer nÃºmero.

// Para determinar si 2 nÃºmero son multiplos, el resto de su divisiÃ³n es 0

public static void main(String[] args) { // Metodo main del programa.

System.out.println("Introducir coeficiente c1"); // Peticion de datos por pantallas.

x = -c2/c1; // Asignacion del valor de x despejando la ecuacion.

import java.util.Scanner; //ImportaciÃ³n del paquete necesario para el uso de la

public static void main(String[] args) { // Metodo main del

Scanner teclado = new Scanner(System.in); // Clase Scanner para la

System.out.println("Introducir primer nÃºmero"); // Peticion de datos por

System.out.println("x = "+ x +" y = "+ y); //ImpresiÃ³n de los valores

double cuadrado=Math.pow(x,2); //DeclaraciÃ³n e inicializaciÃ³n una variable

System.out.println("x ^ 2 = "+ cuadrado); //ImpresiÃ³n del valor de la

public static void main(String[] args) { // Metodo main del programa.

Scanner teclado = new Scanner(System.in); // Clase Scanner para la

System.out.println("Introduce un numero de 5 dÃgitos"); // Peticion por pantalla del

cuarto = digito % 10;

tercero = digito % 10;

segundo = digito % 10;

Tipo_Variable Variable Valor / Operación

El resultado del programa debe ser el siguiente:

------- Operaciones con char -------

public static void main(String[] args) { //Inicio del metodo main.

float x = 4.5f; // DeclaraciÃ³n y asignacion de variables.

System.out.println("\n----- OPERACIONES CON BYTE -----");

System.out.println("byte " + bx + " - " + by + " = " + bz);

bz = (int) (bx - by);

System.out.println("\n----- OPERACIONES CON SHORT -----");

System.out.println("short " + sx + " + " + sy + " = " + sz);

System.out.println("\n----- OPERACIONES CON CHAR -----");

System.out.println("char " + cx + " - 1 = " + z);

System.out.println("(int)" + cx + " = " + z);

System.out.println("(short)" + cx + " = " + sx);

Criterios de puntuación. Total 10 puntos.

Recursos necesarios para realizar la Tarea.

NetBeans IDE 6.9.1 o superior

Tarea para PROG03.

public class Persona {

public class Persona {

void cambia_Nombre(String nom) {

Persona miPersona = new Persona();

System.out.println("Dame un nombre para cambiar ");

Después completa el programa para comprobar el funcionamiento de los nuevos métodos.

public static void main(String[] args) {

Persona miPersona = new Persona();

System.out.println("Dame una altura");

public class Persona {

public int consulta_Edad() {

public void cambia_Edad(int edad) {

public float consulta_Altura() {

public void cambia_Altura(float altura) {

public static void main(String[] args) {