Java - Egg

Introducción a Java
Introducción
a Java
OBJETIVOS DE LA GUÍA
En esta guía aprenderemos a:
● Utilizar el nuevo IDE.

● Comprender la estructura básica de Java
● Comprender los tipos de datos en Java
● Definir y operar variables.
● Utilizar los métodos de escritura y salida
● Utilizar las clases de utilidad
Hasta el momento hemos aprendido los diferentes tipos de estructuras de
control comunes a todos los lenguajes de programación, dentro del paradigma
de programación imperativa, haciendo uso del pseudo intérprete PSeInt. A
partir de esta guía comenzaremos a introducir cada uno de los conceptos
vistos hasta el momento, pero haciendo uso de un lenguaje de programación
de propósito general como lo es Java.
Java
Java es un tipo de lenguaje de programación y una plataforma informática,
creada y comercializada por Sun Microsystems en el año 1995 y desde
entonces se ha vuelto muy popular, gracias a su fácil portabilidad a todos los
sistemas operativos existentes.
Java es un lenguaje de programación de alto nivel, estos permiten escribir

código mediante idiomas que conocemos (inglés, español, etc.) y luego, para
ser ejecutados, se traduce al lenguaje de máquina mediante traductores o
compiladores. Java es un lenguaje de alto nivel donde sus palabras reservadas
están en inglés.
2
Estructura de un programa Java
Vamos a crear un programa desde cero. Estos pasos los repetirás cada vez que
realices un nuevo ejercicio, de esta manera tendrás todos tus proyectos
ordenados y podrás recurrir a ellos fácilmente cuando lo necesites.
Primero deberemos ir a File -> New Project
O podemos hacer click en la siguiente opción:
3
Ahora deberemos elegir el tipo de proyecto que queremos crear, vamos a elegir
un proyecto de Java
Por último deberemos ponerle un nombre a nuestro proyecto
Aquí colocamos el nombre del proyecto de la siguiente manera:
4
Nos quedaría así:
¿Cómo se ve un programa en java?

Un programa describe como un ordenador debe interpretar las órdenes del
programador para que ejecute y realice las instrucciones dadas tal como están
escritas. Un programador utiliza los elementos que ofrece un lenguaje de
programación para diseñar programas que resuelvan problemas concretos o
realicen acciones bien definidas.
El siguiente programa Java muestra un mensaje en la consola con el texto

“Hola Mundo”.
/*
Este programa escribe el texto "Hola Mundo" en la consola,
utilizando el método System.out.println
*/
package primerprograma;
public class HolaMundo {
public static void main(String[] args) {
//La línea 12 muestra el mensaje por pantalla al ejecutar el

programa
System.out.println("Hola mundo");
}
}
5
En este programa se pueden identificar los siguientes elementos del lenguaje
Java: comentarios, paquete, definiciones de clase, definiciones de método y
sentencias. Veamos qué es y qué hace cada uno:
¿Cuáles son los comentarios?

El texto del primer comentario de este ejemplo sería: ‘Este programa escribe el
texto “Hola Mundo” en la consola utilizando el método System.out.println()'.
El segundo comentario es // La línea 12 muestra el mensaje por pantalla al

ejecutar el programa
Los comentarios son ignorados por el compilador y solo son útiles para el
programador. Los comentarios ayudan a explicar aspectos relevantes de un
programa y lo hacen más legible. En un comentario se puede escribir todo lo
que se desee, el texto puede ser de una o más líneas.
¿Cuál es el paquete?
Después del comentario viene escrito el nombre del paquete. Los paquetes son
contenedores de clases y su función es la de organizar la distribución de las
clases. Los paquetes y las clases son análogos a las carpetas y archivos
utilizados por el sistema operativo, respectivamente. Esto quiere decir, cada
paquete es una carpeta que contiene archivos, que son las clases.
El lenguaje de programación de la tecnología Java le provee la sentencia

package como la forma de agrupar clases relacionadas. La sentencia package
tiene la siguiente forma:
6
package <nombre_paq_sup>[.<nombre_sub_paq>]*;
La declaración package, en caso de existir, debe estar al principio del archivo

fuente y sólo la declaración de un paquete está permitida. Los nombres de los
paquetes los pondrá el programador al crear el programa y son jerárquicos (al
igual que una organización de directorios en disco) además, están separados
por puntos. Es usual que sean escritos completamente en minúscula.
¿Cuál es la clase?
La primera línea del programa, después del package. Define una clase que se
llama HolaMundo. En el mundo de orientación a objetos, todos los programas
se definen en términos de objetos y sus relaciones. Las clases sirven para
modelar los objetos que serán utilizados por nuestros programas. Los objetos,
las clases y los paquetes son conceptos que serán abordados con
profundidad más adelante en el curso.
Una clase está formada por una parte correspondiente a la declaración de la

clase, y otra correspondiente al cuerpo de la misma:
Declaración de clase {
Cuerpo de clase
En la plantilla de ejemplo se ha simplificado el aspecto de la Declaración de

clase, pero sí que puede asegurarse que la misma contendrá, como mínimo, la
palabra reservada class y el nombre que recibe la clase. La definición de la
clase o cuerpo de las comienza con una llave abierta ({) y termina con una llave
cerrada (}). El nombre de la clase lo define el programador.
¿Cuál es el Método?
Después de la definición de clase se escribe la definición del método main().
Pero que es un método?. Dentro del cuerpo de la clase se declaran los
atributos y los métodos de la clase. Un método es una secuencia de sentencias
ejecutables. Las sentencias de un método quedan delimitadas por los
caracteres { y } que indican el inicio y el fin del método, respectivamente. Si
bien es un tema sobre el que se profundizará más adelante en el curso, los
métodos son de vital importancia para los objetos y las clases. En un principio,
para dar los primeros pasos en Java nos alcanza con esta definición.
7
Método main()
Ahora sabemos lo que es un método, pero en el ejemplo podemos ver el
método main(). El main() sirve para que un programa se pueda ejecutar, este
método, vendría a representar el Algoritmo / FinAlgoritmo de PseInt y tiene la
siguiente declaración:
public static void main(String[] args){
A continuación, describiremos cada uno de los modificadores y componentes

que se utilizan siempre en la declaración del método main():
public: es un tipo de acceso que indica que el método main() es público y, por
tanto, puede ser llamado desde otras clases. Todo método main() debe ser
público para poder ejecutarse desde el intérprete Java (JVM).
static: es un modificador el cual indica que la clase no necesita ser instanciada

para poder utilizar el método. También indica que el método es el mismo para
todas las instancias que pudieran crearse.
void: indica que la función o método main() no devuelve ningún valor.
El método main() debe aceptar siempre, como parámetro, un vector de strings,

que contendrá los posibles argumentos que se le pasen al programa en la línea
de comandos, aunque como es nuestro caso, no se utilice.
Luego, al indicarle a la máquina virtual que ejecute una aplicación el primer

método que ejecutará es el método main(). Si indicamos a la máquina virtual
que corra una clase que no contiene este método, se lanzará un mensaje
advirtiendo que la clase que se quiere ejecutar no contiene un método main(),
es decir que dicha clase no es ejecutable.
Si no se han comprendido hasta el momento muy bien todos estos conceptos,

los mismos se irán comprendiendo a lo largo del curso.
8
Sentencia
Son las unidades ejecutables más pequeñas de un programa, en otras
palabras, una línea de código escrita es una sentencia. Especifican y controlan
el flujo y orden de ejecución del programa. Una sentencia consta de palabras
clave o reservadas como expresiones, declaraciones de variables, o llamadas a
funciones.
En nuestro ejemplo, del método main() se incluye una sentencia para mostrar
un texto por la consola. Los textos siempre se escriben entre comillas dobles
para diferenciarlos de otros elementos del lenguaje. Todas las sentencias de
un programa Java deben terminar con el símbolo punto y coma. Este símbolo
indica al compilador que ha finalizado una sentencia.
Una vez que el programa se ha editado, es necesario compilarlo y ejecutarlo

para comprobar si es correcto. Al finalizar el proceso de compilación, el
compilador indica si hay errores en el código Java, donde se encuentran y el
tipo de error que ha detectado: léxico, sintáctico o semántico.
9
¿Cuáles son los elementos de un programa?
Los conceptos vistos previamente, son la estructura de un programa, pero
también existen los elementos de un programa. Estos son, básicamente, los
componentes que van a conformar las sentencias que podamos escribir en
nuestro programa. Recordemos que toda sentencia en nuestro programa debe
terminar con el símbolo punto y coma Nos van a ayudar para crear nuestro
programa y resolver sus problemas. Estos elementos siempre estarán dentro
de un programa/algoritmo.
Los elementos de un programa son: identificadores, variables, constantes,

operadores, palabras reservadas.
¿Qué son las palabras reservadas?

Palabras que dentro del lenguaje significan la ejecución de una instrucción
determinada, por lo que no pueden ser utilizadas con otro fin. En Java, al ser un
lenguaje que está creado en inglés, todas nuestras palabras reservadas van a
estar en ese idioma.
¿Qué son los Identificadores?

Los identificadores son los nombres que se usan para identificar cada uno de
los elementos del lenguaje, como ser, los nombres de las variables, nombres de
las clases, interfaces, atributos y métodos de un programa. Si bien Java
permite nombres de identificadores tan largos como se desee, es aconsejable
crearlos de forma que tengan sentido y faciliten su interpretación. El nombre
ideal para un identificador es aquel que no se exceda en longitud (lo más corto
posible) y que califique claramente el concepto que intenta representar en el
contexto del problema que se está resolviendo.
10
Variables y Constantes
Recordemos que en Pseint dijimos que los programas de computadora
necesitan información para la resolución de problemas. Está información
puede ser un número, un nombre, etc. Para utilizar la información, vamos a
guardarla en algo llamado, variables y constantes. Las variables y constantes
vendrían a ser como pequeñas cajas, que guardan algo en su interior, en este
caso información. Estas, van a contar como previamente habíamos
mencionado, con un identificador, un nombre que facilitara distinguir unas de
otras y nos ayudará a saber que variable o constante es la contiene la
información que necesitamos.
Dentro de toda la información que vamos a manejar, a veces, necesitaremos

información que no cambie. Tales valores son las constantes. De igual forma,
existen otros valores que necesitamos que cambien durante la ejecución del
programa; esas van a ser nuestras variables.
Declaración de variables en Java

Normalmente los identificadores de las variables y de las constantes con
nombre deben ser declaradas en los programas antes de ser utilizadas. La
sintaxis de la declaración de una variable en java suele ser:
<tipo_de_dato> <nombre_variable>;
Tipos de dato en Java

Java es un lenguaje de tipado estático, esto significa que todas las variables
deben ser declaradas antes que ellas puedan ser utilizadas y que no podemos
cambiar el tipo de dato de una variable, a menos que sea a través de una
conversión.
11
Tipos de Datos Primitivos
Primitivos: Son predefinidos por el lenguaje. La biblioteca Java proporciona
clases asociadas a estos tipos que proporcionan métodos que facilitan su
manejo.
byte Es un entero con signo de 8 bits, el mínimo valor que se

puede almacenar es -128 y el máximo valor es de 127
(inclusive).
short Es un entero con signo de 16 bits. El valor mínimo es -32,768

y el valor máximo 32,767 (inclusive).
int Es un entero con signo de 32 bits. El valor mínimo es

-2,147,483,648 y el valor máximo es 2,147,483,64 (inclusive).
Generalmente es la opción por defecto.
long Es un entero con signo de 64 bits, el valor mínimo que puede

almacenar este tipo de dato es -9,223,372,036,854,775,808 y
el máximo valor es 9,223,372,036,854,775,807 (inclusive).
float Es un número decimal de precisión simple de 32 bits (IEEE

754 Punto Flotante).
double Es un número decimal de precisión doble de 64 bits (IEEE 754

Punto Flotante).
12
boolean Este tipo de dato sólo soporta dos posibles valores:
verdadero o falso y el dato es representado con tan solo un
bit de información.
El tipo de dato carácter es un simple carácter unicode de 16

bits. Su valor mínimo es de '\u0000' (En entero es 0) y su
char
valor máximo es de '\uffff' (En entero es 65,535). Nota: un
dato de tipo carácter se puede escribir entre comillas simples,
por ejemplo 'a', o también indicando su valor Unicode, por
ejemplo '\u0061'.
String Además de los tipos de datos primitivos el lenguaje de

programación Java provee también un soporte especial para
cadena de caracteres a través de la clase String.
Encerrando la cadena de caracteres con comillas dobles se

creará de manera automática una nueva instancia de un
objeto tipo String.
String cadena = “Sebastián”;
Los objetos String son inmutables, esto significa que una vez
creados, sus valores no pueden ser cambiados. Si bien esta
clase no es técnicamente un tipo de dato primitivo, el lenguaje
le da un soporte especial y hace parecer como si lo fuera.
13
¿Cómo se ve en Java?
public class HolaMundo {

//Este es el método main
String nombre;
int numero;
double decimales;
}
}
Ejercicio 1
Crear un proyecto de Java y definir al menos 6 variables en tu IDE de distintos
tipos de datos.
Detección de errores
¿Puedes corregir las siguientes declaraciones de variables?

string nombre
bolean bandera
char char;
}
}
14
Instrucciones primitivas
Dentro de las instrucciones previamente vistas, existe una subdivisión que son
las instrucciones primitivas, las instrucciones primitivas van a ser las
instrucciones de asignación, lectura y escritura.
Asignación
La instrucción de asignación permite almacenar un valor en una variable
(previamente definida). Esta es nuestra manera de guardar información en una
variable, para utilizar ese valor en otro momento.
<variable> = <expresión>
En Java, podemos definir una variable y al mismo tiempo podemos asignarle un

valor a diferencia de Pseint:
<tipo_de_dato> <nombre_variable> = expresion;
15
Al ejecutarse la asignación, primero se evalúa la expresión de la derecha y
luego se asigna el resultado a la variable de la izquierda. El tipo de la variable y
el de la expresión deben coincidir.

String nombre = "Mariano";
int numero = 10;
double decimales = 40.5;
}
Valores por defecto

En Java no siempre es necesario asignar valores cuando nuevos atributos son
declarados. Cuando los atributos son declarados, pero no inicializados, el
compilador les asignará un valor por defecto. A grandes rasgos el valor por
defecto será cero o null dependiendo del tipo de dato. La siguiente tabla
resume los valores por defecto dependiendo del tipo de dato.
short 0
int 0
long 0
double 0.0
boolean False
char '\u0000'
String Null
Objetos Null
16
Las variables locales son ligeramente diferentes; el compilador no asigna un
valor predeterminado a una variable local no inicializada. Las variables locales
son aquellas que se declaran dentro de un método. Si una variable local no se
inicializa al momento de declararla, se debe asignar un valor antes de intentar
usarla. El acceso a una variable local no inicializada dará lugar a un error en
tiempo de compilación.
Ejercicio 2
¿Recuerdas las variables que creaste en el ejercicio anterior? Ahora deberás
asignarles un valor.
Detección de errores

int numero = "48";
double decimales = 3,55;
bolean bandera -> "false";
}
}
17
Operadores
Los operadores son símbolos especiales de la plataforma que permiten
especificar operaciones en uno, dos o tres operandos y retornar un resultado.
También aprenderemos qué operadores poseen mayor orden de precedencia.
Los operadores con mayor orden de precedencia se evalúan siempre primero.
Primeramente, proceden los operadores unarios, luego los aritméticos,

después los de bits, posteriormente los relacionales, detrás vienen los
booleanos y por último el operador de asignación. La regla de precedencia
establece que los operadores de mayor nivel se ejecuten primero. Cuando dos
operadores poseen el mismo nivel de prioridad los mismos se evalúan de
izquierda a derecha.
Operadores Aritméticos
+ Operador de Suma
- Operador de Resta
* Operador de Multiplicación
/ Operador de División
% Operador de Módulo
Operadores Unarios
+ Operador Unario de Suma; indica que el valor es positivo.
- Operador Unario de Resta; indica que el valor es negativo.
++ Operador de Incremento.
-- Operador de Decremento.
18
Operadores de Igualdad y Relación
== Igual
!= Distinto
> Mayor que
>= Mayor o igual que
< Menor que
<= Menor o igual que
¿Cómo se ve en Java?
int num1 = 5;
int num2 = 5;
int suma = num1 + num2;
double division = num1 / num2;
boolean logico = num2 < num1;
num1++;
19
Ejercicio 3
Define variables donde puedas alojar los resultados y prueba usar dos
operadores de cada tipo.
20
Tipos de Instrucciones
Además de los elementos de un programa/algoritmo, tenemos las instrucciones
que pueden componer un programa. Las instrucciones —acciones— básicas
que se pueden implementar de modo general en un algoritmo y que
esencialmente soportan todos los lenguajes son las siguientes:
✓ Instrucciones de inicio/fin, son utilizadas para delimitar bloques de

código.
✓ Instrucciones de asignación, se utilizan para asignar el resultado de
la evaluación de una expresión a una variable. El valor (dato) que se
obtiene al evaluar la expresión es almacenado en la variable que se
indique.
✓ Instrucciones de lectura, se utilizan para leer datos de un dispositivo
de entrada y se asignan a las variables.
✓ Instrucciones de escritura, se utilizan para escribir o mostrar
mensajes o contenidos de las variables en un dispositivo de salida.
✓ Instrucciones de bifurcación, mediante estas instrucciones el

desarrollo lineal de un programa se interrumpe. Las bifurcaciones o al
flujo de un programa puede ser según el punto del programa en el
que se ejecuta la instrucción hacia adelante o hacia atrás.
Entrada y Salida de Información

Los cálculos que realizan las computadoras requieren, para ser útiles la entrada
de los datos necesarios para ejecutar las operaciones que posteriormente se
convertirán en resultados, es decir, salida.
Las operaciones de entrada permiten leer determinados valores y asignarlos a

determinadas variables y las operaciones de salida permiten escribir o mostrar
resultados de determinadas variables y las operaciones, o simplemente
mostrar mensajes.
21
Escritura en Java
En nuestro ejemplo de código al principio de la guía, usábamos la instrucción
System.out.println() para mostrar el mensaje Hola Mundo. Esta instrucción
permite mostrar valores en el Output, que es la interfaz gráfica de Java. Todo
lo que quisiéramos mostrar en nuestra interfaz gráfica, deberá ir entre comillas
dobles y dentro del paréntesis.
System.out.println("Hola Mundo");
Si quisiéramos concatenar un mensaje y la impresión de una variable

deberíamos usar el símbolo más para poder lograrlo.
System.out.println("La variable tiene el valor de: " + variable);
Si quisiéramos escribir sin saltos de línea, deberíamos quitarle el ln a nuestro

System.out.println.
System.out.print("Hola");
System.out.print("Mundo");
int num = 10;
System.out.println("La variable tiene el valor de: " + num);
System.out.print("Hola");
System.out.print("Mundo");
22
Ejercicio 4
Define una variable que aloje tu nombre y otra que guarde tu edad. Imprime
ambas variables por pantalla.
Recomendamos que hagan el siguiente experimento: tipear en minúsculas la

palabra sout y apenas terminamos de escribirla tocar el botón tab o mejor
dicho tabular.
Esto nos va a generar un System.out.println() para poder escribir lo que

queramos.
23
Clases de utilidad
Se acuerdan que en PseInt vimos una serie de funciones y dijimos que las
funciones, son herramientas que nos proporciona PSeInt y cumplen el
propósito de ayudarnos a resolver ciertos problemas. Bueno, en Java existe
algo muy parecido que se llama Clases de utilidad.
¿Qué son las clases de utilidad?

Las clases de utilidad son clases que definen un conjunto de
métodos/funciones que realizan operaciones, normalmente muy utilizadas o
necesarias. Lo que va a facilitar las clases es no tener que escribir dicha
operación nosotros, por ejemplo, supongamos que tenemos que calcular la raíz
cuadrada de un número, Java no va a dar un método/función, que pasándole
un número, nos devuelve el resultado de su raíz cuadrada.
Entre las clases de utilidad de Java más utilizadas y conocidas están las
siguientes: Arrays, String, Integer, Math, Date, Calendar y GregorianCalendar.
En esta guía solo vamos a ver a Math y String para hacer algunos ejercicios y
después veremos el resto en mayor profundidad. Estas nos van a ayudar junto
con Java, a lograr resolver problemas de manera más sencilla.
Clase String
Método Descripción.
charAt(int index) Retorna el carácter especificado en

la posición index
equals(String str) Sirve para comparar si dos cadenas

son iguales. Devuelve true si son
iguales y false si no.
equalsIgnoreCase(String str) Sirve para comparar si dos cadenas

son iguales, ignorando la grafía de la
palabra. Devuelve true si son iguales
y false si no.
24
compareTo(String Compara dos cadenas de caracteres
otraCadena) alfabéticamente. Retorna 0 si son
iguales, entero negativo si la primera
es menor o entero positivo si la
primera es mayor.
concat(String str) Concatena la cadena del parámetro

al final de la primera cadena.
contains(CharSequence s) Retorna true si la cadena contiene la

secuencia tipo char del parámetro.
endsWith(String suffix) Retorna verdadero si la cadena es

igual al objeto del parámetro
indexOf(String str) Retorna el índice de la primera

ocurrencia de la cadena del
parámetro
isEmpty() Retorna verdadero si la longitud de

la cadena es 0
length() Retorna la longitud de la cadena
replace(char oldChar, char Retorna una nueva cadena

newChar) reemplazando los caracteres del
primer parámetro con el carácter del
segundo parámetro
split(String regex) Retorna un arreglo de cadenas

separadas por la cadena del
parámetro
25
startsWith(String prefix) Retorna verdadero si el comienzo de
la cadena es igual al prefijo del
parámetro.
substring(int beginIndex) Retorna la sub cadena desde el

carácter del parámetro
substring(int beginIndex, int Retorna la sub cadena desde el

endIndex) carácter del primer parámetro hasta
el carácter del segundo parámetro
toCharArray() Retorna el conjunto de caracteres de

la cadena
toLowerCase() Retorna la cadena en minúsculas
toUpperCase() Retorna la cadena en mayúsculas
Java al ser un lenguaje de tipado estático, requiere que para pasar una variable
de un tipo de dato a otro necesitemos usar un conversor. Por lo que, para
convertir cualquier tipo de dato a un String, utilicemos la función valueOf(n).
Ejemplo:
int numEntero = 4;
String numCadena = String.valueOf(numEntero);
Si quisiéramos hacerlo al revés, de String a int se usa el método de la clase

Integer, parseInt().
Ejemplo:
String numCadena = "1";

int numEntero = Integer.parseInt(numCadena);
26
Clase Math
En ocasiones nos vemos en la necesidad de incluir cálculos, operaciones,
matemáticas, estadísticas, etc en nuestros programas Java.
Es cierto que muchos cálculos se pueden hacer simplemente utilizando los

operadores aritméticos que Java pone a nuestra disposición, pero existe una
opción mucho más sencilla de utilizar, sobre todo para cálculos complicados.
Esta opción es la clase Math del paquete java.lang.
La clase Math nos ofrece numerosos y valiosos métodos y constantes

estáticos, que podemos utilizar tan sólo anteponiendo el nombre de la clase.
abs(double a) Devuelve el valor absoluto de un valor double

introducido como parámetro.
abs(int a) Devuelve el valor absoluto de un valor Entero

abs(long a) Devuelve el valor absoluto de un valor long

max(double a, double Devuelve el mayor de dos valores double

b)
max(int a, int b) Devuelve el mayor de dos valores Enteros.
max(long a, long b) Devuelve el mayor de dos valores long.
27
min(double a, double Devuelve el menor de dos valores double.
b)
min(int a, int b) Devuelve el menor de dos valores enteros.
min(long a, long b) Devuelve el menor de dos valores long.
pow(double a, double Devuelve el valor del primer argumento elevado a

b) la potencia del segundo argumento.
random() Devuelve un double con un signo positivo, mayor o

igual que 0.0 y menor que 1.0.
round(double a) Devuelve el long redondeado más cercano al

double introducido.
sqrt(double a) Devuelve la raíz cuadrada positiva correctamente

redondeada de un double.
floor(double a) Devuelve el entero más cercano por debajo.
Método random() de la clase Math

El método random podemos utilizarlo para generar números al azar. El rango o
margen con el que trabaja el método random oscila entre 0.0 y 1.0 (Este último
no incluido)
Por lo tanto, para generar un número entero entre 0 y 9, hay que escribir la
siguiente sentencia:
int numero = (int) (Math.random() * 10);
28
29
Ejercicios
Ejercicios de aprendizaje
A partir de ahora comenzaremos a aprender cómo los mismos algoritmos que
diseñamos en PSeInt podemos escribirlos también en Java, simplemente
haciendo una traducción de cada una de las estructuras de control vistas en
PSeInt a Java.
Si bien en esta guía se proponen nuevos problemas, se sugiere que los mismos
ejercicios ya implementados en PSeInt sean traducidos al lenguaje de
programación Java.
VIDEOS: Te sugerimos ver los videos relacionados con este tema,

antes de empezar los ejercicios, los podrás encontrar en tu aula
virtual o en nuestro canal de YouTube.
Los ejercicios van a seguir con el siguiente filtro de dificultad:
Dificultad baja Dificultad media Dificultad alta
1. Escribir un programa que pida dos números enteros por teclado y calcule
la suma de los dos. El programa deberá después mostrar el resultado de
la suma
2. Escribir un programa que pida tu nombre, lo guarde en una variable y lo

muestre por pantalla.
3. Escribir un programa que pida una frase y la muestre toda en mayúsculas

y después toda en minúsculas.
Nota: investigar la función toUpperCase() y toLowerCase() en Java.
4. Dada una cantidad de grados centígrados se debe mostrar su

equivalente en grados Fahrenheit. La fórmula correspondiente es: F = 32
+ (9 * C / 5).
5. Escribir un programa que lea un número entero por teclado y muestre

por pantalla el doble, el triple y la raíz cuadrada de ese número.
Nota: investigar la función Math.sqrt().
2
Estructuras de control
Material de
lectura
● Definir y utilizar estructuras de control

● Definir y utilizar estructuras repetitivas
● Entender las sentencias de salto
Ya conocemos las estructuras de control de nuestro paso por PseInt pero
ahora vamos a verlas en detalle en Java y como es su funcionamiento.
Instrucciones de bifurcación
Mediante estas instrucciones el desarrollo lineal de un programa se interrumpe.
Las bifurcaciones o al flujo de un programa puede ser según el punto del
programa en el que se ejecuta la instrucción hacia adelante o hacia atrás. De
esto se encargan las estructuras de control.
Para esto también vamos a usar los operadores lógicos o condicionales, estos
son los mismos que en PseInt pero se escriben de distintas formas:
Operadores Condicionales
&& AND
|| OR
! Operador Lógico de Negación.
Estructuras de Control
Las estructuras de control son construcciones hechas a partir de palabras
reservadas del lenguaje que permiten modificar el flujo de ejecución de un
programa. De este modo, pueden crearse construcciones de alternativas
mediante sentencias condicionales y bucles de repetición de bloques de
instrucciones. Hay que señalar que un bloque de instrucciones se encontrará
encerrado mediante llaves {……..} si existe más de una instrucción.
2
Estructuras condicionales
Los condicionales son estructuras de control que cambian el flujo de ejecución
de un programa de acuerdo con si se cumple o no una condición. Cuando el
flujo de control del programa llega al condicional, el programa evalúa la
condición y determina el camino a seguir. Existen dos tipos de estructuras
condicionales, las estructuras if / else y la estructura switch.
If/Else
La estructura if es la más básica de las estructuras de control de flujo. Esta
estructura le indica al programa que ejecute cierta parte del código sólo si la
condición evaluada es verdadera («true»). La forma más simple de esta
estructura es la siguiente:
if(<condición>){
<sentencias>
}
En donde, <condición> es una expresión condicional cuyo resultado luego de la

evaluación es un dato booleano(lógico) verdadero o falso. El bloque de
instrucciones <sentencias> se ejecuta si, y sólo si, la expresión (que debe ser
lógica) se evalúa a true, es decir, se cumple la condición.
Luego, en caso de que la condición no se cumpla y se quiera ejecutar otro

bloque de código, otra forma de expresar esta estructura es la siguiente:
if(<condición>){
<sentencias A>
} else {
<sentencias B>
3
El flujo de control del programa funciona de la misma manera, cuando se
ejecuta la estructura if, se evalúa la expresión condicional, si el resultado de la
condición es verdadero se ejecutan las sentencias que se encuentran
contenidas dentro del bloque de código if (<sentencias A>). Contrariamente,
se ejecutan las sentencias contenidas dentro del bloque else (<sentencias B>).
En muchas ocasiones, se anidan estructuras alternativas if-else, de forma que

se pregunte por una condición si anteriormente no se ha cumplido otra y así
sucesivamente.
if (<condicion1>) {
<sentencias A>
} else if(<condicion2>){
<sentencias B>
} else {
<sentencias C>

int num1 = 5;
int num2 = 7;
if (num1 < num2) {
System.out.println("La variable num1 aloja un número menor a la variable
num2");
}else {
System.out.println("La variable num1 aloja un número mayor a la variable
num2");
}
4
Ejercicio 6
Implementar un programa que le pida dos números enteros al usuario y
determine si ambos o alguno de ellos es mayor a 25.
5
Switch
El bloque switch evalúa qué valor tiene la variable, y de acuerdo con el valor
que posee ejecuta las sentencias del bloque case correspondiente, es decir,
del bloque case que cumpla con el valor de la variable que se está evaluando
dentro del switch.
switch(<variable>) {
case <valor1>:
<sentencias1>
break;
case <valor2>:
<sentencias2>
break;
default:
<sentencias3>
El uso de la sentencia break que va detrás de cada case termina la sentencia

switch que la envuelve, es decir que el control de flujo del programa continúa
con la primera sentencia que se encuentra a continuación del cierre del bloque
switch. Si el programa comprueba que se cumple el primer valor (valor1) se
ejecutará el bloque de instrucciones <sentencias1>, pero si no se encuentra
inmediatamente la sentencia break también se ejecutaría las instrucciones
<sentencias2>, y así sucesivamente hasta encontrarse con la palabra
reservada break o llegar al final de la estructura.
Las instrucciones dentro del bloque default se ejecutan cuando la variable que
se está evaluando no coincide con ninguno de los valores case. Esta sentencia
equivale a else de la estructura if-else.
6
Scanner leer = new Scanner(System.in);
int opcion;
System.out.println("Ingrese una opción");
opcion = leer.nextInt();
switch (opcion) {
case 1:
System.out.println("Esta línea de código se ejecuta si
opcion = 1");
break;
case 2:
System.out.println("Esta línea de código se ejecuta si
opcion = 2");
break;
default:
System.out.println("El valor ingresado en la variable
opcion es diferente" + "a todos los casos analizados por el
switch");
}
}
7
Ejercicio 7
Considera que estás desarrollando una web para una empresa que fabrica
motores (suponemos que se trata del tipo de motor de una bomba para mover
fluidos). Definir una variable tipoMotor y permitir que el usuario ingrese un valor
entre 1 y 4. El programa debe mostrar lo siguiente:
o Si el tipo de motor es 1, mostrar un mensaje indicando “La bomba es

una bomba de agua”.

una bomba de gasolina”.

una bomba de hormigón”.

una bomba de pasta alimenticia”.
o Si no se cumple ninguno de los valores anteriores mostrar el mensaje

“No existe un valor válido para tipo de bomba”
8
Estructuras repetitivas
Durante el proceso de creación de programas, es muy común encontrarse con
que una operación o conjunto de operaciones deben repetirse muchas veces.
Para ello es importante conocer las estructuras de algoritmos que permiten
repetir una o varias acciones, un número determinado de veces.
Las estructuras que repiten una secuencia de instrucciones un número

determinado de veces se denominan bucles, y se denomina iteración al hecho
de repetir la ejecución de una secuencia de acciones.
Todo bucle tiene que llevar asociada una condición, que es la que va a
determinar cuándo se repite el bucle y cuando deja de repetirse.
Sentencias de Salto
En Java existen dos formas de realizar un salto incondicional en el flujo
“normal” de un programa. A saber, las instrucciones, break y continue.
9
Break
La instrucción break sirve para abandonar una estructura de control, tanto de
las condicionales (if-else y switch) como de las repetitivas (for, do-while y
while). En el momento que se ejecuta la instrucción break, el control del
programa sale de la estructura en la que se encuentra contenida y continua
con el programa.
Continue
La sentencia continue corta la iteración en donde se encuentra el continue,
pero en lugar de salir del bucle, continúa con la siguiente iteración. La
instrucción continue transfiere el control del programa desde la instrucción
continue directamente a la cabecera del bucle (for, do-while o while) donde se
encuentra.
While
La estructura while ejecuta un bloque de instrucciones mientras se cumple una
condición. La condición se comprueba antes de empezar a ejecutar por
primera vez el bucle, por lo tanto, si la condición se evalúa a «false» en la
primera iteración, entonces el bloque de instrucciones no se ejecutará ninguna
vez.
while (<condición>) {
<sentencias>
10
String respuesta = "S";
while (respuesta.equalsIgnoreCase("S")) {
System.out.println("Desea continuar?");
respuesta = leer.nextLine();
}
}
Ejercicio 8
Escriba un programa que valide si una nota está entre 0 y 10, sino está entre 0
y 10 la nota se pedirá de nuevo hasta que la nota sea correcta.
11
Do / While
En este tipo de bucle, el bloque de instrucciones se ejecuta siempre al menos
una vez. El bloque de instrucciones se ejecutará mientras la condición se
evalúe a «true». Por lo tanto, entre las instrucciones que se repiten deberá
existir alguna que, en algún momento, haga que la condición se evalúe a
«false», de lo contrario el bucle será infinito.
do {
<sentencias>
} while (<condición>);
12
String respuesta;
do {
System.out.println("Desea continuar?");
respuesta = leer.nextLine();
} while (respuesta.equalsIgnoreCase("S"));
}
13
Ejercicio 9
Escriba un programa que lea 20 números. Si el número leído es igual a cero se
debe salir del bucle y mostrar el mensaje "Se capturó el numero cero". El
programa deberá calcular y mostrar el resultado de la suma de los números
leídos, pero si el número es negativo no debe sumarse. Nota: recordar el uso
de la sentencia break.
14
For
La estructura for proporciona una forma compacta de recorrer un rango de
valores cuando la cantidad de veces que se debe iterar un bloque de código es
conocida. La forma general de la estructura for se puede expresar del
siguiente modo:
for (<inicialización>; <terminación>; <incremento>) {
<sentencias>
La expresión <inicialización> inicializa el bucle y se ejecuta una sola vez al

iniciar el bucle. El bucle termina cuando al evaluar la expresión <terminación>
el resultado que se obtiene es false. La expresión <incremento> se invoca
después de cada iteración que realiza el bucle; esta expresión incrementa o
decrementa un valor hasta que se cumpla la condición de <terminación> del
bucle.
Como regla general puede decirse que se utilizará el bucle for cuando se
conozca de antemano el número exacto de veces que ha de repetirse un
determinado bloque de instrucciones. Se utilizará el bucle do-while cuando no
se conoce exactamente el número de veces que se ejecutará el bucle, pero se
sabe que por lo menos se ha de ejecutar una. Se utilizará el bucle while cuando
es posible que no deba ejecutarse ninguna vez.
15
for (int i = 0; i < 10; i++) {
System.out.println("Imprimo el valor de i: " + i);
System.out.println("===================================");
System.out.println("For decreciendo");
for (int i = 10; i > 10; i--) {
System.out.println("Imprimo el valor de i: " + i);
}
}
Resultado:
16
Ejercicio 10
Realizar un programa que lea 4 números (comprendidos entre 1 y 20) e imprima
el número ingresado seguido de tantos asteriscos como indique su valor. Por
ejemplo:
5 *****
3 ***
11 ***********
2 **
17
Ejercicios
ESTRUCTURAS DE CONTROL
A partir de ahora comenzaremos a aprender cómo los mismos algoritmos que
diseñamos en PSeInt podemos escribirlos también en Java, simplemente
haciendo una traducción de cada una de las estructuras de control vistas en
PSeInt a Java.
Si bien en esta guía se proponen nuevos problemas, se sugiere que los mismos
ejercicios ya implementados en PSeInt sean traducidos al lenguaje de
programación Java.

Los ejercicios van a seguir con el siguiente filtro de dificultad:
Dificultad baja Dificultad media Dificultad alta
1. Crear un programa que dado un número determine si es par o impar.
2. Crear un programa que pida una frase y si esa frase es igual a “eureka” el
programa pondrá un mensaje de Correcto, sino mostrará un mensaje de
Incorrecto. Nota: investigar la función equals() en Java.
3. Realizar un programa que solo permita introducir solo frases o palabras

de 8 de largo. Si el usuario ingresa una frase o palabra de 8 de largo se
deberá de imprimir un mensaje por pantalla que diga “CORRECTO”, en
caso contrario, se deberá imprimir “INCORRECTO”. Nota: investigar la
función Lenght() en Java.
4. Escriba un programa que pida una frase o palabra y valide si la primera

letra de esa frase es una ‘A’. Si la primera letra es una ‘A’, se deberá de
imprimir un mensaje por pantalla que diga “CORRECTO”, en caso
contrario, se deberá imprimir “INCORRECTO”. Nota: investigar la función
Substring y equals() de Java.
2
Bucles y sentencias de salto break y continue
5. Escriba un programa en el cual se ingrese un valor límite positivo, y a

continuación solicite números al usuario hasta que la suma de los
números introducidos supere el límite inicial.
6. Realizar un programa que pida dos números enteros positivos por

teclado y muestre por pantalla el siguiente menú:El usuario deberá elegir
una opción y el programa deberá mostrar el resultado por pantalla y
luego volver al menú. El programa deberá ejecutarse hasta que se elija la
opción 5. Tener en cuenta que, si el usuario selecciona la opción 5, en
vez de salir del programa directamente, se debe mostrar el siguiente
mensaje de confirmación: ¿Está seguro que desea salir del programa
(S/N)? Si el usuario selecciona el carácter ‘S’ se sale del programa, caso
contrario se vuelve a mostrar el menú.
7. Realizar un programa que simule el funcionamiento de un dispositivo

RS232, este tipo de dispositivo lee cadenas enviadas por el usuario. Las
cadenas deben llegar con un formato fijo: tienen que ser de un máximo
de 5 caracteres de largo, el primer carácter tiene que ser X y el último
tiene que ser una O.
Las secuencias leídas que respeten el formato se consideran correctas,

la secuencia especial “&&&&&” marca el final de los envíos (llamémosla
FDE), y toda secuencia distinta de FDE, que no respete el formato se
considera incorrecta.
Al finalizar el proceso, se imprime un informe indicando la cantidad de

lecturas correctas e incorrectas recibidas. Para resolver el ejercicio
deberá investigar cómo se utilizan las siguientes funciones de Java
Substring(), Length(), equals().
3
8. Dibujar un cuadrado de N elementos por lado utilizando el carácter “*”.
Por ejemplo, si el cuadrado tiene 4 elementos por lado se deberá dibujar
lo siguiente:
****
* *
* *
****
4
Estructuras de control en Java
Ejercicios Extras
Ejercicios extras
Estos ejercicios son para reforzar los conocimientos previamente vistos. Estos
pueden realizarse cuando hayas terminado con los ejercicios prácticos del día
y aún no haya finalizado el encuentro. Recuerda que no es necesario que
termines estos ejercicios extra para continuar con lo siguiente.
1. Dado un tiempo en minutos, calcular su equivalente en días y horas. Por

ejemplo, si el usuario ingresa 1600 minutos, el sistema debe calcular su
equivalente: 1 día, 2 horas.
2. Declarar cuatro variables de tipo entero A, B, C y D y asignarle un valor

diferente a cada una. A continuación, realizar las instrucciones
necesarias para que: B tome el valor de C, C tome el valor de A, A tome
el valor de D y D tome el valor de B. Mostrar los valores iniciales y los
valores finales de cada variable. Utilizar sólo una variable auxiliar.
3. Elaborar un algoritmo en el cuál se ingrese una letra y se detecte si se

trata de una vocal. Caso contrario mostrar un mensaje. Nota: investigar
la función equals() de la clase String.
4. Elaborar un algoritmo en el cuál se ingrese un número entre 1 y 10 y se

muestre su equivalente en romano.
5. Una obra social tiene tres clases de socios:
○ Los socios tipo ‘A’ abonan una cuota mayor, pero tienen un 50% de
descuento en todos los tipos de tratamientos.
○ Los socios tipo ‘B’ abonan una cuota moderada y tienen un 35% de
descuento para los mismos tratamientos que los socios del tipo A.
○ Los socios que menos aportan, los de tipo ‘C’, no reciben
descuentos sobre dichos tratamientos.
○ Solicite una letra (carácter) que representa la clase de un socio, y
luego un valor real que represente el costo del tratamiento (previo
al descuento) y determine el importe en efectivo a pagar por dicho
socio.
2
6. Leer la altura de N personas y determinar el promedio de estaturas que
se encuentran por debajo de 1.60 mts. y el promedio de estaturas en
general.
7. Realice un programa que calcule y visualice el valor máximo, el valor

mínimo y el promedio de n números (n>0). El valor de n se solicitará al
principio del programa y los números serán introducidos por el usuario.
Realice dos versiones del programa, una usando el bucle “while” y otra
con el bucle “do - while”.
8. Escriba un programa que lea números enteros. Si el número es múltiplo

de cinco debe detener la lectura y mostrar la cantidad de números
leídos, la cantidad de números pares y la cantidad de números impares.
Al igual que en el ejercicio anterior los números negativos no deben
sumarse. Nota: recordar el uso de la sentencia break.
9. Simular la división usando solamente restas. Dados dos números enteros

mayores que uno, realizar un algoritmo que calcule el cociente y el
residuo usando sólo restas. Método: Restar el dividendo del divisor hasta
obtener un resultado menor que el divisor, este resultado es el residuo, y
el número de restas realizadas es el cociente.
Por ejemplo: 50 / 13:
50 – 13 = 37 una resta realizada
37 – 13 = 24 dos restas realizadas
24 – 13 = 11 tres restas realizadas
dado que 11 es menor que 13, entonces: el residuo es 11 y el cociente es

3.
¿Aún no lo entendiste? Recomendamos googlear división con restas

sucesivas.
10. Realice un programa para que el usuario adivine el resultado de una

multiplicación entre dos números generados aleatoriamente entre 0 y 10.
El programa debe indicar al usuario si su respuesta es o no correcta. En
caso que la respuesta sea incorrecta se debe permitir al usuario ingresar
su respuesta nuevamente. Para realizar este ejercicio investigue como
utilizar la función Math.random() de Java.
3
11. Escribir un programa que lea un número entero y devuelva el número de
dígitos que componen ese número. Por ejemplo, si introducimos el
número 12345, el programa deberá devolver 5. Calcular la cantidad de
dígitos matemáticamente utilizando el operador de división. Nota:
recordar que las variables de tipo entero truncan los números o
resultados.
12. Necesitamos mostrar un contador con 3 dígitos (X-X-X), que muestre los
números del 0-0-0 al 9-9-9, con la particularidad que cada vez que
aparezca un 3 lo sustituya por una E. Ejemplo:
0-0-0
0-0-1
0-0-2
0-0-E
0-0-4
0-1-2
0-1-E
Nota: investigar función equals() y como convertir números a String.
13. Crear un programa que dibuje una escalera de números, donde cada
línea de números comience en uno y termine en el número de la línea.
Solicitar la altura de la escalera al usuario al comenzar. Ejemplo: si se
ingresa el número 3:
1
12
123
14. Se dispone de un conjunto de N familias, cada una de las cuales tiene

una M cantidad de hijos. Escriba un programa que pida la cantidad de
familias y para cada familia la cantidad de hijos para averiguar la media
de edad de los hijos de todas las familias.
4
Subprogramas
Material de
lectura
● Definir y utilizar funciones, manejo de retornos

● Definir y utilizar de procedimientos
● Realizar llamados de funciones y procedimientos
Subprogramas
Un método muy útil para solucionar un problema complejo es dividirlo en
subproblemas —problemas más sencillos— y a continuación dividir estos
subproblemas en otros más simples, hasta que los problemas más pequeños
sean fáciles de resolver. Esta técnica de dividir el problema principal en
subproblemas se suele denominar “divide y vencerás”.
El problema principal se soluciona por el correspondiente programa o algoritmo

principal, mientras que la solución de los subproblemas será a través de
subprogramas, conocidos como procedimientos o funciones. Un subprograma
es un como un mini algoritmo, que recibe los datos, necesarios para realizar
una tarea, desde el programa y devuelve los resultados de esa tarea.
Funciones
Las funciones o métodos son un conjunto de líneas de código (instrucciones),
encapsulados en un bloque, usualmente según los parámetros definidos en la
función, esta recibe argumentos, cuyos valores se utilizan para efectuar
operaciones y adicionalmente retornan un valor. En otras palabras, una función
según sus parámetros puede recibir argumentos (algunas no reciben nada),
hace uso de dichos valores recibidos como sea necesario y retorna un valor
usando la instrucción return, si no retorna es otro tipo de función. Los tipos que
pueden usarse en la función son: int, doble, long, boolean, String y char.
A estas funciones les vamos a asignar un tipo de acceso y un modificador.

Estos dos conceptos los vamos a ver mejor más adelante, pero por ahora
siempre vamos a crear las funciones con el acceso public y el modificador
static. Para saber más sobre estos dos temas, leer la explicación del método
main.
[acceso][modificador][tipo] nombreFuncion([tipo] nombreArgumento, …….){
/*
* Bloque de instrucciones
*/
return valor;
2
Consejos acerca de return:
· Cualquier instrucción que se encuentre después de la ejecución de

return NO será ejecutada. Es común encontrar funciones con
múltiples sentencias return al interior de condicionales, pero una vez
que el código ejecuta una sentencia return lo que haya de allí hacia
abajo no se ejecutará.
· El tipo de valor que se retorna en una función debe coincidir con el

del tipo declarado a la función, es decir si se declara int, el valor
retornado debe ser un número entero.

int num1 = 5;
int num2 = 7;
//Puedo invocar el retorno de esta funcion de esta manera

System.out.println("La suma de ambos es: " + sumar(num1,
num2));
int retorno = sumar(num1, num2);
System.out.println("La suma de ambos es: " + retorno);

}
// Pero, recomendamos hacerlo de esta manera, ya que los

retornos deben alojarse en variables para su posterior uso
public static int sumar(int num1, int num2) {

int suma;
suma = num1 + num2;
return suma;
}
3
Ejercicio 11
Escribir un programa que procese una secuencia de caracteres ingresada por
teclado y terminada en punto, y luego codifique la palabra o frase ingresada de
la siguiente manera: cada vocal se reemplaza por el carácter que se indica en
la tabla y el resto de los caracteres (incluyendo a las vocales acentuadas) se
mantienen sin cambios.
a e i o u
@ # $ % *
Realice un subprograma que reciba una secuencia de caracteres y retorne la

codificación correspondiente. Utilice la estructura “según” para la
transformación.
Por ejemplo, si el usuario ingresa: Ayer, lunes, salimos a las once y 10.
La salida del programa debería ser: @y#r, l*n#s, s@l$m%s @ l@s %nc# y 10.
4
Procedimientos (Funciones sin retorno)
Los procedimientos son básicamente un conjunto de instrucciones que se
ejecutan sin retornar ningún valor, hay quienes dicen que un procedimiento no
recibe valores o argumentos, sin embargo, en la definición no hay nada que se
lo impida. En el contexto de Java un procedimiento es básicamente una función
cuyo tipo de retorno es void, los que indica que devuelven ningún resultado.
[acceso][modificador] void nombreFuncion([tipo] nombreArgumento){
/*
* Bloque de instrucciones
*/
5
Acerca de los argumentos o parámetros:
· Hay algunos detalles respecto a los argumentos de un método,

veamos:
· Una función, un método o un procedimiento pueden tener una

cantidad infinita de parámetros, es decir pueden tener cero, uno, tres,
diez, cien o más parámetros. Aunque habitualmente no suelen tener
más de 4 o 5.
· Si una función tiene más de un parámetro cada uno de ellos debe ir

separado por una coma.
· Los argumentos de una función también tienen un tipo y un nombre

que los identifica. El tipo del argumento puede ser cualquiera y no
tiene relación con el tipo del método.
· Al recibir un argumento nada nos obliga a hacer uso de éste al

interior del método, sin embargo, para que recibirlo si no lo vamos a
usar.
· En java los argumentos que sean variables de tipos primitivos (int,

double, char, etc.) se van a pasar por valor, mientras que los objetos
(String, Integer, etc.) y los arreglos se van a pasar por referencia.
Nota: el concepto de objetos lo vamos a ver más adelante.
6
String nombre = "Mariano";
int edad = 29;
mostrarInfo(nombre, edad);
}
public static void mostrarInfo(String nombre, int edad) {
System.out.println("El nombre del usuario es: " + nombre + "y

su edad:" + edad);
Ejercicio 12
Crea un procedimiento EsMultiplo que reciba los dos números pasados por el
usuario, validando que el primer número múltiplo del segundo e imprima si el
primer número es múltiplo del segundo, sino informe que no lo son.
7
8
Subprogramas
Ejercicios
Continuamos con los ejercicios de aprendizaje y practicamos sobre los
subprogramas en Java

1. Crea una aplicación que le pida dos números al usuario y este pueda
elegir entre sumar, restar, multiplicar y dividir. La aplicación debe tener
una función para cada operación matemática y deben devolver sus
resultados para imprimirlos en el main.
2. Diseñe una función que pida el nombre y la edad de N personas e

imprima los datos de las personas ingresadas por teclado e indique si
son mayores o menores de edad. Después de cada persona, el programa
debe preguntarle al usuario si quiere seguir mostrando personas y frenar
cuando el usuario ingrese la palabra “No”.
3. Crea una aplicación que a través de una función nos convierta una
cantidad de euros introducida por teclado a otra moneda, estas pueden
ser a dólares, yenes o libras. La función tendrá como parámetros, la
cantidad de euros y la moneda a convertir que será una cadena, este no
devolverá ningún valor y mostrará un mensaje indicando el cambio
(void).
El cambio de divisas es:
i. * 0.86 libras es un 1 €
ii. * 1.28611 $ es un 1 €
iii. * 129.852 yenes es un 1 €
4. Crea una aplicación que nos pida un número por teclado y con una
función se lo pasamos por parámetro para que nos indique si es o no un
número primo, debe devolver true si es primo, sino false.
Un número primo es aquel que solo puede dividirse entre 1 y sí mismo.

Por ejemplo: 25 no es primo, ya que 25 es divisible entre 5, sin embargo,
17 si es primo.
2
¿Qué son los números primos?
Básicamente, un número primo es un número natural que tiene solo dos

divisores o factores: 1 y el mismo número. Es decir, es primo aquel
número que se puede dividir por uno y por el mismo número.
El primer número primo es 2, y hay 25 números primos entre 1 y 100,

ellos son: 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67,
71, 73, 79, 83, 89 y 97.
3
Arreglos y vectores
Material de
lectura
● Definir de vectores y matrices

● Llenar de vectores y matrices
● Mostrar vectores y matrices
Arreglos: vectores y matrices
Un arreglo es un contenedor de objetos que tiene un número fijo de valores del
mismo tipo. El tamaño del arreglo es establecido cuando el arreglo es creado y
luego de su creación su tamaño es fijo, esto significa que no puede cambiar.
Cada una de los espacios de un arreglo es llamada elemento y cada elemento
puede ser accedido por un índice numérico que arranca desde 0 hasta el
tamaño menos uno. Por ejemplo, si tenemos un vector de 5 elementos los
índices serían: 0-1-2-3-4.
Al igual que la declaración de otros tipos de variables, la declaración de un

arreglo tiene dos componentes: el tipo de dato del arreglo y su nombre. El tipo
de dato del arreglo se escribe como tipo[], en donde, tipo es el tipo de dato de
cada elemento contenido en él. Los corchetes sirven para indicar que esa
variable va a ser un arreglo. El tamaño del arreglo no es parte de su tipo (es por
esto que los corchetes están vacíos).
Una vez declarado un arreglo hay que crearlo/dimensionarlo, es decir, hay que
asignar al arreglo un tamaño para almacenar los valores. La creación de un
arreglo se hace con el operador new. Recordemos que las matrices son
bidimensionales por lo que tienen dos tamaños, uno para las filas y otro para
las columnas de la matriz.
Declaración y creación de un Vector
tipo[] arregloV = new tipo[Tamaño];
Declaración y creación de una Matriz
tipo[][] arregloM = new tipo[Filas][Columnas];
2
// Creo un arreglo llamado vector con dimensión 5 que

// solo pueda alojar números enteros
int[] vector = new int[5];
// Creo una matriz con dimensión 3x3 que

// solo pueda alojar cadenas
String[][] matriz = new String[3][3];
Ejercicio 13
Crea un vector llamado ‘Equipo’ cuya dimensión sea la cantidad de compañeros
de equipo y define su tipo de dato de tal manera que te permita alojar sus
nombres más adelante.
3
Asignar elementos a un arreglo
Cuando queremos ingresar un elemento en nuestro arreglo vamos a tener que
elegir el subíndice en el que lo queremos guardar. Una vez que tenemos el
subíndice decidido tenemos que invocar nuestro vector por su nombre y entre
corchetes el subíndice en el que lo queremos guardar.
Después, pondremos el signo de igual (que es el operador de asignación)

seguido del elemento a guardar. En las matrices vamos a necesitar dos
subíndices y dos corchetes para representar la posición de la fila y la columna
donde queremos guardar el elemento.
Asignación de un Vector
vector[0] = 5;
Asignación de una Matriz
matriz[0][0] = 6;
Esta forma de asignación implica asignar todos los valores de nuestro arreglo
de uno en uno, esto va a conllevar un trabajo bastante grande dependiendo del
tamaño de nuestro arreglo.
Entonces, para poder asignar varios valores a nuestro arreglo y no hacerlo de

uno en uno usamos un bucle Para. El bucle Para, al poder asignarle un valor
inicial y un valor final a una variable, podemos adaptarlo fácilmente a nuestros
arreglos. Ya que, pondremos el valor inicial de nuestro arreglo y su valor final
en las respectivas partes del Para. Nosotros usamos la variable creada en el
Para, y la pasaríamos a nuestro arreglo para representar todos los subíndices
del arreglo, de esa manera, recorriendo todas las posiciones y asignándole a
cada posición un elemento.
Para poder asignar varios elementos a nuestra matriz, usamos dos bucles Para
anidados., ya que un Para recorrerá las filas (variable i) y otro las columnas
(variable j).
Asignación de un Vector
for (int i = 0; i < 5; i++) {
vector[i] = 5;
4
Asignación de una Matriz
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
matriz[i][j] = 6;
Vector:
int vector[] = new int[5]; // Le ponemos la dimension al

vector
// Puedo asignar valores de esta manera

vector[0] = 3;
// Asigno valores mediante el for

for (int i = 0; i < 5; i++) {
vector[i] = i + 3;
// Muestro el vector
for (int i = 0; i < 5; i++) {
System.out.println("[" + vector[i] + "]");
}
5
Matriz:
String[] [] matriz = new String [3] [3];
// Puedo asignar valores de esta manera

matriz[0][0] = "A";
// Asigno valores mediante el For

for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
matriz[i][j] = "A";
}
}
// Muestro la matriz
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
System.out.print("[" + matriz[i][j] + "]");
}
System.out.println("");
}
6
Ejercicio 14
Utilizando un Bucle for, aloja en el vector Equipo, los nombres de tus
compañeros de equipo
Vectores y matrices en subprogramas

Los arreglos se pueden pasar como parámetros a un subprograma (función o
procedimiento) del mismo modo que pasamos variables, poniendo el tipo de
dato delante del nombre del vector o matriz, pero deberemos sumarle las llaves
para representar que es un vector o matriz. Sin embargo, hay que tener en
cuenta que la diferencia entre los arreglos y las variables, es que los arreglos
siempre se pasan por referencia.
public static void llenarVector(int[] vector){
public static void mostrarMatriz(int[][] matriz){
7
A diferencia de Pseint, en Java si podemos devolver un vector o una matriz en
una función para usarla en otro momento. Lo que hacemos es poner como tipo
de dato de la función, el tipo de dato que tendra el vector y asi poder
devolverlo.
public static int devolverVector(){
int[] vector = new int[5];
return vector;
8
Arreglos
Ejercicios
Continuamos con los ejercicios de aprendizaje y practicamos sobre los arreglos
en Java.

1. Realizar un algoritmo que llene un vector con los 100 primeros números
enteros y los muestre por pantalla en orden descendente.
2. Realizar un algoritmo que llene un vector de tamaño N con valores

aleatorios y le pida al usuario un número a buscar en el vector. El
programa mostrará dónde se encuentra el numero y si se encuentra
repetido
3. Recorrer un vector de N enteros contabilizando cuántos números son de

1 dígito, cuántos de 2 dígitos, etcétera (hasta 5 dígitos).
4. Realizar un programa que rellene un matriz de 4 x 4 de valores aleatorios

y muestre la traspuesta de la matriz. La matriz traspuesta de una matriz
A se denota por B y se obtiene cambiando sus filas por columnas (o
viceversa).
2
5. Realice un programa que compruebe si una matriz dada es antisimétrica.
Se dice que una matriz A es antisimétrica cuando ésta es igual a su
propia traspuesta, pero cambiada de signo. Es decir, A es antisimétrica si
A = -AT. La matriz traspuesta de una matriz A se denota por AT y se
obtiene cambiando sus filas por columnas (o viceversa).
En este caso la matriz es antisimétrica.
6. Un cuadrado mágico 3 x 3 es una matriz 3 x 3 formada por números del

1 al 9 donde la suma de sus filas, sus columnas y sus diagonales son
idénticas. Crear un programa que permita introducir un cuadrado por
teclado y determine si este cuadrado es mágico o no. El programa
deberá comprobar que los números introducidos son correctos, es decir,
están entre el 1 y el 9.
3
Arreglos
Ejercicios
extras
Ejercicios extras
Estos ejercicios son para reforzar los conocimientos previamente vistos. Estos
pueden realizarse cuando hayas terminado con los ejercicios prácticos del día
y aún no haya finalizado el encuentro. Recuerda que no es necesario que
termines estos ejercicios extra para continuar con lo siguiente.
1. Realizar un algoritmo que calcule la suma de todos los elementos de un

vector de tamaño N, con los valores ingresados por el usuario.
2. Escriba un programa que averigüe si dos vectores de N enteros son

iguales (la comparación deberá detenerse en cuanto se detecte alguna
diferencia entre los elementos).
3. Crear una función rellene un vector con números aleatorios, pasándole

un arreglo por parámetro. Después haremos otra función o
procedimiento que imprima el vector.
4. Los profesores del curso de programación de Egg necesitan llevar un

registro de las notas adquiridas por sus 10 alumnos para luego obtener
una cantidad de aprobados y desaprobados. Durante el período de
cursado cada alumno obtiene 4 notas, 2 por trabajos prácticos
evaluativos y 2 por parciales. Las ponderaciones de cada nota son:
Primer trabajo práctico evaluativo 10%
Segundo trabajo práctico evaluativo 15%
Primer Integrador 25%
Segundo integrador 50%
Una vez cargadas las notas, se calcula el promedio y se guarda en el

arreglo. Al final del programa los profesores necesitan obtener por
pantalla la cantidad de aprobados y desaprobados, teniendo en cuenta
que solo aprueban los alumnos con promedio mayor o igual al 7 de sus
notas del curso.
5. Realizar un programa que llene una matriz de tamaño NxM con valores
aleatorios y muestre la suma de sus elementos.
2
6. Construya un programa que lea 5 palabras de mínimo 3 y hasta 5
caracteres y, a medida que el usuario las va ingresando, construya una
“sopa de letras para niños” de tamaño de 20 x 20 caracteres. Las
palabras se ubicarán todas en orden horizontal en una fila que será
seleccionada de manera aleatoria. Una vez concluida la ubicación de las
palabras, rellene los espacios no utilizados con un número aleatorio del 0
al 9. Finalmente imprima por pantalla la sopa de letras creada.
Nota: Para resolver el ejercicio deberá investigar cómo se utilizan las

siguientes funciones de Java substring(), Length() y Math.random().
7. Realizar un programa que complete un vector con los N primeros

números de la sucesión de Fibonacci. Recordar que la sucesión de
Fibonacci es la sucesión de los siguientes números:
1, 1, 2, 3, 5, 8, 13, 21, 34, ...
Donde cada uno de los números se calcula sumando los dos anteriores a
él. Por ejemplo:
La sucesión del número 2 se calcula sumando (1+1)
Análogamente, la sucesión del número 3 es (1+2),
Y la del 5 es (2+3),
Y así sucesivamente…
La sucesión de Fibonacci se puede formalizar de acuerdo a la siguiente

fórmula:
Fibonaccin = Fibonaccin-1 + Fibonaccin-2 para todo n>1
Fibonaccin = 1 para todo n<=1
Por lo tanto, si queremos calcular el término “n” debemos escribir una

función que reciba como parámetro el valor de “n” y que calcule la serie
hasta llegar a ese valor.
Para conocer más acerca de la serie de Fibonacci consultar el siguiente

link: https://quantdare.com/numeros-de-fibonacci/
3
Programación Orientada a Objetos
Material de lectura
INTRODUCCIÓN A OBJETOS
● Comprender el paradigma orientado a objetos

● Crear clases
● Definir atributos de clases
¿Que es un paradigma de programación?
Un paradigma de programación es una manera o estilo de programación.
Existen diferentes formas de diseñar un programa y varios modos de trabajar
para obtener los resultados que necesitan los programadores. Por lo que un
paradigma de programación se trata de un conjunto de métodos sistemáticos
aplicables en todos los niveles del diseño de programas para resolver
problemas.
¿Qué es la programación orientada a objetos?

Antes de sumergirnos en el concepto hagamos una revisión de cómo
evolucionó nuestra manera de pensar y alojar información en la programación.
En un primer momento, aprendimos las variables. Dijimos que las variables eran
como cajones donde podíamos guardar sólo un dato de cierto tipo. Luego
estudiamos los arrays, que nos permitían alojar varios datos a la vez, como si
fuera un cajón con compartimentos; siempre y cuando estos datos fueran del
mismo tipo. La programación orientada a objetos nos trae una nueva forma de
almacenar información: OBJETOS. Pensaremos los objetos como un fichero o
cajonera. Iremos profundizando este ejemplo a medida que avancemos en esta
guía.
2
La Programación Orientada a Objetos (POO) es un paradigma de
programación, es decir, un modelo o un estilo de programación que se basa en
el concepto de clases y objetos. Este tipo de programación se utiliza para
estructurar un programa de software en piezas simples y reutilizables de
código (clases) para crear instancias individuales de objetos.
Con el paradigma de Programación Orientado a Objetos lo que buscamos es

dejar de centrarnos en la lógica pura de los programas, para empezar a pensar
en objetos, lo que constituye la base de este paradigma.
La programación orientada a objetos se enfoca en los objetos, sus atributos y

las interacciones que se producen entre ellos para diseñar programas.
Un programa orientado a objetos es, esencialmente, un conjunto de objetos

que se crean para que interaccionen entre sí y dejan de existir cuando ya no
son útiles durante la ejecución de un programa. Un programa puede llegar a ser
muy complejo. La complejidad es más manejable cuando se descompone y se
organiza en partes pequeñas y simples, los objetos.
¿Por qué POO?

La Programación Orientada a objetos permite que el código sea reutilizable,
organizado y fácil de mantener. Sigue el principio de desarrollo de software
utilizado por muchos programadores DRY (Don’t Repeat Yourself), para evitar
duplicar el código y crear de esta manera programas eficientes. Además, evita
el acceso no deseado a los datos o la exposición de código propietario
mediante la encapsulación y la abstracción, de la que hablaremos en detalle
más adelante.
3
Pero entonces, ¿Qué es un objeto?
Un objeto en la programación es la forma que tenemos de llevar a código, la
representación más fidedigna posible de un objeto de la vida real. Un objeto
tendrá características (atributos) que son comunes a todos ellos, pero pueden
variar entre sí.
Volvamos al ejemplo del fichero o cajonera. El objeto es la cajonera, cada cajón

representará un atributo. Una vez creado el molde para crear este objeto
cajonera, cada uno de sus cajones alojará un tipo de dato que será el mismo
tipo pero la información que se aloje dentro será diferente. En el primer cajón
debemos guardar remeras, pero estas pueden ser rojas en una cajonera o
verdes en otra.
Pensemos también a las personas como objetos. Tenemos ciertas

características que son uniformes a todos. Todos tenemos un nombre, un
número de identificación, una fecha de nacimiento. Estas características
variarían de una persona a otra, pero al compartir esta información podemos
elaborar código que represente y nos permita identificar a una o varias
personas.
4
¿Cómo creamos objetos?
Para llevar cierto orden, por cada uno de los ejercicios de esta guía crearemos
un nuevo proyecto en NetBeans.
Primero crearemos el proyecto:
5
Luego, necesitamos crear una clase. Una clase es un molde para crear
múltiples objetos que encapsula datos y comportamiento. Una clase es una
combinación específica de atributos y métodos y puede considerarse un tipo
de dato de cualquier tipo no primitivo.
Las clases deberán guardarse en un paquete llamado Entidad:
6
7
Así, una clase es una especie de plantilla o prototipo de objetos: define los
atributos que componen ese tipo de objetos y los métodos que pueden
emplearse para trabajar con esos objetos. En su forma más simple, una clase
se define por la palabra reservada class seguida del nombre de la clase. El
nombre de la clase debe empezar por mayúscula.
8
Si el nombre es compuesto, entonces cada palabra debe empezar por
mayúscula. La definición de la clase se pone entre las llaves de apertura y
cierre.
public class NombreClase {
// atributos
// constructores
// métodos propios
Ejercicio persona
Es tu turno, crea tu propio proyecto con la clase Persona.
Estado y Comportamiento
En términos más generales, un objeto es una abstracción conceptual del
mundo real que se puede traducir a un lenguaje de programación orientado a
objetos. Los objetos del mundo real comparten dos características: Todos
poseen estado y comportamiento. Por ejemplo, el perro tiene estado (color,
nombre, raza, edad) y el comportamiento (ladrar, caminar, comer, acostarse,
mover la cola). Por lo tanto, un estado permite informar cuáles son las
características del objeto y lo que este representa, y el comportamiento,
consiste en decir lo que sabe hacer.
El estado de un objeto es una lista de variables conocidas como sus

atributos, cuyos valores representan el estado que caracteriza al objeto.
El comportamiento es una lista de métodos, procedimientos, funciones u

operaciones que un objeto puede ejecutar a solicitud de otros objetos. Los
objetos también se conocen como instancias.
9
Elementos de una Clase
Una clase describe un tipo de objetos con características comunes. Es
necesario definir la información que almacena el objeto y su comportamiento.
1. ¿Qué son los atributos?

Los atributos son características comunes a todos los objetos. Son los
“espacios” donde alojaremos información que cambiará en cada objeto pero
que corresponda a una descripción del mismo. Son los “cajones” de la
cajonera.
El estado o información de un objeto se almacena en atributos. Los atributos

pueden ser de tipos primitivos de Java (descriptos en la guía Intro Java) o del
tipo de otros objetos. La declaración de un atributo de un objeto tiene la
siguiente forma:
<modificador>* <tipo> <nombre>
· <modificador>: si bien hay varios valores posibles para el

<modificador>, por el momento solo usaremos modificadores de
visibilidad: public, protected, private.
· <tipo>: indica la clase a la que pertenece el atributo definido.
· <nombre>: puede ser cualquier identificador válido y denomina el

atributo que está siendo declarado.
public class Persona{

public String nombre;
}
Estos atributos irán al principio de la clase.
10
Ejercicio persona – atributos
Seguiremos trabajando sobre la clase Persona que creamos y ahora deberás
sumarle 3 atributos que creas pertinentes.
2. ¿Qué son los constructores?

Los constructores con métodos propios del objeto que nos permiten CREARLO.
A la creación de un objeto se le denomina INSTANCIACIÓN.
Además de definir los atributos de un objeto, es necesario definir los métodos

que determinan su comportamiento. Toda clase debe definir un método
especial denominado constructor para instanciar los objetos de la clase. Este
método tiene el mismo nombre de la clase. La declaración básica toma la
siguiente forma:
[<modificador>] <nombre de clase> ( <argumento>* ) {
<sentencia>*
● <nombre de clase>: El nombre del constructor debe ser siempre el

mismo que el de la clase.
● <modificador>: Actualmente, los únicos modificadores válidos para los

constructores son public, protected y private.
● <argumentos>: es una lista de parámetros que tiene la misma función

que en los métodos.
11
Este es un constructor por defecto
Éste es un constructor con parámetros
El método constructor se ejecuta cada vez que se instancia un objeto de la

clase. Este método se utiliza para inicializar los atributos del objeto que se
instancia.
Para diferenciar entre los atributos del objeto y los identificadores de los
parámetros del método constructor, se utiliza la palabra this. De esta forma, los
parámetros del método pueden tener el mismo nombre que los atributos de la
clase.
La instanciación de un objeto consiste en asignar un espacio de memoria al

que se hace referencia con el nombre del objeto. Los identificadores de los
objetos permiten acceder a los valores almacenados en cada objeto.
12
El constructor por defecto
Cada clase tiene al menos un constructor. Si no se escribe un constructor, el
lenguaje de programación Java le provee uno por defecto. Este constructor no
posee argumentos y tiene un cuerpo vacío. Si se define un constructor que no
sea vacío, el constructor por defecto se pierde, salvo que creemos un nuevo
constructor vacío.
Una vez que se ha declarado una clase, se pueden crear objetos a partir de
ella. A la creación de un objeto se le denomina instanciación. Por esta razón
que se dice que un objeto es una instancia de una clase y el término instancia y
objeto se utilizan indistintamente. Para crear objetos, basta con declarar una
variable de alguno de los tipos de las clases definidas.
NombreClase nombreObjeto;
Para crear el objeto y asignar un espacio de memoria es necesario realizar la

instanciación con el operador new. El operador new instancia el objeto y
reserva espacio en memoria para los atributos y devuelve una referencia que
se guarda en la variable.
nombreObjeto = new nombreClase();
Tanto la declaración de un objeto como la asignación del espacio de memoria

se pueden realizar en un solo paso:NombreClase nombreObjeto = new
NombreClase();
A partir de este momento los objetos ya pueden ser referenciados por su

nombre.
13
Instanciamos dos objetos en el main del tipo Persona
14
¿Cómo se crean los constructores?
Dentro de la clase, para agregar automáticamente los constructores podemos
presionar el botón derecho > Insert Code > Constructor y podemos no
seleccionar ningún atributo o seleccionar todos los atributos.
Ejercicio persona – constructores

Volveremos a usar la clase Persona y vamos a crear objetos en tu Main
utilizando los constructores.
15
Abstracción y Encapsulamiento
La abstracción es la habilidad de ignorar los detalles de las partes para enfocar
la atención en un nivel más alto de un problema. El encapsulamiento sucede
cuando algo es envuelto en una capa protectora. Cuando el encapsulamiento
se aplica a los objetos, significa que los datos del objeto están protegidos,
“ocultos” dentro del objeto. Con los datos ocultos, ¿cómo puede el resto del
programa acceder a ellos? (El acceso a los datos de un objeto se refiere a
leerlos o modificarlos.) El resto del programa no puede acceder de manera
directa a los datos de un objeto; lo tiene que hacer con ayuda de los métodos
del objeto. Al hecho de proteger los datos o atributos con los métodos se
denomina encapsulamiento.
Abstracción
La abstracción es la propiedad que considera los aspectos más significativos o
notables de un problema y expresa una solución en esos términos. La
abstracción posee diversos grados o niveles de abstracción, los cuales ayudan
a estructurar la complejidad intrínseca que poseen los sistemas del mundo real.
La abstracción encarada desde el punto de vista de la programación orientada
a objetos es el mecanismo por el cual se proveen los límites conceptuales de
los objetos y se expresan sus características esenciales, dejando de lado sus
características no esenciales. Si un objeto tiene más características de las
necesarias los mismos resultan difíciles de usar, modificar, construir y
comprender. En el análisis hay que concentrarse en ¿Qué hace? y no en ¿Cómo
lo hace?
Encapsulamiento
La encapsulación o encapsulamiento significa reunir en una cierta estructura a
todos los elementos que a un cierto nivel de abstracción se pueden considerar
pertenecientes a una misma entidad, y es el proceso de agrupamiento de
datos y operaciones relacionadas bajo una misma unidad de programación, lo
que permite aumentar la cohesión de los componentes del sistema.
El encapsulamiento oculta lo que hace un objeto de lo que hacen otros objetos

y del mundo exterior por lo que se denomina también ocultación de datos. Un
objeto tiene que presentar “una cara” al mundo exterior de modo que se
puedan iniciar sus operaciones.
16
Los métodos operan sobre el estado interno de un objeto y sirven como el
mecanismo primario de comunicación entre objetos. Ocultar el estado interno y
hacer que toda interacción sea a través de los métodos del objeto es un
mecanismo conocido como encapsulación de datos.
Modificadores de Acceso
Para lograr el uso correcto del encapsulamiento vamos a utilizar los
modificadores de acceso, estos, van a dejarnos elegir como se accede a los
datos y a través de que se accede a dichos datos. Todas las clases poseen
diferentes niveles de acceso en función del modificador de acceso (visibilidad).
A continuación, se detallan los niveles de acceso con sus símbolos
correspondientes:
· Public: Este modificador permite acceder a los elementos desde

cualquier clase, independientemente de que esta pertenezca o no al
paquete en que se encuentra el elemento.
· Private: Es el modificador más restrictivo y especifica que los

elementos que lo utilizan sólo pueden ser accedidos desde la clase
en la que se encuentran. Este modificador sólo puede utilizarse
sobre los atributos de una clase y sobre interfaces y clases internas,
no sobre clases o interfaces de primer nivel, dado que esto no tendría
sentido. Es importante destacar también que el modificador private
convierte los elementos en privados para otras clases, no para otras
instancias de la clase. Es decir, un objeto de una determinada clase
puede acceder a los atributos privados de otro objeto de la misma
clase.
· Protected: Este modificador indica que los elementos sólo pueden

ser accedidos desde su mismo paquete y desde cualquier clase
que extienda la clase en que se encuentra, independientemente de si
esta se encuentra en el mismo paquete o no. Este modificador, como
private, no tiene sentido a nivel de clases o interfaces no internas.
Si no especificamos ningún modificador de acceso se utiliza el nivel de acceso

por defecto (Default), que consiste en que el elemento puede ser accedido
sólo desde las clases que pertenezcan al mismo paquete. Los distintos
modificadores de acceso quedan resumidos en la siguiente tabla:
17
Visibilidad Public Private Protected Default
Desde la misma SI SI SI SI
Clase
Desde cualquier SI NO SI SI
Clase del mismo
Paquete
Desde una Subclase SI NO SI SI

del mismo Paquete
Desde una Subclase SI NO SI, a NO

fuera del mismo través de
Paquete la
herencia
Desde cualquier SI NO NO NO
Clase fuera del
Paquete
18
Métodos propios
Los métodos son funciones que determinan el comportamiento de los objetos.
Un objeto se comporta de una u otra forma dependiendo de los métodos de la
clase a la que pertenece. Todos los objetos de una misma clase tienen los
mismos métodos y el mismo comportamiento. Para definir los métodos, el
lenguaje de programación Java toma la siguiente forma básica:
<modificador>* <tipo de retorno> <nombre> ( <argumento>>* ) {
<sentencias>*
return valorRetorno;
● <modificador>: el segmento es opcional y puede contener varios

modificadores diferentes incluyendo a public, protected y private.
Aunque no está limitado a estos.
● <tipo de retorno>: el tipo de retorno indica el tipo de valor devuelto por

el método. Si el método no devuelve un valor, debe ser declarado void.
La tecnología Java es rigurosa acerca de los valores de retorno. Si el tipo
de retorno en la declaración del método es un int, por ejemplo, el método
debe devolver un valor int desde todos los posibles caminos de retorno
(y puede ser invocado solamente en contextos que esperan un int para
ser devuelto). Se usa la sentencia return dentro de un método para
devolver un valor.
● <nombre>: puede ser cualquier identificador válido, con algunas

restricciones basadas en los nombres que ya están en uso.
● <argumento>: permite que los valores de los argumentos sean pasados

hacia el método. Los elementos de la lista están separados por comas y
cada elemento consiste en un tipo y un identificador.
Existen tres tipos de métodos: métodos de consulta, métodos modificadores y

operaciones. Los métodos de consulta sirven para extraer información de los
objetos, los métodos modificadores sirven para modificar el valor de los
atributos del objeto y las operaciones definen el comportamiento de un objeto.
19
Getter & Setter
Para acceder a los atributos de un objeto se definen los métodos get y set. Los
métodos get se utilizan para consultar el estado de un objeto y los métodos
set para modificar su estado. Un método get se declara public y a
continuación se indica el tipo de dato que devuelve. Es un método de consulta.
La lista de parámetros de un método get queda vacía. En el cuerpo del método
se utiliza return para devolver el valor correspondiente al atributo que se quiere
devolver, y al cual se hace referencia como this.nombreAtributo.
Por otra parte, un método set se declara public y devuelve void. La lista de
parámetros de un método set incluye el tipo y el valor a modificar. Es un
método modificador. El cuerpo de un método set asigna al atributo del objeto el
parámetro de la declaración.
¿Cómo se crean los getter y setter?

Dentro de la clase, para agregar automáticamente los getter & setter podemos
presionar el botón derecho > Insert Code > Getter & Setter y selecciono todos
los atributos.
20
¿Cómo utilizamos estos métodos?
Un método se puede invocar dentro o fuera de la clase donde se ha declarado.
Si el método se invoca dentro de la clase, basta con indicar su nombre. Si el
método se invoca fuera de la clase entonces se debe indicar el nombre del
objeto y el nombre del método. Cuando se invoca a un método ocurre lo
siguiente:
● En la línea de código del programa donde se invoca al método se

calculan los valores de los argumentos.
● Los parámetros se inicializan con los valores de los argumentos.
● Se ejecuta el bloque código del método hasta que se alcanza return o se

llega al final del bloque.
● Si el método devuelve un valor, se sustituye la invocación por el valor

devuelto.
● La ejecución del programa continúa en la siguiente instrucción donde se

invocó el método.
Ejercicio persona – Get y set

Continuaremos con nuestra clase Persona y vamos a primero crear los getter y
setter y después invocarlos desde el Main con alguno de los objetos que
instanciaste.
21
En resumen
Antes de POO, la técnica estándar de programación era la programación
procedural. Se denomina programación procedural porque en ella se destacan
los procedimientos o tareas que resuelven un problema. Se piensa primero en
lo que se quiere hacer: los procedimientos.
En contraste, el paradigma POO invita a pensar en lo que se desea que

represente el programa. Normalmente se responde esta invitación
identificando algunas cosas en el mundo que se desea que el programa
modele.
Estas cosas podrían ser entidades físicas o conceptuales, por ejemplo, un libro.
Una vez identificadas las cosas que se quiere modelar, se identifican sus
propiedades/atributos básicos. Estos se pueden agrupar todos juntos en una
estructura coherente llamada objeto que creamos a través de las clases.
22
Ejercicios Extras
Ejercicios extras
Estos van a ser ejercicios para reforzar los conocimientos previamente vistos.
Estos pueden realizarse cuando hayas terminado la guía y tengas una buena
base sobre lo que venimos trabajando. Además, si ya terminaste la guía y te
queda tiempo libre, puedes continuar con estos ejercicios extra, recordando
siempre que no es necesario que los termines para continuar con el tema
siguiente. Por último, recuerda que la prioridad es ayudar a los compañeros de
tu equipo y que cuando tengas que ayudar, lo más valioso es que puedas
explicar el ejercicio con la intención de que tu compañero lo comprenda, y no
sólo mostrarlo. ¡Muchas gracias!
1. Desarrollar una clase Cancion con los siguientes atributos: título y autor.
Se deberá definir además dos constructores: uno vacío que inicializa el
título y el autor a cadenas vacías y otro que reciba como parámetros el
título y el autor de la canción. Se deberán además definir los métodos
getters y setters correspondientes.
2. Definir una clase llamada Puntos que contendrá las coordenadas de dos
puntos, sus atributos serán, x1, y1, x2, y2, siendo cada x e y un punto.
Generar un objeto puntos usando un método crearPuntos() que le pide al
usuario los dos números y los ingresa en los atributos del objeto.
Después, a través de otro método calcular y devolver la distancia que
existe entre los dos puntos que existen en la clase Puntos. Para conocer
como calcular la distancia entre dos puntos consulte el siguiente link:
http://www.matematicatuya.com/GRAFICAecuaciones/S1a.html
3. Crea una clase "Juego" que tenga un método "iniciar_juego" que permita
a dos jugadores jugar un juego de adivinanza de números. El primer
jugador elige un número y el segundo jugador intenta adivinarlo. El
segundo jugador tiene un número limitado de intentos y recibe una pista
de "más alto" o "más bajo" después de cada intento. El juego termina
cuando el segundo jugador adivina el número o se queda sin intentos.
Registra el número de intentos necesarios para adivinar el número y el
número de veces que cada jugador ha ganado.
4. Crea una clase "Cuenta" que tenga atributos como "saldo" y "titular".
Luego, crea un método "retirar_dinero" que permita retirar una cantidad
de dinero del saldo de la cuenta. Asegúrate de que el saldo nunca sea
negativo después de realizar una transacción de retiro.
2
5. Crea una clase "Empleado" que tenga atributos como "nombre", "edad" y
"salario". Luego, crea un método "calcular_aumento" que calcule el
aumento salarial de un empleado en función de su edad y salario actual.
El aumento salarial debe ser del 10% si el empleado tiene más de 30
años o del 5% si tiene menos de 30 años.
6. Crea una clase "Rectángulo" que tenga atributos "lado1" y "lado2" y un

método "calcular_area" que calcule y devuelva el área del rectángulo.
Luego crea un objeto "rectangulo1" de la clase "Rectángulo" con lados
de 4 y 6 y imprime el área del rectángulo.
3
Ejercicios
Antes de comenzar con esta guía, les damos algunas recomendaciones:
Este módulo es uno de los más divertidos ya que vamos a comenzar a modelar
los objetos del mundo real con el lenguaje de programación Java. Es
importante tener en cuenta que entender la programación orientada a objetos
lleva tiempo y sobre todo PRÁCTICA, así que, a no desesperarse, con cada
ejercicio vamos a ir entendiendo un poco más cómo aplicar este paradigma.
Importante: para la elaboración de estos ejercicios vas a tener 6 encuentros,

por lo que recomendamos que te tomes tu tiempo, que vuelvas a leer la guía la
cantidad de veces que sea necesario y que te apoyes lo más posible en tus
compañeros.

1. Crear una clase llamada Libro que contenga los siguientes atributos:
ISBN, Título, Autor, Número de páginas, y un constructor con todos los
atributos pasados por parámetro y un constructor vacío. Crear un
método para cargar un libro pidiendo los datos al usuario y luego
informar mediante otro método el número de ISBN, el título, el autor del
libro y el número de páginas.
2. Declarar una clase llamada Circunferencia que tenga como atributo

privado el radio de tipo real. A continuación, se deben crear los
siguientes métodos:
a) Método constructor que inicialice el radio pasado como parámetro.
b) Métodos get y set para el atributo radio de la clase Circunferencia.
c) Método para crearCircunferencia(): que le pide el radio y lo guarda

en el atributo del objeto.
d) Método area(): para calcular el área de la circunferencia (Area=〖

π*radio〗^2).
e) Método perimetro(): para calcular el perímetro

(Perimetro=2*π*radio).
2
3. Crear una clase llamada Operacion que tenga como atributos privados
numero1 y numero2. A continuación, se deben crear los siguientes
métodos:
a) Método constructor con todos los atributos pasados por parámetro.
b) Método constructor sin los atributos pasados por parámetro.
c) Métodos get y set.
d) Método para crearOperacion(): que le pide al usuario los dos

números y los guarda en los atributos del objeto.
e) Método sumar(): calcular la suma de los números y devolver el

resultado al main.
f) Método restar(): calcular la resta de los números y devolver el

resultado al main
g) Método multiplicar(): primero valida que no se haga una

multiplicación por cero, si fuera a multiplicar por cero, el método
devuelve 0 y se le informa al usuario el error. Si no, se hace la
multiplicación y se devuelve el resultado al main
h) Método dividir(): primero valida que no se haga una división por cero,
si fuera a pasar una división por cero, el método devuelve 0 y se le
informa al usuario el error se le informa al usuario. Si no, se hace la
división y se devuelve el resultado al main.
4. Crear una clase Rectángulo que modele rectángulos por medio de un

atributo privado base y un atributo privado altura. La clase incluirá un
método para crear el rectángulo con los datos del Rectángulo dados por
el usuario. También incluirá un método para calcular la superficie del
rectángulo y un método para calcular el perímetro del rectángulo. Por
último, tendremos un método que dibujará el rectángulo mediante
asteriscos usando la base y la altura. Se deberán además definir los
métodos getters, setters y constructores correspondientes.
Superficie = base * altura / Perímetro = (base + altura) * 2.
3
Clase Servicio
● Utilizar arquitectura en capas

● Utilizar una clase servicio con métodos que siguen
reglas del negocio
Clase servicio
Vamos a continuar con el paradigma orientado a objetos pero ahora vamos a
ver algo que no es parte realmente del paradigma orientado a objetos, sino que
es una clase que nos va a ayudar mucho a la realización del paradigma
orientado a objetos y es la clase servicio.
¿Qué es la clase servicio?

La clase servicio (service) o control, va a ser una clase auxiliar que nos va a
ayudar con el manejo de las clases y los objetos de esas clases, pero para
poder explicar esto, primero vamos a tener que ver los patrones generales de
software GRASP. Aunque se considera que más que patrones propiamente
dichos, son una serie de "buenas prácticas" de aplicación recomendable en el
diseño de software.
Patrones grasp
Un proceso de desarrollo sirve para normalizar quién hace qué cosa en cada
momento y cómo debe realizarse esta cosa.
GRASP es el acrónimo de General Responsibility Assignment Software

Patterns. Una de las cosas más complicadas en Orientación a Objeto consiste
en elegir las clases adecuadas y decidir cómo estas clases deben interactuar.
Patron Experto
Dentro de los patrones GRASP, vamos a utilizar el patrón experto. El GRASP de
experto en información es el principio básico de asignación de
responsabilidades. Nos indica, por ejemplo, que la responsabilidad de la
creación de un objeto o la implementación de un método debe recaer sobre la
clase que conoce toda la información necesaria para crearlo. De este modo
obtendremos un diseño con mayor cohesión y así la información se mantiene
encapsulada (disminución del acoplamiento).
Problema
¿Cuál es el principio general para asignar responsabilidades a los objetos?
Solución
Asignar una responsabilidad al experto en información.
2
Beneficios
Se mantiene el encapsulamiento, los objetos utilizan su propia información para

llevar a cabo sus tareas. Se distribuye el comportamiento entre las clases que
contienen la información requerida. Son más fáciles de entender y mantener.
Clase servicio
Esta clase del patrón experto va a ser la clase servicio. Es una clase común y
corriente pero que se va a encargar de crear los objetos y va a tener todos los
métodos necesarios para la utilización de ese objeto. Supongamos que
necesitamos un método que le sume un valor x a un atributo del objeto, este
método estará en la clase control.
Siempre se crea una clase control, por cada clase que tengamos, si tenemos
las clases Persona y Sueldo, crearemos una clase control para Persona y otra
para Sueldo. La idea es que una clase servicio, se encargue de solo una clase.
Como podemos ver en el diagrama, PersonaService llama y trabaja con la clase

Persona y crea instancias de ese objeto a través de un método, también, tiene
un método para mostrar la persona.
Pero, el encargado de llamar a esos métodos de la clase PersonaService va a

ser la clase Main, que vendría a ser el usuario llamando a las cosas que quiere
realizar con la Persona.
3
Para trabajar con clase de servicio o control debemos crear un nuevo paquete
en nuestro proyecto que se llame Servicios.
Métodos clase servicio

Como pudimos ver en el diagrama anterior la clase PersonaService, tenía sus
propios métodos, que iban a trabajar con la clase Persona, pero no que no se
encuentran en la clase Persona, sino en PersonaService. Es importante que a la
hora de trabajar con métodos dentro de la clase servicio o métodos externos,
tengamos en cuenta las siguientes cosas:
Parámetros y argumentos
Los parámetros de un método definen la cantidad y el tipo de dato de los
valores que recibe un método para su ejecución. Los argumentos son los
valores que se pasan a un método durante su invocación. El método recibe los
argumentos correspondientes a los parámetros con los que ha sido declarado.
Un método puede tener tantos parámetros como sea necesario. La lista de
parámetros de la cabecera de un método se define con la siguiente sintaxis:
tipo nombre [tipo nombre,]
4
Durante la invocación de un método es necesario que el número y el tipo de
argumentos coincidan con el número y el tipo de parámetros declarados en la
cabecera del método. Durante el proceso de compilación se comprueba que
durante la invocación de un método se pasan tantos argumentos como
parámetros tiene declarados y que además coinciden los tipos. Esta es una
característica de los lenguajes que se denominan “strongly tiped” o
“fuertemente tipado”
Paso de parámetros
Cuando se invoca un método se hace una copia de los valores de los
argumentos en los parámetros. Esto quiere decir que, si el método modifica el
valor de un parámetro, nunca se modifica el valor original del argumento.
Cuando se pasa una referencia a un objeto se crea un nuevo alias sobre el

objeto, de manera que esta nueva referencia utiliza el mismo espacio de
memoria del objeto original y esto permite acceder al objeto original.
El valor de retorno
Un método puede devolver un valor. Los métodos que no devuelven un valor se
declaran void, mientras que los métodos que devuelven un valor indican el tipo
que devuelven: int, double, char, String o un tipo de objeto.
Sobrecarga de métodos
La sobrecarga de métodos es útil para que el mismo método opere con
parámetros de distinto tipo o que un mismo método reciba una lista de
parámetros diferente. Esto quiere decir que puede haber dos métodos con el
mismo nombre que realicen dos funciones distintas. La diferencia entre los
métodos sobrecargados está en su declaración, y más específicamente, en la
cantidad y tipos de datos que reciben.
5
En el Main:
Ejercicio void
Crea un método void que reciba un objeto tipo persona como parámetro y
utilice el get para mostrar sus atributos. Llama ese método desde el main.
6
Ejercicios
CLASE SERVICIO
A partir de esta guía vamos a realizar todos los ejercicios, utilizando la clase
servicio. Recomendamos ver los videos y leer la teoría las veces que sean
necesarias, además, apoyarnos en nuestros compañeros si hay un concepto
que no entendemos.

1. Realizar una clase llamada CuentaBancaria en el paquete Entidades con

los siguientes atributos: numeroCuenta(entero), dniCliente(entero largo),
saldoActual. Agregar constructor vacío, con parámetros, getters y
setters.
Agregar la clase CuentaBancariaServicio en el paquete Servicios que

contenga:
a) Método para crear cuenta pidiéndole los datos al usuario.
b) Método ingresar(double): recibe una cantidad de dinero a ingresar y

se le sumará al saldo actual.
c) Método retirar(double): recibe una cantidad de dinero a retirar y se le

restara al saldo actual. Si la cuenta no tiene la cantidad de dinero a
retirar se retirará el máximo posible hasta dejar la cuenta en 0.
d) Método extraccionRapida: le permitirá sacar solo un 20% de su saldo.

Validar que el usuario no saque más del 20%.
e) Método consultarSaldo: permitirá consultar el saldo disponible en la

cuenta.
f) Método consultarDatos: permitirá mostrar todos los datos de la

cuenta.
2
2. Programa Nespresso. Desarrolle una clase Cafetera en el paquete
Entidades con los atributos capacidadMáxima (la cantidad máxima de
café que puede contener la cafetera) y cantidadActual (la cantidad
actual de café que hay en la cafetera). Agregar constructor vacío y con
parámetros así como setters y getters. Crear clase CafeteraServicio en
el paquete Servicios con los siguiente:
a) Método llenarCafetera(): hace que la cantidad actual sea igual a la

capacidad máxima.
b) Método servirTaza(int): se pide el tamaño de una taza vacía, el

método recibe el tamaño de la taza y simula la acción de servir la
taza con la capacidad indicada. Si la cantidad actual de café “no
alcanza” para llenar la taza, se sirve lo que quede. El método le
informará al usuario si se llenó o no la taza, y de no haberse llenado
en cuanto quedó la taza.
c) Método vaciarCafetera(): pone la cantidad de café actual en cero.
d) Método agregarCafe(int): se le pide al usuario una cantidad de café,

el método lo recibe y se añade a la cafetera la cantidad de café
indicada.
1. Realizar una clase llamada Persona en el paquete de entidades que

tengan los siguientes atributos: nombre, edad, sexo (‘H’ para hombre, ‘M’
para mujer, ‘O’ para otro), peso y altura. Si desea añadir algún otro
atributo, puede hacerlo. Agregar constructores, getters y setters.
En el paquete Servicios crear PersonaServicio con los siguientes 3

métodos:
a) Método esMayorDeEdad(): indica si la persona es mayor de edad. La

función devuelve un booleano.
b) Metodo crearPersona(): el método crear persona, le pide los valores

de los atributos al usuario y después se le asignan a sus respectivos
atributos para llenar el objeto Persona. Además, comprueba que el
sexo introducido sea correcto, es decir, H, M o O. Si no es correcto se
deberá mostrar un mensaje
3
c) Método calcularIMC(): calculara si la persona está en su peso ideal
(peso en kg/(altura^2 en mt2)). Si esta fórmula da por resultado un
valor menor que 20, significa que la persona está por debajo de su
peso ideal y la función devuelve un -1. Si la fórmula da por resultado
un número entre 20 y 25 (incluidos), significa que la persona está en
su peso ideal y la función devuelve un 0. Finalmente, si el resultado
de la fórmula es un valor mayor que 25 significa que la persona tiene
sobrepeso, y la función devuelve un 1.
A continuación, en la clase main hacer lo siguiente:
● Crear 4 objetos de tipo Persona con distintos valores, a continuación,

llamaremos todos los métodos para cada objeto, deberá comprobar si la
persona está en su peso ideal, tiene sobrepeso o está por debajo de su
peso ideal e indicar para cada objeto si la persona es mayor de edad.
● Por último, guardaremos los resultados de los métodos calcularIMC y

esMayorDeEdad en distintas variables(arrays), para después calcular un
porcentaje de esas 4 personas cuantas están por debajo de su peso,
cuantas en su peso ideal y cuantos, por encima, y también calcularemos
un porcentaje de cuantos son mayores de edad y cuantos menores. Para
esto, podemos crear unos métodos adicionales.
4
Ejercicios Extras
CLASE SERVICIO
Ejercicios extras
Estos pueden realizarse cuando hayas terminado la guía y tengas una buena
1. Vamos a realizar una clase llamada Raices, donde representaremos los

valores de una ecuación de 2º grado. Tendremos los 3 coeficientes
como atributos, llamémosles a, b y c. Hay que insertar estos 3 valores
para construir el objeto a través de un método constructor. Luego, en
RaicesServicio las operaciones que se podrán realizar son las siguientes:
a) Método getDiscriminante(): devuelve el valor del discriminante

(double). El discriminante tiene la siguiente fórmula: (b^2)-4*a*c
b) Método tieneRaices(): devuelve un booleano indicando si tiene dos

soluciones, para que esto ocurra, el discriminante debe ser mayor o
igual que 0.
c) Método tieneRaiz(): devuelve un booleano indicando si tiene una

única solución, para que esto ocurra, el discriminante debe ser igual
que 0.
d) Método obtenerRaices(): llama a tieneRaíces() y si devolvió́ true,

imprime las 2 posibles soluciones.
e) Método obtenerRaiz(): llama a tieneRaiz() y si devolvió́ true imprime

una única raíz. Es en el caso en que se tenga una única solución
posible.
f) Método calcular(): esté método llamará tieneRaices() y a tieneRaíz(),

y mostrará por pantalla las posibles soluciones que tiene nuestra
ecuación con los métodos obtenerRaices() o obtenerRaiz(), según lo
que devuelvan nuestros métodos y en caso de no existir solución, se
mostrará un mensaje.
Nota: Fórmula ecuación 2o grado: (-b±√((b^2)-(4*a*c)))/(2*a) Solo varía

el signo delante de -b
2
2. Dígito Verificador. Crear una clase NIF que se usará para mantener DNIs
con su correspondiente letra (NIF). Los atributos serán el número de DNI
(entero largo) y la letra (String o char) que le corresponde. En NIFService
se dispondrá de los siguientes métodos:
a) Métodos getters y setters para el número de DNI y la letra.
b) Método crearNif(): le pide al usuario el DNI y con ese DNI calcula la

letra que le corresponderá. Una vez calculado, le asigna la letra que
le corresponde según
c) Método mostrar(): que nos permita mostrar el NIF (ocho dígitos, un

guion y la letra en mayúscula; por ejemplo: 00395469-F).
La letra correspondiente al dígito verificador se calculará a traves de un

método que funciona de la siguiente manera: Para calcular la letra se
toma el resto de dividir el número de DNI por 23 (el resultado debe ser
un número entre 0 y 22). El método debe buscar en un array (vector) de
caracteres la posición que corresponda al resto de la división para
obtener la letra correspondiente. La tabla de caracteres es la siguiente:
POSICIÓN LETRA
0 T
1 R
2 W
3 A
4 G
5 M
6 Y
7 F
8 P
9 D
10 X
11 B
3
12 N
13 J
14 Z
15 S
16 Q
17 V
18 H
19 L
20 C
21 K
22 E
4
Clases de Utilidades
PARTE 2
En esta guía aprenderemos sobre:
● Clase Array
● Clase Date
● Clase Integer
Clases de Utilidad Parte 2
Recordemos que las clases de utilidad son clases dentro del API de Java que
son muy utilizadas en el desarrollo de aplicaciones. Las clases de utilidad son
clases que definen un conjunto de métodos que realizan funciones,
normalmente muy reutilizadas. Estas nos van a ayudar junto con las estructuras
de control, a lograr resolver problemas de manera más sencilla.
Entre las clases de utilidad de Java más utilizadas y conocidas están las
siguientes: Arrays, String, Integer, Math, Date, Calendar y GregorianCalendar.
En la guía anterior vimos solo las clases Math y String. Ahora vamos a ver el
resto de las clases.
Clase Arrays
La clase Arrays es una clase de utilidad que posee una gran cantidad de
métodos para manipular arreglos.
Método Descripción
Arrays.equals(arreglo1, Retorna true o false, si dos arreglos del

arreglo2) mismo tipo de dato son iguales.
Arrays.fill(arreglo, Este método lo que hace es inicializar todo

variable) el arreglo con la variable o valor que
pasamos como argumento. Este método se
Arrays.fill(arreglo, int
puede usar con cualquier tipo de dato y le
desde, int hasta,
podemos decir desde y hasta que índice
variable)
queremos que llene con ese valor.
Arrays.sort(arreglo) Este método sirve para ordenar un arreglo

de manera ascendente. A este método
Arrays.sort(arreglo, int
también le podemos decir desde y hasta
desde, int hasta)
que índice queremos que ordene.
2
Arrays.toString(arreglo) Este método imprime el arreglo como una
cadena, la cadena consiste en una lista de
los elementos del arreglo encerrados entre
corchetes ("[]"). Los elementos adyacentes
están separados por comas (",").
Clase Integer
La clase Integer permite convertir un tipo primitivo de dato int a objeto Integer.
La clase Integer pertenece al paquete java.lang del API de Java y hereda de la
clase java.lang.Number.
Integer(String s) Constructor que inicializa un objeto con una

cadena de caracteres. Esta cadena debe
contener un número entero.
compareTo(entero, Compara dos objetos Integer

otroEntero) numéricamente. Retorna 0 si son iguales,
entero negativo si el primer número es
menor o entero positivo si el primer número
es mayor.
doubleValue() Retorna el valor del Integer en tipo primitivo

double
equals(Object obj) Compara el Integer con el objeto del

parámetro. Devuelve true si son iguales y
false si no.
parseInt(String s) Convierte la cadena de caracteres numérica

del parámetro en tipo primitivo int.
toString() Retorna el valor del Integer en una cadena

de caracteres.
3
Clase Date
La clase Date modela objetos o variables de tipo fecha. La clase Date
representa un instante de tiempo específico con una precisión en milisegundos
y permite el uso del formato Universal Coordinated Time (UTC). Por otro lado,
muchas computadoras están definidas en términos de Greenwich Mean Time
(GMT) que es equivalente a Universal Time (UT). GMT es el nombre estándar y
UT es el nombre científico del estándar. La diferencia entre UT y UTC es que
UTC está basado en un reloj atómico y UT está basado en un reloj astronómico.
Las fechas en Java, comienzan en el valor standar based time llamado “epoch”
que hace referencia al 1 de Enero de 1970, 0 horas 0 minutos 0 segundos GMT.
La clase Date posee métodos que permiten la manipulación de fechas. La clase

Date pertenece al paquete java.util del API de Java.
Date() Constructor que inicializa la fecha en el

milisegundo más cercano a la fecha del
sistema.
Date(int dia, int mes, int Constructor que inicializa la fecha

año) sumándole 1900 al año.
after(Date fecha2) Retorna verdadero si la fecha está después

de la fecha del parámetro
before(Date fecha2) Retorna verdadero si la fecha está antes de

la fecha del parámetro
compareTo(Date fecha) Compara la fecha con la del parámetro.

Retorna 0 si son iguales, entero negativo si
el primer número es menor o entero positivo
si el primer número es mayor.
equals(Object obj) Compara el Date con el objeto del

parámetro. Devuelve true si son iguales y
false si no.
4
getDay() Retorna el valor del día de la semana de la
fecha. Ejemplo: si es lunes devuelve 0,
martes 1, miércoles 2, jueves 3, viernes 4,
sábado 5 y domingo 6.
getDate() Retorna el número del día de la fecha.
getMonth() Retorna el mes de la fecha.
getYear() Retorna el año de la fecha.
getTime() Retorna la fecha en milisegundos a partir del

“epoch”.
setDate(int dia) Asigna un día a la fecha.
setMonth(int mes) Asigna un mes a la fecha.
setYear(int anio) Asigna un año a la fecha.
setTime(long time) Asigna la fecha en milisegundos a partir del

“epoch”.
toString() Retorna la fecha en una cadena de

caracteres.
5
Ejercicios
CLASES DE UTILIDADES
Los métodos disponibles para las clases de utilidad Integer, Arrays y Date
están en esta guía. Recordar que la clase String y Math están explicadas en la
guía anterior de Intro Java.
1. Realizar una clase llamada Cadena, en el paquete de entidades, que

tenga como atributos una frase (String) y su longitud. Agregar
constructor vacío y con atributo frase solamente. Agregar getters y
setters. El constructor con frase como atributo debe setear la longitud
de la frase de manera automática. Crear una clase CadenaServicio en el
paquete servicios que implemente los siguientes métodos:
a) Método mostrarVocales(), deberá contabilizar la cantidad de vocales

que tiene la frase ingresada.
b) Método invertirFrase(), deberá invertir la frase ingresada y mostrarla

por pantalla. Por ejemplo: Entrada: "casa blanca", Salida: "acnalb
asac".
c) Método vecesRepetido(String letra), recibirá un carácter ingresado

por el usuario y contabilizar cuántas veces se repite el carácter en la
frase, por ejemplo:
d) Entrada: frase = "casa blanca". Salida: El carácter 'a' se repite 4

veces.
e) Método compararLongitud(String frase), deberá comparar la longitud

de la frase que compone la clase con otra nueva frase ingresada por
el usuario.
f) Método unirFrases(String frase), deberá unir la frase contenida en la

clase Cadena con una nueva frase ingresada por el usuario y mostrar
la frase resultante.
g) Método reemplazar(String letra), deberá reemplazar todas las letras

“a” que se encuentren en la frase, por algún otro carácter
seleccionado por el usuario y mostrar la frase resultante.
h) Método contiene(String letra), deberá comprobar si la frase contiene

una letra que ingresa el usuario y devuelve verdadero si la contiene y
falso si no.
2
Método Static y Clase Math
2. Realizar una clase llamada ParDeNumeros que tenga como atributos dos
números reales con los cuales se realizarán diferentes operaciones
matemáticas. La clase debe tener un constructor vacío, getters y setters.
En el constructor vacío se usará el Math.random para generar los dos
números. Crear una clase ParDeNumerosService, en el paquete
Servicios, que deberá además implementar los siguientes métodos:
a) Método mostrarValores que muestra cuáles son los dos números

guardados.
b) Método devolverMayor para retornar cuál de los dos atributos tiene

el mayor valor
c) Método calcularPotencia para calcular la potencia del mayor valor de

la clase elevado al menor número. Previamente se deben redondear
ambos valores.
d) Método calculaRaiz, para calcular la raíz cuadrada del menor de los

dos valores. Antes de calcular la raíz cuadrada se debe obtener el
valor absoluto del número.
Clase Arrays
3. Crear en el Main dos arreglos. El arreglo A de 50 números reales y el

arreglo B de 20 números reales. Crear la clase ArregloService, en el
paquete servicio, con los siguientes métodos:
1) Método inicializarA recibe un arreglo por parámetro y lo inicializa con

números aleatorios.
2) Método mostrar recibe un arreglo por parámetro y lo muestra por

pantalla.
3) Método ordenar recibe un arreglo por parámetro y lo ordena de

mayor a menor.
4) Método inicializarB copia los primeros 10 números del arreglo A en el

arreglo B. Luego llenar las últimas 10 posiciones del arreglo B con 0.5.
En el Main nuevamente: inicializar A, mostrar A, ordenar A, inicializar B,

mostrar A y B.
3
Clase Date
4. Vamos a usar la clase Date que ya existe en Java. Crearemos la clase

FechaService, en paquete Servicios, que tenga los siguientes métodos:
a) Método fechaNacimiento que pregunte al usuario día, mes y año de

su nacimiento. Luego los pase por parámetro a un nuevo objeto Date.
El método debe retornar el objeto Date. Ejemplo fecha: Date fecha =
new Date(anio, mes, dia);
b) Método fechaActual que cree un objeto fecha con el día actual. Para
esto usaremos el constructor vacío de la clase Date. Ejemplo: Date
fechaActual = new Date();
El método debe retornar el objeto Date.
c) Método diferencia que reciba las dos fechas por parámetro y retorna
la diferencia de años entre una y otra (edad del usuario).
Si necesiten acá tienen más información en clase Date: Documentacion

Oracle
5. Implemente la clase Persona en el paquete entidades. Una persona tiene

un nombre y una fecha de nacimiento (Tipo Date), constructor vacío,
constructor parametrizado, get y set. Crear una clase PersonaService,
en el paquete servicio, con los siguientes métodos:
a) Método crearPersona que pida al usuario Nombre y fecha de

nacimiento de la persona a crear. Retornar el objeto Persona creado.
b) Método calcularEdad que calcule la edad del usuario utilizando el

atributo de fecha de nacimiento y la fecha actual.
c) Método menorQue recibe como parámetro una Persona y una edad.

Retorna true si la persona es menor que la edad consultada o false
en caso contrario.
d) Método mostrarPersona que muestra la información de la persona

deseada.
4
Uso de vectores como atributos de clase
6. Un profesor particular está dando cursos para grupos de cinco alumnos

y necesita un programa para organizar la información de cada curso.
Para ello, crearemos una clase entidad llamada Curso, cuyos atributos
serán: nombreCurso, cantidadHorasPorDia, cantidadDiasPorSemana,
turno (mañana o tarde), precioPorHora y alumnos. Donde alumnos es un
arreglo de tipo String de dimensión 5 (cinco), donde se alojarán los
nombres de cada alumno. A continuación, se implementarán los
siguientes métodos:
a) Un constructor por defecto.
b) Un constructor con todos los atributos como parámetro.
c) Métodos getters y setters de cada atributo.
d) Método cargarAlumnos(): este método le permitirá al usuario ingresar

los alumnos que asisten a las clases. Nosotros nos encargaremos de
almacenar esta información en un arreglo e iterar con un bucle,
solicitando en cada repetición que se ingrese el nombre de cada
alumno.
e) Método crearCurso(): el método crear curso, le pide los valores de

los atributos al usuario y después se le asignan a sus respectivos
atributos para llenar el objeto Curso. En este método invocamos al
método cargarAlumnos() para asignarle valor al atributo alumnos
f) Método calcularGananciaSemanal(): este método se encarga de

calcular la ganancia en una semana por curso. Para ello, se deben
multiplicar la cantidad de horas por día, el precio por hora, la
cantidad de alumnos y la cantidad de días a la semana que se repite
el encuentro.
5
Ejercicios extras
CLASES DE UTILIDADES
Ejercicios extras
Estos deben realizarse cuando hayas terminado la guía y tengas una buena
1. Crea una clase en Java donde declares una variable de tipo array de
Strings que contenga los doce meses del año, en minúsculas. A
continuación, declara una variable mesSecreto de tipo String, y hazla
igual a un elemento del array (por ejemplo, mesSecreto = mes[9]. El
programa debe pedir al usuario que adivine el mes secreto. Si el usuario
acierta mostrar un mensaje, y si no lo hace, pedir que vuelva a intentar
adivinar el mes secreto. Un ejemplo de ejecución del programa podría
ser este:
Adivine el mes secreto. Introduzca el nombre del mes en minúsculas:

febrero
No ha acertado. Intente adivinarlo introduciendo otro mes: agosto
¡Ha acertado!
2. Juego Ahorcado: Crear una clase Ahorcado (como el juego), la cual

deberá contener como atributos, un vector con la palabra a buscar, la
cantidad de letras encontradas y la cantidad jugadas máximas que
puede realizar el usuario. Definir los siguientes métodos en
AhorcadoService:
● Metodo crearJuego(): le pide la palabra al usuario y cantidad de

jugadas máxima. Con la palabra del usuario, pone la longitud de la
palabra, como la longitud del vector. Después ingresa la palabra en el
vector, letra por letra, quedando cada letra de la palabra en un índice
del vector. Y también, guarda la cantidad de jugadas máximas y el
valor que ingresó el usuario.
2
● Método longitud(): muestra la longitud de la palabra que se debe
encontrar. Nota: buscar como se usa el vector.length.
● Método buscar(letra): este método recibe una letra dada por el

usuario y busca si la letra ingresada es parte de la palabra o no.
También informará si la letra estaba o no.
● Método encontradas(letra): que reciba una letra ingresada por el

usuario y muestre cuantas letras han sido encontradas y cuántas le
faltan. Este método además deberá devolver true si la letra estaba y
false si la letra no estaba, ya que, cada vez que se busque una letra
que no esté, se le restará uno a sus oportunidades.
● Método intentos(): para mostrar cuántas oportunidades le queda al

jugador.
● Método juego(): el método juego se encargará de llamar todos los

métodos previamente mencionados e informará cuando el usuario
descubra toda la palabra o se quede sin intentos. Este método se
llamará en el main.
Un ejemplo de salida puede ser así:
Ingrese una letra:

a
Longitud de la palabra: 6
Mensaje: La letra pertenece a la palabra
Número de letras (encontradas, faltantes): (3,4)
Número de oportunidades restantes: 4
----------------------------------------------
Ingrese una letra:

z
Mensaje: La letra no pertenece a la palabra
3
---------------------------------------------
Ingrese una letra:

b
----------------------------------------------
Ingrese una letra:

u
----------------------------------------------
Ingrese una letra:

q
Mensaje: Lo sentimos, no hay más oportunidades
4
Ejercicio
Integrador
Estudiantes
Ejercicio integrador
Una escuela ha terminado su ciclo lectivo y todos sus alumnos ya rindieron el
examen final. La escuela nos ha pedido que calculemos el promedio de notas
final de todos sus alumnos y saber qué alumnos han recibido una nota por
encima de ese promedio.
Para esto vamos a tener que crear un objeto de tipo Estudiante, sus atributos
van a ser nombre y nota (representando la nota obtenida en el final).
La escuela consta con tan solo 8 estudiantes, por lo que deberemos crear los 8
estudiantes con sus respectivas notas.
Una vez creado los estudiantes deberemos guardar los estudiantes en un

arreglo de objetos tipo Estudiante, usando ese arreglo tenemos que realizar las
dos tareas que nos ha pedido la escuela.
1. Calcular y mostrar el promedio de notas de todo el curso
2. Retornar otro arreglo con los nombre de los alumnos que recibieron una
nota mayor al promedio del curso
3. Por último, deberemos mostrar todos los estudiantes con una nota
mayor al promedio.
Nota: para crear un vector de objetos la definición es la siguiente:
Objeto nombreVector[] = new Objeto[];
2
CURSO DE PROGRAMACIÓN FULL STACK
COLECCIONES
PARADIGMA ORIENTADO EN OBTEJOS
Objetivos de la Guía
• El concepto de colecciones en java
• Crear y usar listas, conjuntos y mapas
• Entender cuando usar cada una de las distintas

colecciones
• Modificar y recorrer colecciones
• Agregar, buscar y eliminar elementos en las

colecciones
P¿QUÉ SON LAS COLECCIONES?P

Previo a esta guía, nosotros manejábamos nuestros objetos de uno en uno, no teníamos manera
de manejar varios objetos a la vez, pero, para esto existen las colecciones.
Una colección representa un grupo de objetos, conocidos como elementos. Podemos crear una
colección con cualquier tipo de objeto, incluso los creados por nosotros. La única restricción es
que no podremos crear una colección sólo de tipo primitivo, para eso usaremos los tipos de
Objetos equivalentes a los primitivos. Por ejemplo: en vez de int, hay que utilizar Integer. Aquí
dejamos una tabla de los objetos equivalentes a los primitivos que Java nos trae.
Tipos de datos
Primitivos Objetos
int Integer
double Double
long Long
char Character
boolean Boolean
String ya es un objeto, por lo que no tiene

tipo primitivo
Sigamos con nuestro ejemplo de la cajonera, de la guía anterior para terminar de cerrar el
concepto. Hemos tenido muchos pedidos, por lo que construimos un almacén donde guardar
todas las cajoneras que vamos fabricando. De esta forma tenemos muchas cajoneras (elementos)
dentro de un almacén (colección).
1
Dijimos que una colección es un grupo de objetos, pero para obtener una colección vamos a
utilizar unas clases propias de Java. Estas clases, que van a ser el almacén de los objetos, nos
proveen con una serie de herramientas (métodos) comunes, para trabajar con los elementos de la
colección, como, por ejemplo: agregar y eliminar elementos u obtener el tamaño de la colección,
etc.
La principal diferencia entre las colecciones y los arreglos tradicionales es que las colecciones
crecen de manera dinámica a medida que se van agregando objetos. No necesitamos saber de
antemano la cantidad de elementos con la que vamos a trabajar.
Usaremos el Java Collections Framework dentro del paquete java.util. El Collections Framework
es una arquitectura compuesta de interfaces y clases. Dentro de este framework están las
colecciones que vamos a trabajar, las listas, conjuntos y mapas. Nota: el concepto de interfaces lo
vamos a explicar más adelante.
¿QUÉ ES UN FRAMEWORK?
Un framework es un marco de trabajo el cual contiene un conjunto estandarizado de conceptos,
prácticas, criterios y herramientas para hacer frente a un tipo de problemática particular y resolver
nuevos problemas de índole similar. Las clases del Java Collections Framework son las
siguientes:
2
P¿QUÉ COLECCIONES VAMOS A VER EN ESTA GUÍA?P
Como pudimos ver en el grafico del framework de colecciones, hay varios tipos de colecciones, en
esta guía nos vamos a centrar en las listas, los conjuntos y los mapas. Además veremos el uso
del Iterable.
PLISTASP
Las listas son un tipo de colección que nos permiten tener un control preciso sobre el lugar que
ocupa cada elemento. Es decir, sus elementos están ordenados y podemos elegir en qué lugar
colocar un elemento mediante su índice(lugar que ocupa). Esto nos da una de las características
más importantes de las listas: pueden guardar elementos duplicados. Es decir, permite que lista[0]
sea exactamente igual a lista[1].
ARRAYLIST
Se implementa como un arreglo de tamaño variable. A medida que se agregan más elementos, su
tamaño aumenta dinámicamente. Es el tipo más común.
Básicamente es un array o vector de tamaño dinámico, con las características propias de las listas.
LINKEDLIST
Se implementa como una lista de doble enlace. Su rendimiento al agregar y quitar es mejor que
Arraylist, pero peor en los métodos set y get.
¿Qué es una lista de doble enlace?
Básicamente una lista de doble enlace es un tipo de lista enlazada que permite moverse hacia
delante y hacia atrás.
Si quieres saber más te dejamos este enlace:
• https://www.deltapci.com/java-listas-doblemente-enlazadas/
3
Las listas son las colecciones más simples y más usadas en la
programación, pero dependerá de cada proyecto qué colección
elegir.
PCONJUNTOSP
Los conjuntos o en ingles Set modelan una colección de objetos de una misma clase donde cada
elemento aparece solo una vez, no puede tener duplicados, a diferencia de una lista donde los
elementos podían repetirse. El framework trae varias implementaciones de distintos tipos de
conjuntos:
HASHSET
Se implementa utilizando una tabla hash para darle un valor único a cada elemento y de esa
manera evitar los duplicados. Es decir, el HashSet crea un código hash para cada valor, evitando
que hayan dos valores iguales o duplicados y a diferencia del TreeSet sus elementos no están
ordenados.
¿Qué es un Hash?
Una función criptográfica hash- usualmente conocida como “hash”- es un algoritmo matemático
que transforma cualquier bloque arbitrario de datos en una nueva serie de caracteres
alfanuméricos (mezcla entre letras y números) con una longitud fija. Independientemente de la
longitud de los datos de entrada, el valor hash de salida tendrá siempre la misma longitud.
4
Esto lo que hace el HashSet cada vez que se le ingresa un dato, lo transforma en ese valor hash
que es único para ese dato.
Si quieres saber más te dejamos este enlace:
• https://latam.kaspersky.com/blog/que-es-un-hash-y-como-funciona/2806/
TREESET
Se implementa utilizando una estructura de árbol (árbol rojo-negro en el libro de algoritmos) Te
dejamos un link a este concepto: https://es.wikipedia.org/wiki/%C3%81rbol_rojo-negro.
La gran diferencia entre el HashSet y el TreeSet, es que el TreeSet mantiene todos sus elementos
de manera ordenada (forma ascendente), pero los métodos de agregar, eliminar son más lentos
que el HashSet ya que cada vez que le entra un elemento debe posicionarlo para que quede
ordenado. Además de ordenarlos el TreeSet tampoco admite duplicados.
LINKEDHASHSET
Está entre HashSet y TreeSet. Se implementa como una tabla hash con una lista vinculada que se
ejecuta a través de ella, por lo que proporciona el orden de inserción.
PMAPASP
Los mapas modelan un objeto a través de una llave y un valor. Esto significa que cada valor de
nuestro mapa, va a tener una llave única para representar dicho valor. Las llaves de nuestro mapa
no pueden repetirse, pero los valores sí. Un ejemplo sería una persona que tiene su DNI/RUT
(llave única) y como valor puede ser su nombre completo, puede haber dos personas con el
mismo nombre, pero nunca con el mismo DNI/RUT.
Los mapas al tener dos datos, también vamos a tener que especificar el tipo de dato tanto de la
llave y del valor, pueden ser de tipos de datos distintos. A la hora de crear un mapa tenemos que
pensar que el primer tipo dato será el de la llave y el segundo el valor.
Son una de las estructuras de datos importantes del Framework de Collections. Las
implementaciones de mapas son HashMap, TreeMap, LinkedHashMap y HashTable.
HASHMAP
Es un mapa implementado a través de una tabla hash, las llaves se almacenan utilizando un
algoritmo de hash solo para las llaves y evitar que se repitan.
5
TREEMAP
Es un mapa que ordena los elementos de manera ascendente a través de las llaves.
LINKEDHASHMAP
Es un HashMap que conserva el orden de inserción.
Veremos que los mapas al tener una llave trabajan muy

parecidos a lo que van a ser las bases de datos que vamos a
ver más adelante.
MANOS A LA OBRA – DETECCIÓN DE ERRORES

Corrige el siguiente código:
Array<int> listado = new ArrayList;
TreeSet<String> = TreeSet();
HashMap<Integer> personas = new HashMap<>;
PAÑADIR UN ELEMENTO A UNA COLECCIÓNP

Las colecciones constan con funciones para realizar distintas operaciones, en este caso si
queremos añadir un elemento a las listas o conjuntos vamos a tener que utilizar la función add(T).
Sólo en el caso de los mapas vamos a utilizar la función put(llave,valor).
6
EJERCICIO COLECCIONES
Toma la Lista, el Conjunto y el Mapa del ejemplo y agrega 5 objetos a cada uno.
PELIMINAR UN ELEMENTO DE UNA COLECCIÓNP

Cada colección consta con métodos para poder remover elementos del tipo que sea la colección.
LISTAS
Las listas constan de dos métodos:
• remove(int índice): Este método remueve un elemento de un índice especifico. Esto mueve
los elementos, de manera que no queden índices sin elementos.
• remove(elemento): Este método remueve la primera aparición de un elemento a borrar en una

lista
7
CONJUNTOS
Ya que los conjuntos no constan de índices, solo se puede borrar por elemento.
remove(elemento): Este método remueve la primera aparición de un elemento a borrar en un

conjunto
MAPAS
La parte más importante de los elementos de un mapa es la llave del elemento, que es la que
hace el elemento único, por eso en los mapas solo podemos remover un elemento por su llave.
remove(llave): Este método remueve la primera aparición de la llave de un elemento a borrar en

un mapa.
Toma la Lista, el Conjunto y el Mapa que hiciste previamente y elimina en cada uno un objeto de
cada forma que aprendiste arriba.
PRECORRER UNA COLECCIÓNP

Si quisiéramos mostrar todos los elementos que le hemos agregado y que componen a nuestra
colección vamos a tener que recorrerla.
Para recorrer una colección, vamos a tener que utilizar el bucle forEach. El bucle comienza con la
palabra clave for al igual que un bucle for normal. Pero, en lugar de declarar e inicializar una
variable contadora del bucle, declara una variable vacía, que es del mismo tipo que la colección,
seguido de dos puntos y seguido del nombre de la colección. La variable recibe en cada iteración
un elemento de la colección, de esa manera si nosotros mostramos esa variable, podemos
mostrar todos los elementos de nuestra colección.
Para recorrer mapas vamos a tener que usar el objeto Map.Entry en el for each. A través del entry
vamos a traer los valores y las llaves, si no, podemos tener un for each para cada parte de nuestro
mapa sin utilizar el objeto Map.Entry.
8
Para saber más sobre la clase Map y el objeto Entry: Map.Entry
For Each:
for (Tipo de dato variableVacia : Colección){

}
9
MANOS A LA OBRA – DETECCIÓN DE ERRORES
HashMap<Integer> personas = new HashMap<>;
String n1 = “Albus”;
String n2 = “Severus”;
personas.add(n1);
personas.add(n2);
PITERATORP
El Iterator es un objeto que pertenece al framework de colecciones. Este, nos permite recorrer,
acceder a la información y eliminar algún elemento de una colección. Gracias al Iterator podemos
eliminar un elemento, mientras recorremos la colección. Ya que, cuando queremos eliminar algún
elemento mientras recorremos una colección con el bucle ForEach, nos va a tirar un error.
Como el Iterator es parte del framework de colecciones, todas las colecciones vienen con el
método iterator(), este, devuelve las instrucciones para iterar sobre esa colección. Este método
iterator(), devuelve la colección, lo recibe el objeto Iterator y usando el objeto Iterator, podemos
iterar sobre nuestra colección.
Para poder usar el Iterator es importante crear el objeto de tipo Iterator, con el mismo tipo de dato
que nuestra colección.
El Iterator contiene tres métodos muy útiles para lograr esto:
1. boolean hasNext(): Retorna verdadero si al iterator le quedan elementos por iterar
2. Object next(): Devuelve el siguiente elemento en la colección, mientras le método

hasNext() retorne true. Este método es el que nos sirve para mostrar el elemento,
3. void remove(): Elimina el elemento actual de la colección.
10
PELIMINAR UN ELEMENTO DE UNA COLECCIÓN CON ITERATORP
Como pudimos ver más arriba para eliminar un elemento de una colección vamos a tener que
utilizar la función remove() del Iterator. Esto se aplica para el resto de nuestras colecciones. Los
mapas son los únicos que no podemos eliminar mientras las iteramos.
MANOS A LA OBRA - DETECCIÓN DE ERRORES

ArrayList<String> = new ArrayList()
bebidas.put(“café);
bebidas.add(“té”);
Iterator<String> it =bebidas.iterator();
whale (it.next()){
if (it.next().equals(“café”)){
it.remove();
PORDENAR UNA COLECCIÓNP

Los elementos, que vamos agregando a nuestra colección se van a mostrar según se fueron
agregando y nosotros capaz, necesitemos mostrar o tener todos los elementos ordenados.
Para ordenar una colección, vamos a tener que utilizar la función Collections.sort(colección). La
función, que es parte de la clase Collections, recibe la colección y la ordena para después poder
mostrarla ordenada de manera ascendente.
11
Algunas colecciones, como los conjuntos o los mapas no pueden utilizar el sort(). Ya que por
ejemplo los HashSet, manejan valores Hash y el sort() no sabe ordenar por hash, si no por
elementos. Por otro lado, los mapas al tener dos datos, el sort() no sabe por cuál de esos datos
ordenar.
Entonces, para ordenar los conjuntos, deberemos convertirlos a listas, para poder ordenar esa
lista por sus elementos. Y a la hora de ordenar un mapa como tenemos dos datos para ordenar,
vamos a convertir el HashMap a un TreeMap.
Nota: recordemos que los TreeSet y TreeMap se ordenan por sí mismos.
PCOLECCIONES CON OBJETOS CREADOS POR NOSOTROSP

De la misma manera que podemos crear colecciones con los tipos de datos de Java, podemos
crear colecciones de algún objeto, de una clase creada por nosotros, previamente. Esto, nos
servirá para manejar varios objetos al mismo tiempo y acceder a ellos de una manera más sencilla.
Por ejemplo, tener una lista de alumnos, siendo cada Alumno un objeto con sus atributos.
AÑADIR UN OBJETO A UNA COLECCIÓN

Para añadir un objeto a una colección tenemos que primero crear el objeto que queremos trabajar
y después crear una colección donde su tipo de dato sea dicho objeto.
La manera de agregar los objetos a la colección es muy parecida a lo que habíamos visto
previamente.
Las colecciones Tree, ya sean TreeSet o TreeMap, son las únicas que no vamos a poder agregar
como siempre. Ya que, los Tree, siendo colecciones que se ordenan a sí mismas, debemos
informarle al Tree como va a ordenarse. Pensemos que un objeto posee más de un
dato(atributos), entonces, el Tree, no sabe por qué atributo debe ordenarse.
Para solucionar esto, vamos a necesitar un Comparator, este, le dará la pauta de como ordenarse
y sobre que atributo. El Comparator está explicado más abajo en la guía y muestra como
agregárselo a los Tree.
12
PRECORRER UNA COLECCIÓN CON OBJETOSP
Para recorrer una colección donde su tipo de dato sea un objeto creado por nosotros, vamos a
seguir utilizando los métodos que conocemos, el for each o el iterator. Pero a la hora de mostrar el
objeto con un System.out.println, no nos va a mostrar sus atributos. Sino que, nos va a mostrar el
nombre de la clase, el nombre del objeto, una arroba y un código hash para representar los
valores del objeto.
Cuando queremos mostrar el libro, que está siendo recorrido por el for each, nos mostraría algo
así: Libreria.Libro@14ae5a5
Para solucionar este problema, vamos a tener que sobrescribir(Override), un método de la clase
String dentro de la clase de nuestro objeto. Este método va a transformar, el nombre de la clase, el
nombre del objeto y el hash, en una cadena legible para imprimir.
Para poder usar este método vamos a ir a nuestra clase, ahí hacemos click derecho, insert code y
le damos a toString(). Eso nos va a generar un método toString() con los atributos de nuestro
objeto y que retorna una cadena para mostrar el objeto.
13
El toString lo podemos modificar a nuestro gusto para que nos
muestre la información como la necesitemos.
Este método se va a llamar solo, sin necesidad que lo llamemos nosotros, siempre que queramos
mostrar nuestro objeto en un System.out.println. Y mostrará la línea que se ve en el return.
EJERCICIO LISTA LIBROS

¡Es tu turno! Crea una lista de Libros y muestra el título de cada uno con un bucle.
PCOMPARATORP
A la hora de querer ordenar una colección de objetos en Java, no podemos utilizar la función sort,
ya que el sort se utiliza para ordenar colecciones con elementos uniformes. Pero los objetos
pueden tener dentro distintos tipos de datos (atributos). Entonces, nuestra función sort no sabe
por cuál tipo de dato o atributo ordenar. Para esto, utilizamos la interfaz Comparator con su
función compare() dentro de nuestra clase entidad.
Supongamos que tenemos una clase Perro, que tiene como atributos el nombre del perro y la
edad. Nosotros queremos ordenar los perros por edad, deberemos crear el método compare de la
clase Comparator en la clase Perro.
14
Explicación del método:
• El método crea un objeto estático de la interfaz Comparator. Este nos va a permitir utilizar
a través de un sobrescribir (Override) el método compare, el mismo nos deja comparar dos
objetos para poder ordenarlos. Este objeto se crea static para poder llamar al método solo
llamando a la clase, sin tener que crear otro objeto Comparator, en este caso la clase
Perro.
• Dentro de la creación de objeto se crea un método de la clase Comparator llamado

compare, arriba del método se puede ver la palabra Override. Override, se usa cuando
desde una subclase (Perro), queremos utilizar un método de otra clase (Comparator) en
nuestra subclase.
• El método recibe dos objetos de la clase Perro y retorna una comparación entre los dos
usando los get para traer el atributo que queríamos comparar y usa la función compareTo,
que devuelve 0 si la edad es la misma, 1 si la primera edad es mayor a la segunda y -1 si la
primera edad es menor a la segunda.
• Si quisiéramos cambiar el atributo que usa para ordenar, pondríamos otro atributo en el
get del return.
USO DEL MÉTODO COMPARATOR

Como el comparator se va a usar para ordenar nuestras colecciones, se va a poner en el llamado
de la función Collections.sort() y se va a poner en la inicialización de cualquier tipo de Tree.
USO DE COMPARATOR EN TREESET

En los TreeSet necesitamos crearlos con el comparator porque como el TreeSet se ordena solo,
necesitamos decirle al TreeSet, bajo que atributo se va a ordenar, por eso le pasamos el
comparator en el constructor.
15
USO DE COMPARATOR EN MAPAS
PCOLECCIONES EN FUNCIONESP
A la hora de querer pasar una colección a una función, deberemos recordar que Java es
fuertemente tipado, por lo que deberemos poner el tipo de dato de la colección y que tipo de
colección es cuando la pongamos como argumento.
LISTAS
CONJUNTOS
16
MAPAS
PDEVOLVER UNA COLECCIÓN EN FUNCIONESP

Para devolver una colección en una función, tenemos que hacer que el tipo de dato de nuestra
función sea la colección que queremos devolver, teniendo también el tipo de dato que va a
manejar dicha colección.
LISTAS
CONJUNTOS
17
MAPAS
PROYECTO CON EJEMPLOS DE COLECCIONES

El proyecto contiene un paquete con un main para cada tipo de colección y un paquete más que
muestra cómo usar una lista con un objeto. Además, contiene algunos métodos que no están
explicados en la teoría.
Pueden encontrar un ejemplo de Colecciones en Java en tu Aula

Virtual.
PCLASE COLLECTIONSP
La clase Collections es parte del framework de colecciones y también es parte del paquete
java.util. Esta clase nos provee de métodos que reciben una colección y realizan alguna
operación o devuelven una colección, según el método. Vamos a mostrar algunos de los métodos,
pero hay muchos más.
Este método reemplaza todos los elementos de la lista con un

fill(List<T> lista, Objeto objeto)
elemento especifico.
frequency(Collection<T> Este método retorna la cantidad de veces que se encuentra

coleccion, Objeto objeto) un elemento especifico en una colección.
replaceAll(List<T> lista, T Este método reemplaza todas las apariciones de un elemento

valorViejo, T valorNuevo) especifico en una lista, con otro valor.
reverse(List<T> lista) Este método invierte el orden de los elementos de una lista.
Este método retorna un comparator que invierte el orden de

reverseOrder()
los elementos de una colección.
18
Este método modifica la posición de los elementos de una
shuffle(List<T> lista)
lista de manera aleatoria.
Este método ordena los elementos de una lista de manera

sort(List<T> lista)
ascendente.
METODOS EXTRAS COLECCIONES

En la guía se muestran las acciones más realizadas con colecciones, con la ayuda de sus métodos,
pero también existen otros métodos en las colecciones para realizar otras acciones. Nota: los
métodos de los List y los Set, son los mismos, quitando el get y el set.
LISTAS Y CONJUNTOS
size() Este método retorna el tamaño de una lista / conjunto.
Este método se usa para remover todos los elementos de una

clear()
lista / conjunto.
Este método retorna un elemento de la lista según un índice

get(int índice)
de la lista.
Este método guarda un elemento en la lista en un índice

set(int índice, elemento)
especifico.
Este método retorna verdadero si la lista / conjunto está vacío

isEmpty()
y falso si no lo está.
Este método recibe un elemento dado por el usuario y revisa

contains(elemento) si el elemento se encuentra en la lista o no. Si el elemento se
encuentra retorna verdadero y si no falso.
19
MAPAS
Este método se usa para remover todos los elementos de un

clear()
mapa.
Este método recibe una llave dada por el usuario y revisa si la

containsKey(Llave) llave se encuentra en la lista o no. Si la llave se encuentra
retorna verdadero y si no falso.
Este método recibe un valor dado por el usuario y revisa si el

containsValue(Valor) valor se encuentra en el mapa o no. Si el elemento se
encuentra retorna verdadero y si no falso.
Este método retorna un elemento del mapa según una llave

get(Llave)
dentro del mapa.
Este método retorna verdadero si el mapa está vacío y falso si

isEmpty()
no lo está.
size() Este método retorna el tamaño de un mapa.
Este método crea una colección según los valores del mapa.
values() Ósea, que retorna una lista, por ejemplo, con todos los
valores del mapa.
Este método se usa para remover todos los elementos de un

clear()
mapa.
20
PEJERCICIOS DE APRENDIZAJEP
En este módulo vamos a continuar modelando los objetos con el lenguaje de programación Java,
pero ahora vamos a utilizar las colecciones para poder manejarlas de manera más sencilla y
ordenada.
VIDEOS: Te sugerimos ver los videos relacionados con este tema, antes de empezar los
ejercicios, los podrás encontrar en tu aula virtual o en nuestro canal de YouTube.
1. Diseñar un programa que lea y guarde razas de perros en un ArrayList de tipo String. El
programa pedirá una raza de perro en un bucle, el mismo se guardará en la lista y
después se le preguntará al usuario si quiere guardar otro perro o si quiere salir. Si decide
salir, se mostrará todos los perros guardados en el ArrayList.
2. Continuando el ejercicio anterior, después de mostrar los perros, al usuario se le pedirá

un perro y se recorrerá la lista con un Iterator, se buscará el perro en la lista. Si el perro
está en la lista, se eliminará el perro que ingresó el usuario y se mostrará la lista
ordenada. Si el perro no se encuentra en la lista, se le informará al usuario y se mostrará
la lista ordenada.
3. Crear una clase llamada Alumno que mantenga información sobre las notas de distintos
alumnos. La clase Alumno tendrá como atributos, su nombre y una lista de tipo Integer
con sus 3 notas.
En el servicio de Alumno deberemos tener un bucle que crea un objeto Alumno. Se pide
toda la información al usuario y ese Alumno se guarda en una lista de tipo Alumno y se le
pregunta al usuario si quiere crear otro Alumno o no.
Después de ese bucle tendremos el siguiente método en el servicio de Alumno:
Método notaFinal(): El usuario ingresa el nombre del alumno que quiere calcular su nota
final y se lo busca en la lista de Alumnos. Si está en la lista, se llama al método. Dentro
del método se usará la lista notas para calcular el promedio final de alumno. Siendo este
promedio final, devuelto por el método y mostrado en el main.
Pueden encontrar un ejemplo de Colección como Atributo en tu Aula

Virtual.
4. Un cine necesita implementar un sistema en el que se puedan cargar peliculas. Para esto,
tendremos una clase Pelicula con el título, director y duración de la película (en horas).
Implemente las clases y métodos necesarios para esta situación, teniendo en cuenta lo
que se pide a continuación:
En el servicio deberemos tener un bucle que crea un objeto Pelicula pidiéndole al usuario
todos sus datos y guardándolos en el objeto Pelicula.
Después, esa Pelicula se guarda una lista de Peliculas y se le pregunta al usuario si quiere
crear otra Pelicula o no.
Después de ese bucle realizaremos las siguientes acciones:
21
• Mostrar en pantalla todas las películas.
• Mostrar en pantalla todas las películas con una duración mayor a 1 hora.
• Ordenar las películas de acuerdo a su duración (de mayor a menor) y mostrarlo en

pantalla.
• Ordenar las películas de acuerdo a su duración (de menor a mayor) y mostrarlo en

pantalla.
• Ordenar las películas por título, alfabéticamente y mostrarlo en pantalla.
• Ordenar las películas por director, alfabéticamente y mostrarlo en pantalla.
5. Se requiere un programa que lea y guarde países, y para evitar que se ingresen repetidos
usaremos un conjunto. El programa pedirá un país en un bucle, se guardará el país en el
conjunto y después se le preguntará al usuario si quiere guardar otro país o si quiere salir,
si decide salir, se mostrará todos los países guardados en el conjunto. (Recordemos hacer
los servicios en la clase correspondiente)
Después deberemos mostrar el conjunto ordenado alfabéticamente: para esto recordar

cómo se ordena un conjunto.
Por último, al usuario se le pedirá un país y se recorrerá el conjunto con un Iterator, se

buscará el país en el conjunto y si está en el conjunto se eliminará el país que ingresó el
usuario y se mostrará el conjunto. Si el país no se encuentra en el conjunto se le informará
al usuario.
6. Se necesita una aplicación para una tienda en la cual queremos almacenar los distintos
productos que venderemos y el precio que tendrán. Además, se necesita que la
aplicación cuente con las funciones básicas.
Estas las realizaremos en el servicio. Como, introducir un elemento, modificar su precio,

eliminar un producto y mostrar los productos que tenemos con su precio (Utilizar
Hashmap). El HashMap tendrá de llave el nombre del producto y de valor el precio.
Realizar un menú para lograr todas las acciones previamente mencionadas.
22
RELACIONES
ENTRE CLASES
PARADIGMA ORIENTADO A OBJETOS
En esta guía aprenderás:
• Qué es una relación
• Cómo usar un objeto a través de otro
• Las distintas relaciones que existen
• Cuando usar esas relaciones
• Cómo diagramar clases y relaciones
PRELACIONES ENTRE CLASESP

En la programación orientada a objetos, un objeto se comunica con otro objeto para utilizar la
funcionalidad y los servicios proporcionados por ese objeto.
Una relación es una conexión semántica entre clases. Permite que una clase conozca sobre los
atributos, operaciones y relaciones de otras clases. Las clases no actúan aisladas entre sí, al
contrario, las clases están relacionadas unas con otras. Una clase puede ser un tipo de otra clase
—generalización— o bien puede contener objetos de otra clase de varias formas posibles,
dependiendo de la fortaleza de la relación entre las dos clases.
La relación entre dos clases separadas se establece a través de sus Objetos. Es decir, las clases
se conectan juntas conceptualmente. Las relaciones entre clases realmente significan que una
clase contiene una referencia a un objeto u objetos, de la otra clase en la forma de un atributo.
Por ejemplo: un objeto curso tiene varios objetos alumnos y un objeto profesor. Esto significa que,
gracias a la relación entre objetos, el objeto curso puede tener toda la información que necesita.
Además, nos ayuda para la reutilización de código, ya que podemos usar todo lo de la clase que
ya habíamos escrito.
Ahora veamos cómo sería el ejemplo que venimos trabajando. Una cajonera necesita cajones,
pero estos tienen propiedades propias que la cajonera necesita saber. Por ejemplo: el cajón tiene
un ancho, largo y profundidad. Estas dimensiones no son las mismas que el ancho, largo y
profundidad de la cajonera. Cada uno tiene sus atributos, pero la cajonera necesita incorporar x
cantidad de cajones y para prever sus dimensiones necesita saber las dimensiones de los
cajones.
ASOCIACIÓN
La relación más simple es la asociación, esta relación es entre dos objetos como habíamos dicho
previamente. En las relaciones de asociación se puede establecer una relación bidireccional,
donde los objetos que están al extremo de una relación pueden “conocerse “entre sí, o una
relación unidireccional donde solamente uno de ellos “conoce” a otro.
1
Dentro de la asociación simple existe la composición y la agregación, que son las dos formas de
relaciones entre clases.
AGREGACIÓN
Representa un tipo de relación muy particular, en la que una clase es instanciada por otro objeto y
clase. La agregación se podría definir como el momento en que dos objetos se unen para trabajar
juntos y así, alcanzar una meta. Un punto a tomar muy en cuenta es que ambos objetos son
independientes entre sí.
En agregación, ambos objetos pueden sobrevivir individualmente, lo que significa que al borrar un
objeto no afectará a la otra entidad.
Para validar la agregación, la frase “Usa un” debe tener sentido,

por ejemplo: El programador usa una computadora. El objeto
computadora va a existir más allá de que exista o no el objeto
programador.
2
COMPOSICIÓN
La composición es una relación más fuerte que la agregación, es una "relación de vida", es decir,
que el tiempo de vida de un objeto está condicionado por el tiempo de vida del objeto que lo
incluye. La composición es un tipo de relación dependiente en dónde un objeto más complejo es
conformado por objetos más pequeños.
En esta situación, la frase “Tiene un”, debe tener sentido, por

ejemplo: el cliente tiene una cuenta bancaria. Esta relación es
una composición, debido a que al eliminar el cliente la cuenta
bancaria no tiene sentido, y también se debe eliminar, es decir,
la cuenta existe sólo mientras exista el cliente.
P¿CÓMO SE VE EN CÓDIGO?P
Recordemos que las relaciones entre clases significan que una clase contiene una referencia a un
objeto u objetos, de la otra clase en la forma de un atributo. Pero a la hora de poner un atributo en
una clase, debemos ver el tipo de relación de esas clases.
En las relaciones, tanto composición como agregación, las relaciones pueden ser de uno a uno,
de cero a uno, de uno a muchos y de cero a muchos. El tipo de relación se ve representada a la
hora de poner el objeto como forma de atributo en la clase que recibe la relación. Por ahora
vamos a trabajar solo con uno a uno y uno a muchos porque son las más comunes.
UNO A UNO
Por cada objeto tenemos una relación con un solo objeto. Ejemplo: para un curso tengo un
profesor. En código se representa con un atributo que sea un objeto.
3
En este ejemplo en el Main vamos a tener que crear un objeto Profesor, para poder guardarlo en
el Curso. Para guardar el objeto podemos usar el set que se va a generar de dicho objeto
Profesor, ya que es un atributo de la clase Curso.
Main
Es muy importante en esta etapa, tener el programa pensado

de antemano antes de empezar a escribir código. Lo mejor es
definirlo primero en papel antes de tocar el teclado.
EJERCICIO PERSONA
Realiza un programa en donde una clase Persona tenga como atributo nombre, apellido y un
objeto de clase Dni. La clase Dni tendrá como atributos la serie (carácter) y número. Prueba
acceder luego a los atributos del dni de la persona creando objetos y jugando desde el main.
UNO A MUCHOS
Por cada objeto tenemos una relación con muchos objetos de una clase. Ejemplo: para un curso
tengo muchos alumnos. En java para guardar varios objetos de una clase utilizamos colecciones. Y
como las listas son las colecciones más rápidas de llenar, utilizamos una lista.
4
En este ejemplo en el Main vamos a tener que crear varios objetos Alumno para después
guardarlos en un ArrayList de tipo Alumno, para poder guardarlo en el Curso. Para guardar el
objeto podemos usar el set que se va a generar de dicho ArrayList de tipo Alumno, ya que es un
atributo de la clase Curso.
Main
EJERCICIO JUGADOR
Realiza un programa en donde exista una clase Jugador que contenga nombre, apellido, posición
y número. Luego otra clase Equipo que contenga una colección de jugadores. Una vez hecho
esto, desde el main recorreremos el equipo mostrando la información de cada jugador.
P¿QUÉ ES UML?P
El lenguaje de modelado unificado (UML) es un lenguaje de modelado de propósito general. El
objetivo principal de UML es definir una forma estándar de visualizar la forma en que se ha
diseñado un sistema mediante diagramas. Es bastante similar a los planos utilizados en otros
campos de la ingeniería.
UML no es un lenguaje de programación, es más bien un lenguaje visual. Usamos diagramas UML
para representar el comportamiento y la estructura de un sistema. Estos diagramas se hacen
siempre previos a la codificación del programa en sí, también para facilitar después la creación
del programa si ya tenemos en claro que debemos crear.
Existen varios tipos de diagramas de programación que podemos hacer con UML, en el que
vamos a hacer hincapié nosotros es el diagrama de clases.
DIAGRAMAS DE CLASES
Es el componente básico de todos los programas orientados a objetos. Usamos diagramas de
clases para representar la estructura de un sistema mostrando las clases del sistema, sus métodos
y atributos. Los diagramas de clases también nos ayudan a identificar la relación entre diferentes
clases u objetos. Ya se relaciones entre clases o herencia.
Cada clase está representada por un rectángulo que tiene una subdivisión de tres
compartimentos: nombre, atributos y métodos.
5
Hay tres tipos de modificadores que se utilizan para decidir la visibilidad de atributos y métodos:
“+” se usa para el modificador de acceso public.
“#” se usa para el modificador de acceso protected.
“-“ se usa para el modificador de acceso private.
Libro
- String titulo
- Integer ejemplares
+ void prestamo()
+ void devolucion()
Si tuviéramos una interfaz, se vería así
<<interface>>
Interfaz
+void metodo()
Nota: El concepto de interfaz se desarrollará en la siguiente guía.
RELACIONES ENTRE CLASES

Las relaciones entre clases se representan con flechas entre las clases. La clase que recibe la
relación de la otra clase, como un objeto de la otra clase, es la clase a la que lo toca el rombo.
Y para representar el tipo de relación, ya sea uno a uno o de uno a muchos, es con un símbolo
para cada relación en la flecha.
A continuación, veremos uno de los muchos ejemplos:
6
Tipo de relación Significado
1…1 Uno a uno
Uno a muchos o
1…* muchos a uno
En el primer ejemplo la Clase A tiene a la clase B por ser una composición y en el segundo
ejemplo, la clase A usa a la clase B por ser una agregación.
HERENCIA
El concepto de herencia se desarrollará en la siguiente guía. La herencia se representa con la
siguiente flecha:
7
Recuerda que la programación no se lleva bien con las tildes u
otros caracteres especiales. Por lo tanto, para que todo
funcione bien, evita que estos existan en la ruta de tus
archivos. Un error muy común que impide que se cree el
diagrama es tener el proyecto dentro de una carpeta
“Programación”, en este caso podrías renombrarla
“Programación” quitando la tilde.
EJERCICIO UML
Realiza el diagrama UML de los ejercicios de manos a la obra que hicimos arriba:
• El de Persona
• Dni y el de Equipo
• Jugadores
Vamos a instalar el easyUML para ver nuestros proyectos como diagramas UML. Encontrarás
cómo instalarlo en Moodle.
Si tienes problemas para instalar pide ayuda o puedes utilizar una página que nos permite hacer
diagramas online:
https://online.visual-paradigm.com/app/diagrams/#diagram:proj=0&type=ClassDiagram.
8
En este módulo de POO, vamos a empezar a ver cómo dos o más clases pueden relacionarse
entre sí, ya sea por una relación entre clases o mediante una herencia de clases.
1. Realizar un programa para que una Persona pueda adoptar un Perro. Vamos a contar de dos
clases. Perro, que tendrá como atributos: nombre, raza, edad y tamaño; y la clase Persona con
atributos: nombre, apellido, edad, documento y Perro.
Ahora deberemos en el main crear dos Personas y dos Perros. Después, vamos a tener que
pensar la lógica necesaria para asignarle a cada Persona un Perro y por ultimo, mostrar desde
la clase Persona, la información del Perro y de la Persona.
2. Realizar el juego de la ruleta rusa de agua en Java. Como muchos saben, el juego se trata de
un número de jugadores, que, con un revolver de agua, el cual posee una sola carga de agua,
se dispara y se moja. Las clases por hacer del juego son las siguientes:
Clase Revolver de agua: esta clase posee los siguientes atributos: posición actual (posición
del tambor que se dispara, puede que esté el agua o no) y posición agua (la posición del
tambor donde se encuentra el agua). Estas dos posiciones, se generarán aleatoriamente.
Métodos:
• llenarRevolver(): le pone los valores de posición actual y de posición del agua. Los valores
deben ser aleatorios.
• mojar(): devuelve true si la posición del agua coincide con la posición actual
• siguienteChorro(): cambia a la siguiente posición del tambor
• toString(): muestra información del revolver (posición actual y donde está el agua)
Clase Jugador: esta clase posee los siguientes atributos: id (representa el número del
jugador), nombre (Empezara con Jugador más su ID, “Jugador 1” por ejemplo) y mojado (indica
si está mojado o no el jugador). El número de jugadores será decidido por el usuario, pero
debe ser entre 1 y 6. Si no está en este rango, por defecto será 6.
Métodos:
• disparo(Revolver r): el método, recibe el revolver de agua y llama a los métodos de

mojar() y siguienteChorro() de Revolver. El jugador se apunta, aprieta el gatillo y si el
revolver tira el agua, el jugador se moja. El atributo mojado pasa a false y el método
devuelve true, sino false.
Clase Juego: esta clase posee los siguientes atributos: Jugadores (conjunto de Jugadores) y
Revolver
Métodos:
• llenarJuego(ArrayList<Jugador>jugadores, Revolver r): este método recibe los jugadores

y el revolver para guardarlos en los atributos del juego.
9
• ronda(): cada ronda consiste en un jugador que se apunta con el revolver de agua y
aprieta el gatillo. Sí el revolver tira el agua el jugador se moja y se termina el juego, sino se
moja, se pasa al siguiente jugador hasta que uno se moje. Si o si alguien se tiene que
mojar. Al final del juego, se debe mostrar que jugador se mojó.
Pensar la lógica necesaria para realizar esto, usando los atributos de la clase Juego.
3. Realizar una baraja de cartas españolas orientada a objetos. Una carta tiene un número entre 1
y 12 (el 8 y el 9 no los incluimos) y un palo (espadas, bastos, oros y copas). Esta clase debe
contener un método toString() que retorne el número de carta y el palo. La baraja estará
compuesta por un conjunto de cartas, 40 exactamente.
Las operaciones que podrá realizar la baraja son:
• barajar(): cambia de posición todas las cartas aleatoriamente.
• siguienteCarta(): devuelve la siguiente carta que está en la baraja, cuando no haya más o
se haya llegado al final, se indica al usuario que no hay más cartas.
• cartasDisponibles(): indica el número de cartas que aún se puede repartir.
• darCartas(): dado un número de cartas que nos pidan, le devolveremos ese número de
cartas. En caso de que haya menos cartas que las pedidas, no devolveremos nada, pero
debemos indicárselo al usuario.
• cartasMonton(): mostramos aquellas cartas que ya han salido, si no ha salido ninguna

indicárselo al usuario
• mostrarBaraja(): muestra todas las cartas hasta el final. Es decir, si se saca una carta y
luego se llama al método, este no mostrara esa primera carta.
10
PEJERCICIOS DE APRENDIZAJE EXTRAP
Estos van a ser ejercicios para reforzar los conocimientos previamente vistos. Estos pueden
realizarse cuando hayas terminado la guía y tengas una buena base sobre lo que venimos
trabajando. Además, si ya terminaste la guía y te queda tiempo libre en las mesas, podes
continuar con estos ejercicios extra, recordando siempre que no es necesario que los termines
para continuar con el tema siguiente. Por último, recordá que la prioridad es ayudar a los
compañeros de la mesa y que cuando tengas que ayudar, lo más valioso es que puedas explicar
el ejercicio con la intención de que tu compañero lo comprenda, y no sólo mostrarlo. ¡Muchas
gracias!
1. Ahora se debe realizar unas mejoras al ejercicio de Perro y Persona. Nuestro programa va a
tener que contar con muchas personas y muchos perros. El programa deberá preguntarle a
cada persona, que perro según su nombre, quiere adoptar. Dos personas no pueden adoptar
al mismo perro, si la persona eligió un perro que ya estaba adoptado, se le debe informar a la
persona.
Una vez que la Persona elige el Perro se le asigna, al final deberemos mostrar todas las
personas con sus respectivos perros.
2. Nos piden hacer un programa sobre un Cine, que tiene una sala con un conjunto de asientos
(8 filas por 6 columnas). De Cine nos interesa conocer la película que se está reproduciendo, la
sala con los espectadores y el precio de la entrada. Luego, de las películas nos interesa saber
el título, duración, edad mínima y director. Por último, del espectador, nos interesa saber su
nombre, edad y el dinero que tiene disponible.
Para representar la sala con los espectadores vamos a utilizar una matriz. Los asientos son
etiquetados por una letra y un número la fila A1 empieza al final del mapa como se muestra en
la tabla. También deberemos saber si el asiento está ocupado por un espectador o no, si esta
ocupado se muestra una X, sino un espacio vacío.
8AX|8BX|8CX|8D |8EX|8FX
7AX|7BX|7CX |7DX|7E |7FX
6AX|6BX|6C |6DX|6EX|6F
5AX|5BX|5CX|5DX|5EX|5FX
4AX|4BX|4CX|4DX|4EX|4FX
3AX|3BX|3CX|3D |3EX|3FX
2AX|2B |2CX|2DX|2EX|2F
1AX|1BX |1CX |1DX |1EX |1FX
Se debe realizar una pequeña simulación, en la que se generen muchos espectadores y se los
ubique en los asientos aleatoriamente (no se puede ubicar un espectador donde ya este
ocupado el asiento).
Los espectadores serán ubicados de uno en uno y para ubicarlos tener en cuenta que sólo se
podrá sentar a un espectador si tiene el dinero suficiente para pagar la entrada, si hay espacio
libre en la sala y si tiene la edad requerida para ver la película. En caso de que el asiento este
ocupado se le debe buscar uno libre.
Al final del programa deberemos mostrar la tabla, podemos mostrarla con la letra y numero de
cada asiento o solo las X y espacios vacíos.
3. Ha llegado el momento de poner de prueba tus conocimientos. Para te vamos a contar que te
ha contratado “La Tercera Seguros”, una empresa aseguradora que brinda a sus clientes
coberturas integrales para vehículos.
Luego de un pequeño relevamiento, te vamos a pasar en limpio los requerimientos del sistema
que quiere realizar la empresa.
11
a. Gestión Integral de clientes. En este módulo vamos a registrar la información personal de
cada cliente que posea pólizas en nuestra empresa. Nombre y apellido, documento, mail,
domicilio, teléfono.
b. Gestión de vehículos. Se registra la información de cada vehículo asegurado. Marca,
modelo, año, número de motor, chasis, color, tipo (camioneta, sedán, etc.).
c. Gestión de Pólizas: Se registrará una póliza, donde se guardará los datos tanto de un
vehículo, como los datos de un solo cliente. Los datos incluidos en ella son: número de
póliza, fecha de inicio y fin de la póliza, cantidad de cuotas, forma de pago, monto total
asegurado, incluye granizo, monto máximo granizo, tipo de cobertura (total, contra
terceros, etc.). Nota: prestar atención al principio de este enunciado y pensar en las
relaciones entre clases. Recuerden que pueden ser de uno a uno, de uno a muchos, de
muchos a uno o de muchos a muchos.
d. Gestión de cuotas: Se registrarán y podrán consultar las cuotas generadas en cada póliza.
Esas cuotas van a contener la siguiente información: número de cuota, monto total de la
cuota, si está o no pagada, fecha de vencimiento, forma de pago (efectivo, transferencia,
etc.).
Debemos realizar el diagrama de clases completo, teniendo en cuenta todos los

requerimientos arriba descriptos. Modelando clases con atributos y sus correspondientes
relaciones.
4. Desarrollar un simulador del sistema de votación de facilitadores en Egg-
El sistema de votación de Egg tiene una clase llamada Alumno con los siguientes atributos:
nombre completo, DNI y cantidad de votos. Además, crearemos una clase Simulador que va a
tener los métodos para manejar los alumnos y sus votaciones. Estos métodos serán llamados
desde el main.
• La clase Simulador debe tener un método que genere un listado de alumnos manera
aleatoria y lo retorne. Las combinaciones de nombre y apellido deben ser generadas de
manera aleatoria. Nota: usar listas de tipo String para generar los nombres y los apellidos.
• Ahora hacer un generador de combinaciones de DNI posibles, deben estar dentro de un

rango real de números de documentos. Y agregar a los alumnos su DNI. Este método
debe retornar la lista de dnis.
• Ahora tendremos un método que, usando las dos listas generadas, cree una cantidad de
objetos Alumno, elegidos por el usuario, y le asigne los nombres y los dnis de las dos
listas a cada objeto Alumno. No puede haber dos alumnos con el mismo dni, pero si con el
mismo nombre.
• Se debe imprimir por pantalla el listado de alumnos.
• Una vez hecho esto debemos generar una clase Voto, esta clase tendrá como atributos,
un objeto Alumno que será el alumno que vota y una lista de los alumnos a los que votó.
• Crearemos un método votación en la clase Simulador que, recibe el listado de alumnos y

para cada alumno genera tres votos de manera aleatoria. En este método debemos
guardar a el alumno que vota, a los alumnos a los que votó y sumarle uno a la cantidad de
votos a cada alumno que reciba un voto, que es un atributo de la clase Alumno.
Tener en cuenta que un alumno no puede votarse a sí mismo o votar más de una vez al
mismo alumno. Utilizar un hashset para resolver esto.
• Se debe crear un método que muestre a cada Alumno con su cantidad de votos y cuales
fueron sus 3 votos.
12
• Se debe crear un método que haga el recuento de votos, este recibe la lista de Alumnos y
comienza a hacer el recuento de votos.
• Se deben crear 5 facilitadores con los 5 primeros alumnos votados y se deben crear 5
facilitadores suplentes con los 5 segundos alumnos más votados. A continuación, mostrar
los 5 facilitadores y los 5 facilitadores suplentes.
13
HERENCIA
• Qué es la herencia
• Para qué sirve
• Cómo heredar entre clases
• Clases abstractas y finales
• Métodos abstractos y finales
• Qué son interfaces
• Cuándo y cómo usar interfaces
P¿QUÉ ES LA HERENCIA?P
La herencia es una relación fuerte entre dos clases donde una clase es padre de otra.
La herencia es un pilar importante de la POO. Es el mecanismo mediante el cual una clase es

capaz de heredar todas las características (atributos y métodos) de otra clase.
Las propiedades comunes se definen en la superclase (clase padre/madre) y las subclases

heredan estas propiedades (Clase hija/o). En esta relación, la frase “Un objeto es un-tipo-de una
superclase” debe tener sentido, por ejemplo: un perro es un tipo de animal, o también, una
heladera es un tipo de electrodoméstico.
La herencia apoya el concepto de "reutilización", es decir, cuando queremos crear una nueva
clase y ya existe una clase que incluye parte del código que queremos, podemos utilizar esa clase
que ya tiene el código que queremos y hacer de la nueva clase una subclase. Al hacer esto,
estamos reutilizando los campos y métodos de la clase existente.
La manera de usar herencia es a través de la palabra extends.
Viendo nuestro ejemplo de la cajonera pensemos que la clase Cajonera podría heredar atributos
de MuebleMadera que le otorgue atributos de materiales, durabilidad, resistencia al fuego. Estas
serán características que también podría heredar una clase Mesa y clase Silla, compartiendo las 3
esos atributos.
1
Cuando en nuestro diseño detectamos que más de una clase
comparte atributos o métodos podemos buscar puntos en
común para diseñar una superclase.
HERENCIA Y ATRIBUTOS
La subclase (Hija) como hemos dicho recibe todos los atributos de la superclase (Madre), y
además la subclase puede tener atributos propios.
El siguiente programa crea una superclase llamada Persona, que crea personas según su nombre,
edad y documento, y una subclase llamada Alumno, que recibe todos los atributos de Persona. De
esta manera se piensa que los atributos de alumno son nombre, edad y documento, que son
propios de cualquier Persona y matera que sería especifico de cada Alumno. Usualmente la
superclase suele ser un concepto muy general y abstracto, para que pueda utilizarse para varias
subclases.
En la superclase podemos observar que los atributos están creados con el modificador de acceso
protected y no private. Esto es porque el modificador de acceso protected permite que las
subclases puedan acceder a los atributos sin la necesidad de getters y setters.
Los atributos se trabajan como protected también, porque una subclase no hereda los miembros
privados de su clase principal. Sin embargo, si la superclase tiene métodos públicos o protegidos
(como getters y setters) para acceder a sus campos privados, estos también pueden ser utilizados
por la subclase. Entonces, para evitar esto, usamos atributos protected.
2
Visibilidad Public Private Protected Default
Desde la misma Clase SI SI SI SI
Desde cualquier Clase del SI NO SI SI

mismo Paquete
Desde una Subclase del SI NO SI SI

mismo Paquete
Desde una Subclase fuera SI NO SI, a través NO

del mismo Paquete de la
herencia
Desde cualquier Clase fuera SI NO NO NO

del Paquete
HERENCIA Y CONSTRUCTORES
Una diferencia entre los constructores y los métodos es que los constructores no se heredan, pero
los métodos sí. Todos los constructores definidos en una superclase pueden ser usados desde
constructores de las subclases a través de la palabra clave super. La palabra clave super es la que
me permite elegir qué constructor, entre los que tiene definida la clase padre, es el que debo usar.
Si la superclase tiene definido el constructor vacío y no colocamos una llamada explícita super, se
llamará el constructor vacío de la superclase.
En el ejemplo podemos ver que el constructor de la clase Alumno utiliza la palabra clave super
para llamar al constructor de la superclase y de esa manera utilizarlo como constructor propio y
además sumarle su atributo materia.
3
La palabra clave super nos sirve para hacer referencia o llamar a los atributos, métodos y
constructores de la superclase en las subclases.
super.atributoClasePadre;
super.metodoClasePadre;
HERENCIA Y MÉTODOS
Todos los métodos accesibles o visibles de una superclase se heredan a sus subclases. Pero,
¿qué ocurre si una subclase necesita que uno de sus métodos heredados funcione de manera
diferente?
Los métodos heredados pueden ser redefinidos en las clases hijas. Este mecanismo se lo llama
sobreescritura. La sobreescritura permite a las clases hijas utilizar un método definido en la
superclase.
Una subclase sobreescribe un método de su superclase cuando define un método con las mismas
características (nombre, número y tipo de argumentos) que el método de la superclase. Las
subclases emplean la sobreescritura de métodos la mayoría de las veces para agregar o modificar
la funcionalidad del método heredado de la clase padre.
La sobreescritura permite que las clases hijas sumen sus métodos en torno al funcionamiento y
Esto se logra poniendo la anotación @Override arriba del método que queremos sobreescribir, el
método debe llamarse igual en la subclase como en la superclase.
Una anotación en Java es una característica que permite

incrustar información suplementaria en un archivo fuente. Esta
información no cambia las acciones de un programa, pero
puede ser utilizada por varias herramientas, tanto durante el
desarrollo como durante el despliegue del programa.
En el ejemplo podemos ver que tenemos el mismo método en la clase Persona, que en la clase
Alumno, el método nos va a informar cuáles son sus capacidades para codear según la clase que
llamemos. Por lo que en la clase Alumno, cuando heredamos el método lo sobreescribimos para
cambiar su funcionamiento, y hacer que diga algo distinto al método de Persona.
En los métodos de la superclase, también podemos hacer que tengan un modificador de acceso
protected, esto hace que los únicos que puedan invocar a ese método sean las subclases.
4
PPOLIMORFISMOP
El término polimorfismo es una palabra de origen griego que significa "muchas formas”. Este
término se utiliza en POO para referirse a la propiedad por la que es posible enviar mensajes
sintácticamente iguales a objetos de tipos distintos, es decir, que la misma operación se realiza
en las clases de diferente forma. Estas operaciones tienen el mismo significado y comportamiento,
pero internamente, cada operación se realiza de diferente forma. El único requisito que deben
cumplir los objetos que se utilizan de manera polimórfica es saber responder al mensaje que se
les envía. Esto hace referencia a la idea de que podemos tener un método definido en la
superclase y que las subclases tengan el mismo método, pero con distintas funcionalidades.
EJERCICIO ANIMAL
Vamos a crear una clase Animal que tenga un método hacerRuido() que devuelva un saludo
“Hola”. Luego haremos clase Perro y clase Gato que extiendan de Animal y sobreescriban el
método hacerRuido() con el ruido que corresponda a cada uno. Luego, en el main vamos a crear
un ArrayList de animales y los siguientes animales
Animal a = new Animal();
Animal b = new Perro();
Animal c = new Gato();
Agregaremos a la lista a cada uno y luego, con un for each, recorreremos la lista llamando al
método hacerRuido() de cada ítem.
PTIPOS DE HERENCIAP
Dentro del concepto de herencia tenemos distintos tipos de herencia, los veremos ahora.
HERENCIA ÚNICA
En la herencia única, las subclases heredan las características de solo una superclase. En la
imagen a continuación, la clase A sirve como clase base para la clase derivada B.
5
HERENCIA JERÁRQUICA
En la herencia jerárquica, una clase sirve como una superclase (clase base) para más de una
subclase. En la imagen inferior, la clase A sirve como clase base para la clase derivada B, C y D.
B C D
HERENCIA MULTINIVEL
En la herencia multinivel, una clase derivada heredará una clase base y, además, la clase derivada
también actuará como la clase base de otra clase. En la imagen inferior, la clase A sirve como
clase base para la clase derivada B, que a su vez sirve como clase base para la clase derivada C.
En Java, una clase no puede acceder directamente a los miembros de los “abuelos”.
Clase
A
Base
Clase
B
Intermedia
Clase
C
Derivada
6
HERENCIA MÚLTIPLE (A TRAVÉS DE INTERFACES)
En Herencia múltiple, una clase puede tener más de una superclase y heredar características de
todas las clases principales. Tenga en cuenta que Java no admite herencia múltiple con clases. En
Java, podemos lograr herencia múltiple solo a través de Interfaces. En la imagen a continuación, la
Clase C se deriva de la interfaz A y B.
A B
Interfaces las veremos más adelante en esta misma guía.
PMODIFICADORES DE CLASES Y MÉTODOSP

CLASES FINALES
El modificador final puede utilizarse también como modificador de clases. Al marcar una clase
como final impedimos que se generen hijos a partir de esta clase, es decir, cortamos la jerarquía
de herencia.
public final class Animal{ }
MÉTODOS FINALES
El modificador final puede utilizarse también como modificador de métodos. La herencia nos
permite reutilizar el código existente y uno de los mecanismos es la crear una subclase y
sobrescribir alguno de los métodos de la clase padre. Cuando un método es marcado como final
en una clase, evitamos que sus clases hijas puedan sobrescribir estos métodos.
public final void método(){ }
Es útil declarar algo como final cuando no queremos que nada

lo pueda modificar.
7
CLASES ABSTRACTAS
En java se dice que una clase es abstracta cuando no se permiten instancias de esa clase, es decir
que no se pueden crear objetos. Nosotros haríamos una clase abstracta por dos razones.
Usualmente las clases abstractas suelen ser las superclases, esto lo hacemos porque creemos
que la superclase o clase padre, no debería poder instanciarse. Por ejemplo, si tenemos una clase
Animal, el usuario no debería poder crear un Animal, sino que solo debería poder instanciar solo
objetos de las subclases
public abstract class Animal { }
Otra razón es porque decidimos hacer métodos abstractos en nuestra superclase. Cuando una
clase posee al menos un método abstracto esa clase necesariamente debe ser marcada como
abstracta.
MÉTODOS ABSTRACTOS
Un método abstracto es un método declarado, pero no implementado, es decir, es un método del
que solo se escribe su nombre, parámetros, y tipo devuelto, pero no su código de
implementación. Estos métodos se heredan y se sobreescriben por las clases hijas quienes son
las responsables de implementar sus funcionalidades.
¿Qué utilidad tiene un método abstracto? Podemos ver un

método abstracto como una palanca que fuerza dos cosas: la
primera, que no se puedan crear objetos de una clase. La
segunda, que todas las subclases sobreescriban el método
declarado como abstracto.
8
PINTERFACESP
Una interfaz es sintácticamente similar a una clase abstracta, en la que puede especificar uno o
más métodos que no tienen cuerpo. Esos métodos deben ser implementados por una clase para
que se definan sus acciones.
Por lo tanto, una interfaz especifica qué se debe hacer, pero no cómo hacerlo. Una vez que se
define una interfaz, cualquier cantidad de clases puede implementarla. Además, una clase puede
implementar cualquier cantidad de interfaces.
Para implementar una interfaz, una clase debe proporcionar cuerpos (implementaciones) para los
métodos descritos por la interfaz. Cada clase es libre de determinar los detalles de su propia
implementación. Dos clases pueden implementar la misma interfaz de diferentes maneras,
pero cada clase aún admite el mismo conjunto de métodos.
Para decirle a Java que estamos trabajando sobre una interfaz vamos a tener que utilizar la
palabra interface, esto se vería así
public interface nombreInterfaz { }
Para una interfaz, el modificador de acceso es public o no se usa. Cuando no se incluye ningún
modificador de acceso, los resultados de acceso serán los predeterminados y la interfaz solo
están disponibles para otros miembros de su paquete. Si se declara como public, la interfaz puede
ser utilizada por cualquier otra clase. El nombre de la interfaz puede ser cualquier identificador
válido.
INSTANCIAR UNA INTERFAZ

Aunque las interfaces van a ser implementadas por clases y van a tener métodos, al igual que una
clase abstracta, esta, no se va a poder instanciar. La definición de un interfaz no tiene constructor,
por lo que no es posible invocar el operador new sobre un tipo interfaz, por lo que no podemos
crear objetos del tipo interfaz.
Vamos a crear una interfaz con un método abstracto. Luego desde el main intentaremos instanciar
un objeto a partir de la interfaz
IMPLEMENTACIÓN DE INTERFACES
Una vez que se ha definido una interfaz, una o más clases pueden implementar esa interfaz. Para
implementar una interfaz, incluya la palabra reservada implements en la definición de clase.
public class Clase implements Interfaz { }
Los métodos de la interfaz los podemos implementar en nuestra clase y se van a sobrescribir
desde la interfaz, métodos que recordemos, no tendrán cuerpo. Nuestra tarea será completar
esos métodos que implementamos de la interfaz.
9
MÉTODOS
Los métodos de una interfaz se declaran utilizando solo su tipo de devolución y firma. Son,
esencialmente, métodos abstractos. Por lo tanto, cada clase que incluye dicha interfaz debe
implementar todos sus métodos. En una interfaz, los métodos son implícitamente públicos.
Como podemos ver en la interfaz teníamos dos métodos sin cuerpo y al implementar la interfaz en
nuestra clase, los sobrescribimos y les dimos una funcionalidad a dichos métodos.
¿Qué es una firma?

En Java dos o más métodos dentro de la misma clase pueden
compartir el mismo nombre, siempre que sus declaraciones de
parámetros sean diferentes. Cuando esto sucede, se dice que
estamos usando sobrecarga de métodos (method overloading).
En general sobrecargar un método consiste en declarar
versiones diferentes de él. Y aquí es donde el compilador se
ocupa del resto y donde el término firma cobra importancia.
Una firma es el nombre de un método más su lista de
parámetros. Por lo tanto, cada método en una misma clase, en
términos de sobrecarga, obtiene una firma diferente.
VARIABLES
Las variables declaradas en una interfaz no son variables de instancia. En cambio, son
implícitamente public y final, además, deben inicializarse. Por lo tanto, son esencialmente
constantes. Recordemos que por convención las constantes suelen escribirse en mayúsculas, para
separarlas de las variables.
10
Las constantes definidas en nuestra interfaz pueden ser llamadas en la clase, solo con el nombre y
de esa manera podemos utilizar los valores definidos en la interfaz.
11
Recordemos que todos los ejercicios debemos realizarlos con las clases de servicio. En los
ejercicios se numeran los métodos a escribir, pero no cuáles van en servicio, pueden hablar en el
equipo y dar sus opiniones sobre dónde van. Nos vamos a encontrar con algo nuevo. Vamos a
heredar clases con clases y servicios con servicios. No mezclemos las cosas.
1. Tenemos una clase padre Animal junto con sus 3 clases hijas Perro, Gato, Caballo.
La clase Animal tendrá como atributos el nombre, alimento, edad y raza del Animal.
Crear un método en la clase Animal a través del cual cada clase hija deberá mostrar luego un
mensaje por pantalla informando de que se alimenta. Generar una clase Main que realice lo
siguiente:
2. Crear una superclase llamada Electrodoméstico con los siguientes atributos: precio, color,
consumo energético (letras entre A y F) y peso.
Los constructores que se deben implementar son los siguientes:
• Un constructor vacío.
• Un constructor con todos los atributos pasados por parámetro.
Los métodos a implementar son:
• Métodos getters y setters de todos los atributos.

• Método comprobarConsumoEnergetico(char letra): comprueba que la letra es correcta,
sino es correcta usara la letra F por defecto. Este método se debe invocar al crear el
objeto y no será visible.
• Método comprobarColor(String color): comprueba que el color es correcto, y si no lo es,
usa el color blanco por defecto. Los colores disponibles para los electrodomésticos son
blanco, negro, rojo, azul y gris. No importa si el nombre está en mayúsculas o en
minúsculas. Este método se invocará al crear el objeto y no será visible.
12
• Metodo crearElectrodomestico(): le pide la información al usuario y llena el
electrodoméstico, también llama los métodos para comprobar el color y el consumo. Al
precio se le da un valor base de $1000.
• Método precioFinal(): según el consumo energético y su tamaño, aumentará el valor del
precio. Esta es la lista de precios:
LETRA PRECIO PESO PRECIO
A $1000
Entre 1 y 19 kg $100
B $800
Entre 20 y 49 kg $500
C $600
D $500 Entre 50 y 79 kg $800
E $300 Mayor que 80 kg $1000
F $100
A continuación, se debe crear una subclase llamada Lavadora, con el atributo carga,
además de los atributos heredados.
Los constructores que se implementarán serán:
• Un constructor con la carga y el resto de los atributos heredados. Recuerda que debes
llamar al constructor de la clase padre.
Los métodos que se implementara serán:
• Método get y set del atributo carga.

• Método crearLavadora (): este método llama a crearElectrodomestico() de la clase
padre, lo utilizamos para llenar los atributos heredados del padre y después llenamos
el atributo propio de la lavadora.
• Método precioFinal(): este método será heredado y se le sumará la siguiente
funcionalidad. Si tiene una carga mayor de 30 kg, aumentará el precio en $500, si la
carga es menor o igual, no se incrementará el precio. Este método debe llamar al
método padre y añadir el código necesario. Recuerda que las condiciones que hemos
visto en la clase Electrodoméstico también deben afectar al precio.
Se debe crear también una subclase llamada Televisor con los siguientes atributos:
resolución (en pulgadas) y sintonizador TDT (booleano), además de los atributos
heredados.
Los constructores que se implementarán serán:
• Un constructor con la resolución, sintonizador TDT y el resto de los atributos
heredados. Recuerda que debes llamar al constructor de la clase padre.
13
Los métodos que se implementara serán:
• Método get y set de los atributos resolución y sintonizador TDT.
• Método crearTelevisor(): este método llama a crearElectrodomestico() de la clase

padre, lo utilizamos para llenar los atributos heredados del padre y después llenamos
los atributos del televisor.
• Método precioFinal(): este método será heredado y se le sumará la siguiente

funcionalidad. Si el televisor tiene una resolución mayor de 40 pulgadas, se
incrementará el precio un 30% y si tiene un sintonizador TDT incorporado, aumentará
$500. Recuerda que las condiciones que hemos visto en la clase Electrodomestico
también deben afectar al precio.
Finalmente, en el main debemos realizar lo siguiente:
Vamos a crear una Lavadora y un Televisor y llamar a los métodos necesarios para mostrar
el precio final de los dos electrodomésticos.
3. Siguiendo el ejercicio anterior, en el main vamos a crear un ArrayList de Electrodomésticos

para guardar 4 electrodomésticos, ya sean lavadoras o televisores, con valores ya asignados.
Luego, recorrer este array y ejecutar el método precioFinal() en cada electrodoméstico. Se

deberá también mostrar el precio de cada tipo de objeto, es decir, el precio de todos los
televisores y el de las lavadoras. Una vez hecho eso, también deberemos mostrar, la suma del
precio de todos los Electrodomésticos. Por ejemplo, si tenemos una lavadora con un precio de
2000 y un televisor de 5000, el resultado final será de 7000 (2000+5000) para
electrodomésticos, 2000 para lavadora y 5000 para televisor.
4. Se plantea desarrollar un programa que nos permita calcular el área y el perímetro de formas
geométricas, en este caso un círculo y un rectángulo. Ya que este cálculo se va a repetir en las
dos formas geométricas, vamos a crear una Interfaz, llamada calculosFormas que tendrá, los
dos métodos para calcular el área, el perímetro y el valor de PI como constante.
Desarrollar el ejercicio para que las formas implementen los métodos de la interfaz y se
calcule el área y el perímetro de los dos. En el main se crearán las formas y se mostrará el
resultado final.
Área circulo: PI * radio ^ 2 / Perímetro circulo: PI * diámetro.
Área rectángulo: base * altura / Perímetro rectángulo: (base + altura) * 2.
14
PEJERCICIOS DE APRENDIZAJE EXTRAP
trabajando. Además, si ya terminaste la guía y te queda tiempo libre en las mesas, podes continuar
con estos ejercicios extra, recordando siempre que no es necesario que los termines para
continuar con el tema siguiente. Por último, recordá que la prioridad es ayudar a los compañeros
de la mesa y que cuando tengas que ayudar, lo más valioso es que puedas explicar el ejercicio
con la intención de que tu compañero lo comprenda, y no sólo mostrarlo. ¡Muchas gracias!
1. En un puerto se alquilan amarres para barcos de distinto tipo. Para cada Alquiler se guarda: el
nombre, documento del cliente, la fecha de alquiler, fecha de devolución, la posición del
amarre y el barco que lo ocupará.
Un Barco se caracteriza por: su matrícula, su eslora en metros y año de fabricación.
Sin embargo, se pretende diferenciar la información de algunos tipos de barcos especiales:
• Número de mástiles para veleros.

• Potencia en CV para barcos a motor.
• Potencia en CV y número de camarotes para yates de lujo.
Un alquiler se calcula multiplicando el número de días de ocupación (calculado con la fecha de

alquiler y devolución), por un valor módulo de cada barco (obtenido simplemente
multiplicando por 10 los metros de eslora).
En los barcos de tipo especial el módulo de cada barco se calcula sacando el módulo normal y
sumándole el atributo particular de cada barco. En los veleros se suma el número de mástiles,
en los barcos a motor se le suma la potencia en CV y en los yates se suma la potencia en CV y
el número de camarotes.
Utilizando la herencia de forma apropiada, deberemos programar en Java, las clases y los
métodos necesarios que permitan al usuario elegir el barco que quiera alquilar y mostrarle el
precio final de su alquiler.
2. Crear una superclase llamada Edificio con los siguientes atributos: ancho, alto y largo. La clase
edificio tendrá como métodos:
• Método calcularSuperficie(): calcula la superficie del edificio.
• Método calcularVolumen(): calcula el volumen del edifico.
Estos métodos serán abstractos y los implementarán las siguientes clases:
• Clase Polideportivo con su nombre y tipo de instalación que puede ser Techado o
Abierto, esta clase implementará los dos métodos abstractos y los atributos del padre.
• Clase EdificioDeOficinas con sus atributos número de oficinas, cantidad de personas

por oficina y número de pisos. Esta clase implementará los dos métodos abstractos y
los atributos del padre.
De esta clase nos interesa saber cuántas personas pueden trabajar en todo el edificio, el
usuario dirá cuántas personas entran en cada oficina, cuantas oficinas y el número de piso
(suponiendo que en cada piso hay una oficina). Crear el método cantPersonas(), que muestre
cuantas personas entrarían en un piso y cuantas en todo el edificio.
15
Por último, en el main vamos a crear un ArrayList de tipo Edificio. El ArrayList debe contener
dos polideportivos y dos edificios de oficinas. Luego, recorrer este array y ejecutar los
métodos calcularSuperficie y calcularVolumen en cada Edificio. Se deberá mostrar la
superficie y el volumen de cada edificio.
Además de esto, para la clase Polideportivo nos interesa saber cuántos polideportivos son
techados y cuantos abiertos. Y para la clase EdificioDeOficinas deberemos llamar al método
cantPersonas() y mostrar los resultados de cada edificio de oficinas.
3. Una compañía de promociones turísticas desea mantener información sobre la infraestructura

de alojamiento para turistas, de forma tal que los clientes puedan planear sus vacaciones de
acuerdo con sus posibilidades. Los alojamientos se identifican por un nombre, una dirección,
una localidad y un gerente encargado del lugar. La compañía trabaja con dos tipos de
alojamientos: Hoteles y Alojamientos Extrahoteleros.
Los Hoteles tienen como atributos: Cantidad de Habitaciones, Número de Camas, Cantidad de
Pisos, Precio de Habitaciones. Y estos pueden ser de cuatro o cinco estrellas. Las
características de las distintas categorías son las siguientes:
• Hotel **** Cantidad de Habitaciones, Número de camas, Cantidad de Pisos, Gimnasio,

Nombre del Restaurante, Capacidad del Restaurante, Precio de las Habitaciones.
• Hotel ***** Cantidad de Habitaciones, Número de camas, Cantidad de Pisos, Gimnasio,

Nombre del Restaurante, Capacidad del Restaurante, Cantidad Salones de
Conferencia, Cantidad de Suites, Cantidad de Limosinas, Precio de las Habitaciones.
Los gimnasios pueden ser clasificados por la empresa como de tipo “A” o de tipo “B”, de
acuerdo a las prestaciones observadas. Las limosinas están disponibles para cualquier
cliente, pero sujeto a disponibilidad, por lo que cuanto más limosinas tenga el hotel, más caro
será.
El precio de una habitación debe calcularse de acuerdo con la siguiente fórmula:

PrecioHabitación = $50 + ($1 x capacidad del hotel) + (valor agregado por restaurante) + (valor
agregado por gimnasio) + (valor agregado por limosinas).
Donde:
Valor agregado por el restaurante:
• $10 si la capacidad del restaurante es de menos de 30 personas.
• $30 si está entre 30 y 50 personas.
• $50 si es mayor de 50.
Valor agregado por el gimnasio:
• $50 si el tipo del gimnasio es A.
• $30 si el tipo del gimnasio es B.
Valor agregado por las limosinas:
• $15 por la cantidad de limosinas del hotel.
16
En contraste, los Alojamientos Extra hoteleros proveen servicios diferentes a los de los
hoteles, estando más orientados a la vida al aire libre y al turista de bajos recursos. Por cada
Alojamiento Extrahotelero se indica si es privado o no, así como la cantidad de metros
cuadrados que ocupa. Existen dos tipos de alojamientos extrahoteleros: los Camping y las
Residencias. Para los Camping se indica la capacidad máxima de carpas, la cantidad de baños
disponibles y si posee o no un restaurante dentro de las instalaciones. Para las residencias se
indica la cantidad de habitaciones, si se hacen o no descuentos a los gremios y si posee o no
campo deportivo. Realizar un programa en el que se representen todas las relaciones
descriptas.
Realizar un sistema de consulta que le permite al usuario consultar por diferentes criterios:
• todos los alojamientos.

• todos los hoteles de más caro a más barato.
• todos los campings con restaurante
• todos las residencias que tienen descuento.
4. Sistema Gestión Facultad. Se pretende realizar una aplicación para una facultad que gestione
la información sobre las personas vinculadas con la misma y que se pueden clasificar en tres
tipos: estudiantes, profesores y personal de servicio. A continuación, se detalla qué tipo de
información debe gestionar esta aplicación:
• Por cada persona, se debe conocer, al menos, su nombre y apellidos, su número de

identificación y su estado civil.
• Con respecto a los empleados, sean del tipo que sean, hay que saber su año de
incorporación a la facultad y qué número de despacho tienen asignado.
• En cuanto a los estudiantes, se requiere almacenar el curso en el que están
matriculados.
• Por lo que se refiere a los profesores, es necesario gestionar a qué departamento
pertenecen (lenguajes, matemáticas, arquitectura, ...).
• Sobre el personal de servicio, hay que conocer a qué sección están asignados
(biblioteca, decanato, secretaría, ...).
El ejercicio consiste, en primer lugar, en definir la jerarquía de clases de esta aplicación. A

continuación, debe programar las clases definidas en las que, además de los constructores,
hay que desarrollar los métodos correspondientes a las siguientes operaciones:
• Cambio del estado civil de una persona.

• Reasignación de despacho a un empleado.
• Matriculación de un estudiante en un nuevo curso.
• Cambio de departamento de un profesor.
• Traslado de sección de un empleado del personal de servicio.
• Imprimir toda la información de cada tipo de individuo. Incluya un programa de prueba
que instancie objetos de los distintos tipos y pruebe los métodos desarrollados.
17
MANEJO DE
EXCEPCIONES
• Aprender qué es una excepción
• Aprender cuándo y cómo atrapar una excepción
• Usar bloques Try, Catch y Finally
• Usar cláusulas Throws y Throw
P¿QUÉ SON LAS EXCEPCIONES?P

El término excepción es una abreviación de la frase “Evento Excepcional”. Una excepción es un
evento que ocurre durante la ejecución de un programa que interrumpe el flujo normal de las
instrucciones del programa.
Existen muchas clases de errores que pueden provocar una excepción, desde un desbordamiento
de memoria o un disco duro estropeado hasta un intento de dividir por cero o intentar acceder a
un vector fuera de sus límites. Cuando esto ocurre, la máquina virtual Java crea un objeto de la
clase exception o error y se notifica el hecho al sistema de ejecución. Se dice, que se ha lanzado
una excepción (“Throwing Exception”). Luego, el objeto, llamado excepción, contiene información
sobre el error, incluyendo su tipo y el estado del programa cuando el error ocurrió.
Después de que un método lanza una excepción, el sistema, en tiempo de ejecución, intenta
encontrar algo que maneje esa excepción. El conjunto de posibles “algo” para manejar la
excepción es la lista ordenada de los métodos que habían sido llamados hasta llegar al método
que produjo el error. Esta lista de métodos se conoce como pila de llamadas. Luego, el sistema en
tiempo de ejecución busca en la pila de llamadas el método que contenga un bloque de código
que pueda manejar la excepción. Este bloque de código es llamado manejador de excepciones.
Concretamente, una excepción en java es un objeto que modela un evento excepcional, el cual
no debería haber ocurrido. Como observamos anteriormente, al ocurrir estos tipos de evento la
máquina virtual no debe continuar con la ejecución normal del programa. Es evidente que las
excepciones son objetos especiales, son objetos con la capacidad de cambiar el flujo normal de
ejecución. Cuando se detecta un error, una excepción debe ser lanzada.
Ejemplos de situaciones que provocan una excepción:
• No hay memoria disponible para asignar

• Acceso a un elemento de un array fuera de rango
• Leer por teclado un dato de un tipo distinto al esperado
• Error al abrir un fichero
• División por cero
1
¿TIENEN ALGUNA JERARQUIA?
En Java, todas las excepciones están representadas por clases. Todas las clases de excepción se
derivan de una clase llamada Throwable. Por lo tanto, cuando se produce una excepción en un
programa, se genera un objeto de algún tipo de clase de excepción.
Hay dos subclases directas de Throwable: Exception y Error:
1. Las excepciones de tipo Error están relacionadas con errores que ocurren en la Máquina
Virtual de Java y no en tu programa. Este tipo de excepciones escapan a su control y, por
lo general, tu programa no se ocupará de ellas. Por lo tanto, este tipo de excepciones no
se describen aquí.
2. Los errores que resultan de la actividad del programa están representados por subclases
de Exception. Por ejemplo, dividir por cero, límite de matriz y errores de archivo caen en
esta categoría. En general, tu programa debe manejar excepciones de estos tipos. Una
subclase importante de Exception es RuntimeException, que se usa para representar
varios tipos comunes de errores en tiempo de ejecución.
2
P¿CÓMO SE COMPONE EL MANEJADOR DE EXCEPCIONES?P
El manejo de excepciones Java se gestiona a través de cinco palabras clave: try, catch, throw y
finally. Forman un subsistema interrelacionado en el que el uso de uno, implica el uso del otro.
Las declaraciones del programa que desea supervisar para excepciones están contenidas dentro
de un bloque try. Si se produce una excepción dentro del bloque try, se lanza. Tu código puede
atrapar esta excepción usando catch y manejarlo de una manera racional. Las excepciones
generadas por el sistema son lanzadas automáticamente por el sistema de tiempo de ejecución
de Java. Para lanzar manualmente una excepción, use la palabra clave throw. En algunos casos,
una excepción arrojada por un método debe ser especificada como tal por una cláusula throws.
Cualquier código que debe ejecutarse al salir de un bloque try se coloca en un bloque finally.
Ahora vamos a ver en detalle cada palabra clave dentro del manejo de excepciones.
Lo más importante es adelantarnos a los posibles errores que

puedan generarse en el programa.
EL BLOQUE TRY
Intentar en inglés
Lo primero que hay que hacer para que un método sea capaz de tratar una excepción generada
por la máquina virtual Java o por el propio programa mediante una instrucción throw es encerrar
las instrucciones susceptibles de generarla en un bloque try. En el bloque try vamos a poner una
serie de instrucciones que creemos que puede llegar a tirar una excepción durante su ejecución y
queremos manejarla para evitar la finalización del programa.
try {
Instrucción1;
Intruscción2;
Instrucción3;
Instrucción4
...
Cualquier excepción que se produzca por alguna instrucción, dentro del bloque try será analizada
por el bloque o bloques catch. En el momento en que se produzca la excepción, se abandona el
bloque try, y las instrucciones que sigan al punto donde se produjo la excepción no son
ejecutadas. Cada bloque try debe tener asociado por lo menos un bloque catch.
3
EL BLOQUE CATCH
Atrapar en inglés
Por cada bloque try pueden declararse uno o varios bloques catch, cada uno de ellos capaz de
tratar un tipo u otro de excepción. Para declarar el tipo de excepción que es capaz de tratar un
bloque catch, se declara un objeto cuya clase es la clase de la excepción que se desea tratar o
una de sus superclases.
try {
BloqueDeIntrucciones
} catch (TipoExcepción nombreVariable) {
BloqueCatch
BloqueCatch
Al producirse la excepción dentro de un bloque try, la ejecución del programa se pasa al primer
bloque catch. Si la clase de la excepción se corresponde con la clase o alguna subclase de la
clase declarada en el bloque catch, se ejecuta el bloque de instrucciones catch y a continuación
se pasa el control del programa a la primera instrucción a partir de los bloques try-catch. Lo más
adecuado es utilizar excepciones lo más cercanas al tipo de error previsto, ya que lo que se
pretende es recuperar al programa de alguna condición de error y si “se meten todas las
condiciones en la misma bolsa”, seguramente habrá que averiguar después qué condición de
error se produjo para poder dar una respuesta adecuada.
En este ejemplo en el bloque try hacemos una división por cero, las divisiones por cero generan
un tipo de excepción llamado, ArithmeticExcepction. En el bloque catch ponemos como tipo de
excepción la ArithmeticException y dentro del bloque ponemos un mensaje que explique cual ha
sido el error.
4
MÉTODOS THROWABLE
Lanzable, arrojable en inglés. que algo puede ser lanzado.
Dentro del bloque catch, utilizamos un System.out.print para mostrar el error, pero no hemos
estado haciendo nada con el objeto de excepción en sí mismo. Como muestran todos los
ejemplos anteriores, una cláusula catch especifica un tipo de excepción y un parámetro.
El parámetro recibe el objeto de excepción. Como todas las excepciones son subclases de
Throwable, todas las excepciones admiten los métodos definidos por Throwable.
Estos métodos son:
Método Sintaxis Descripción
Devuelve una descripción de

getMessage String getMessage()
la excepción
Devuelve un objeto
Throwable que contiene un
fillInStackTrace Throwable fillInStackTrace() seguimiento de pila completo.
Este objeto se puede volver a
lanzar.
Devuelve un objeto String

que contiene una descripción
completa de la excepción.
toString String toString() Este método lo llama println()
cuando se imprime un objeto
Throwable.
5
EL BLOQUE FINALLY
Finalmente en inglés
El bloque finally se utiliza para ejecutar un bloque de instrucciones sea cual sea la excepción que
se produzca. Este bloque se ejecutará siempre, incluso si no se produce ninguna excepción. Sirve
para no tener que repetir código en el bloque try y en los bloques catch. El bloque finally es un
buen lugar en donde liberar los recursos tomados dentro del bloque de intento.
try {
BloqueDeIntrucciones
MensajeDeError
MensajeDeError
} finally {
CodigoFinal
}
LA CLAÚSULA THROWS
Lanza (en presente) en inglés, que lanza algo.
La cláusula throws lista las excepciones que un método puede lanzar. Los tipos de excepciones
que lanza el método se especifica después de los paréntesis de un método, con una cláusula
throws. Un método puede lanzar objetos de la clase indicada o de subclases de la clase indicada.
Java distingue entre las excepciones verificadas y errores. Las excepciones verificadas deben
aparecer en la cláusula throws de ese método. Como las RuntimeExceptions y los Errores pueden
aparecer en cualquier método, no tienen que listarse en la cláusula throws y es por esto que
decimos que no están verificadas. Todas las excepciones que no son RuntimeException y que un
método puede lanzar deben listarse en la cláusula throws del método y es por eso que decimos
que están verificadas. El requisito de atrapar excepciones en Java exige que el programador
atrape todas las excepciones verificadas o bien las coloque en la cláusula throws de un método.
6
Si la excepción no se trata, el manejador de excepciones realiza lo siguiente:
• Muestra la descripción de la excepción.
• Muestra la traza de la pila de llamadas.
• Provoca el final del programa.
Colocar una excepción en la cláusula throws obliga a otros métodos a ocuparse de la excepción.
Esto se puede hacer colocando otro throws al método que llama al método, con el tipo de
excepción que podría tirar o rodear el llamado del método con un try-catch, y de esa manera que
el try-catch se encargue de manejar la excepción que podría tirar el método.
[acceso][modificador][tipo] nombreFuncion() throws TipoDeExcepcion {
Bloque de instrucciones
Ejemplo:
7
LA PALABRA THROW
Lanzar (en infinitivo) en inglés. Cuando pase algo, lanzar esto.
Los programas escritos en Java pueden lanzar excepciones explícitamente mediante la

instrucción throw, lo que facilita la devolución de un “código de error” al método que invocó el
método que causó el error. La cláusula throw debe ir seguida del tipo de excepción que
queremos que lance el método. Puede lanzarse cualquier tipo de excepción que implemente la
interfaz Throwable.
Cuando se lanza una excepción usando la palabra throw, el flujo de ejecución del programa se
detiene y el control se transfiere al bloque try-catch más cercano que coincida con el tipo de
excepción lanzada. Si no se encuentra tal coincidencia, el controlador de excepciones
predeterminado finaliza el programa. La palabra clave throw es útil para lanzar excepciones
basadas en ciertas condicione, por ejemplo, si un usuario ingresa datos incorrectos. También es
útil para lanzar excepciones personalizadas específicas para un programa o aplicación.
Cuando utilicemos la palabra throw en un método, vamos a tener que agregarle la palabra throws
al método con la excepción que va a tirar nuestro throw. De esa manera avisamos que cuando se
llame al método hay que manejar una posible excepción.
throw new TipoExcepcion(“Mensaje de error”);
Ejemplo:
En este método recibimos una lista y un numero para agregar a dicha lista. El método contiene la
palabra throws para avisar que este método puede tirar una excepción
8
En este módulo vamos a empezar a manejar los errores y las excepciones de nuestro código para
poder seguir trabajando sin que el código se detenga.
1. Inicializar un objeto de la clase Persona ejercicio 3 de la guía 8 Servicios, a null y tratar

de invocar el método esMayorDeEdad() a través de ese objeto. Luego, englobe el código
con una cláusula try-catch para probar la nueva excepción que debe ser controlada.
2. Definir una Clase que contenga algún tipo de dato de tipo array y agregue el código para
generar y capturar una excepción ArrayIndexOutOfBoundsException (índice de arreglo fuera
de rango).
3. Defina una clase llamada DivisionNumero. En el método main utilice un Scanner para leer dos
números en forma de cadena. A continuación, utilice el método parseInt() de la clase Integer,
para convertir las cadenas al tipo int y guardarlas en dos variables de tipo int. Por ultimo realizar
una división con los dos numeros y mostrar el resultado.
4. Todas estas operaciones puede tirar excepciones a manejar, el ingreso por teclado puede
causar una excepción de tipo InputMismatchException, el método Integer.parseInt() si la cadena
no puede convertirse a entero, arroja una NumberFormatException y además, al dividir un
número por cero surge una ArithmeticException. Manipule todas las posibles excepciones
utilizando bloques try/catch para las distintas excepciones
5. Escribir un programa en Java que juegue con el usuario a adivinar un número. La computadora
debe generar un número aleatorio entre 1 y 500, y el usuario tiene que intentar adivinarlo. Para
ello, cada vez que el usuario introduce un valor, la computadora debe decirle al usuario si el
número que tiene que adivinar es mayor o menor que el que ha introducido el usuario. Cuando
consiga adivinarlo, debe indicárselo e imprimir en pantalla el número de veces que el usuario
ha intentado adivinar el número. Si el usuario introduce algo que no es un número, se debe
controlar esa excepción e indicarlo por pantalla. En este último caso también se debe contar el
carácter fallido como un intento.
6. Dado el método metodoA de la clase A, indique:
a) ¿Qué sentencias y en qué orden se ejecutan si se produce la excepción MioException?

b) ¿Qué sentencias y en qué orden se ejecutan si no se produce la excepción MioException?
class A {
public void metodoA() {
sentencia_a1
sentencia_a2
try {
sentencia_a3
sentencia_a4
} catch (MioException e){
sentencia_a6
}
sentencia_a5
}
}
9
7. Dado el método metodoB de la clase B, indique:
class B {
public void metodoB() {
sentencia_b1
try {
sentencia_b2
sentencia_b3
}
finally
sentencia_b4
}
}
8. Indique que se mostrará por pantalla cuando se ejecute cada una de estas clases:
class Uno{
private static int metodo() {
int valor=0;
try {
valor = valor+1;
valor = valor + Integer.parseInt (”42”);
valor = valor +1;
System.out.println(”Valor final del try:” + valor) ;
} catch (NumberFormatException e) {
Valor = valor + Integer.parseInt(”42”);
System.out.println(“Valor final del catch:” + valor);
} finally {
valor = valor + 1;
System.out.println(”Valor final del finally: ” + valor) ;
}
valor = valor +1;
System.out.println(”Valor antes del return: ” + valor) ;
return valor;
}
10
public static void main (String[] args) {
try {
System.out.println (metodo()) ;
}catch(Exception e) {
System.err.println(”Excepcion en metodo() ”) ;
e.printStackTrace();
}
}
}
class Dos{
private static int metodo() {
int valor=0;
try{
valor = valor + 1;
valor = valor + Integer.parseInt (”W”);
valor = valor + 1;
System.out.println(”Valor final del try: ” + valor) ;
} catch ( NumberFormatException e ) {
valor = valor + Integer.parseInt (”42”);
System.out.println(”Valor final del catch: ” + valor) ;
} finally {
valor = valor + 1;
System.out.println(”Valor final del finally: ” + valor) ;
}
valor = valor + 1;
return valor;
}

try{
System.out.println ( metodo ( ) ) ;
} catch(Exception e) {
System.err.println ( ” Excepcion en metodo ( ) ” ) ;
}
}
}
11
class Tres{
private static int metodo( ) {
int valor=0;
try{
valor = valor + 1;
valor = valor + 1;
System.out.println(”Valor final del try: ” + valor);
} catch(NumberFormatException e) {
System.out.println(”Valor final del catch: ” + valor);
} finally{
valor = valor + 1;
System.out.println(”Valor final del finally:” + valor);
}
valor = valor + 1;
return valor;
}

try{
System.out.println( metodo ( ) ) ;
} catch(Exception e) {
System.err.println(”Excepcion en metodo ( ) ” ) ;
}
}
}
9. Dado el método metodoC de la clase C, indique:
c) ¿Qué sentencias y en qué orden se ejecutan si se produce la excepción TuException?
class C {
void metodoC() throws TuException{
sentencia_c1
try {
sentencia_c2
sentencia_c3
12
sentencia_c4
} catch (TuException e){
sentencia_c5
throw (e)
}
finally
sentencia_c6
}
}
IMPORTANTE: A partir de la próxima guía se debe aplicar en

todos los ejercicios el manejo de excepciones cada vez que sea
necesario controlar una posible excepción.
13
EJERCICIO INTEGRADOR COMPLEMENTARIO
Este ejercicio va a requerir que utilicemos todos conocimientos previamente vistos en esta y otras
guías. Estos pueden realizarse cuando hayas terminado todas las guías y tengas una buena base
sobre todo lo que veníamos trabajando. Además, si ya terminaste la guía y te queda tiempo libre
en las mesas, podes continuar con este ejercicio complementario, recordando siempre que no es
necesario que los termines para continuar con el tema siguiente. Este ejercicio, no lleva nota y es
solamente para medir nuestros conocimientos. Por ultimo, recordá que la prioridad es ayudar a
los compañeros de la mesa y que cuando tengas que ayudar, lo más valioso es que puedas
explicar el ejercicio con la intención de que tu compañero lo comprenda, y no sólo mostrarlo.
¡Muchas gracias!
ARMADURA IRON MAN:

J.A.R.V.I.S. es una inteligencia artificial desarrollada por Tony Stark. Está programado para hablar
con voz masculina y acento británico. Actualmente se encarga de todo lo relacionado con la
información doméstica de su casa, desde los sistemas de calefacción y refrigeración hasta los Hot
Rod que Stark tiene en su garage.
Tony Stark quiere adaptar a J.A.R.V.I.S. para que lo asista en el uso de sus armaduras, por lo tanto,
serás el responsable de llevar adelante algunas de estas tareas.
El objetivo de JARVIS es que analice intensivamente toda la información de la armadura y del

entorno y en base a esto tome decisiones inteligentes.
En este trabajo se deberá crear en el proyecto una clase llamada Armadura que modele toda la
información y las acciones que pueden efectuarse con la Armadura de Iron Man. La armadura de
Iron Man es un exoesqueleto mecánico ficticio usado por Tony Stark cuando asume la identidad
de Iron Man. La primera armadura fue creada por Stark y Ho Yinsen, mientras estuvieron
prisioneros.
Las armaduras de Stark se encuentran definidas por un color primario y un color secundario. Se
encuentran compuestas de dos propulsored, uno en cada bota; y dos repulsores, uno en cada
guante (los repulsores se utilizan también como armas). Tony los utiliza en su conjunto para volar.
La armadura tiene un nivel de resistencia, que depende del material con el que está fabricada, y
se mide con un número entero cuya unidad de medida de dureza es Rockwell
(https://es.wikipedia.org/wiki/Dureza_Rockwell). Todas las armaduras poseen un nivel de salud el
cual se mide de 0 a 100. Además, Tony tiene un generador, el cual le sirve para salvarle la vida en
cada instante de tiempo alejando las metrallas de metal de su corazón y también para alimentar
de energía a la armadura. La batería a pesar de estar en el pecho de Tony, es considerada como
parte de la armadura.
La armadura también posee una consola en el casco, a través de la cual JARVIS le escribe
información a Iron Man. En el casco también se encuentra un sintetizador por donde JARVIS
susurra cosas al oído de Tony. Cada dispositivo de la armadura de Iron Man (botas, guantes,
consola y sintetizador) tienen un consumo de energía asociado.
En esta primera etapa con una armadura podremos: caminar, correr, propulsar, volar, escribir y
leer.
• Al caminar la armadura hará un uso básico de las botas y se consumirá la energía

establecida como consumo en la bota por el tiempo en el que se camine.
• Al correr la armadura hará un uso normal de las botas y se consumirá el doble de la

energía establecida como consumo en la bota por el tiempo en el que se corra.
14
• Al propulsarse la armadura hará un uso intensivo de las botas utilizando el triple de la
energía por el tiempo que dure la propulsión.
• Al volar la armadura hará un uso intensivo de las botas y de los guantes un uso normal
consumiendo el triple de la energía establecida para las botas y el doble para los guantes.
• Al utilizar los guantes como armas el consumo se triplica durante el tiempo del disparo.
• Al utilizar las botas para caminar o correr el consumo es normal durante el tiempo que se
camina o se corra.
• Cada vez que se escribe en la consola o se habla a través del sintetizador se consume lo
establecido en estos dispositivos. Solo se usa en nivel básico.
• Cada vez que se efectúa una acción se llama a los métodos usar del dispositivo se le pasa
el nivel de intensidad y el tiempo. El dispositivo debe retornar la energía consumida y la
armadura deberá informar al generador se ha consumido esa cantidad de energía.
Modele las clases, los atributos y los métodos necesarios para poder obtener un modelo real de la
armadura y del estado de la misma.
Mostrando Estado
Hacer un método que JARVIS muestre el estado de todos los dispositivos y toda la información de
la Armadura.
Estado de la Batería
Hacer un método para que JARVIS informe el estado de la batería en porcentaje a través de la
consola. Poner como carga máxima del reactor el mayor float posible. Ejecutar varias acciones y
mostrar el estado de la misma.
Mostrar Información del Reactor
Hacer un método para que JARVIS informe el estado del reactor en otras dos unidades de
medida. Hay veces en las que Tony tiene pretensiones extrañas. Buscar en Wikipedia la tabla de
transformaciones.
Sufriendo Daños
A veces los dispositivos de la armadura sufren daños para esto cada dispositivo contiene un
atributo público que dice si el dispositivo se encuentra dañado o no. Al utilizar un dispositivo
existe un 30% de posibilidades de que se dañe.
La armadura solo podrá utilizar dispositivos que no se encuentren dañados.
Modifique las clases que sean necesarias para llevar adelante este comportamiento.
Reparando Daños
Hay veces que se puede reparar los daños de un dispositivo, en general es el 40% de las veces
que se puede hacer. Utilizar la clase Random para modelar este comportamiento. En caso de estar
dentro de la probabilidad (es decir probabilidad menor o igual al 40%) marcar el dispositivo como
sano. Si no dejarlo dañado.
Revisando Dispositivos
Los dispositivos son revisados por JARVIS para ver si se encuentran dañados. En caso de
encontrar un dispositivo dañado se debe intentar arreglarlo de manera insistente. Para esos
intentos hay un 30% de posibilidades de que el dispositivo quede destruido, pero se deberá
intentar arreglarlo hasta que lo repare, o bien hasta que quede destruido.
15
Hacer un método llamado revisar dispositivos que efectúe lo anteriormente descrito, el
mecanismo insistente debe efectuarlo con un bucle do while.
Radar Versión 1.0
JARVIS posee también incorporado un sistema que usa ondas electromagnéticas para medir
distancias, altitudes, ubicaciones de objetos estáticos o móviles como aeronaves barcos,
vehículos motorizados, formaciones meteorológicas y por su puesto enemigos de otro planeta.
Su funcionamiento se basa en emitir un impulso de radio, que se refleja en el objetivo y se recibe

típicamente en la misma posición del emisor.
Las ubicaciones de los objetos están dadas por las coordenadas X, Y y Z. Los objetos pueden ser
marcados o no como hostiles. JARVIS también puede detectar la resistencia del objeto, y puede
detectar hasta 10 objetos de manera simultánea.
JARVIS puede calcular la distancia a la que se encuentra cada uno de los objetos, para esto
siempre considera que la armadura se encuentra situada en la coordenada (0,0,0).
Hacer un método que informen a qué distancia se encuentra cada uno de los enemigos. Usar la
clase Math de Java.
Simulador
Hacer un método en JARVIS que agregue en radar objetos, hacer que la resistencia, las
coordenadas y la hostilidad sean aleatorios utilizando la clase random. Utilizar la clase Random.
¿Qué ocurre si quiero añadir más de 10 objetos?
¿Qué ocurre si cuando llevo 8 enemigos aumento la capacidad del vector?
Destruyendo Enemigos
Desarrollar un método para que JARVIS que analice todos los objetos del radar y si son hostiles
que les dispare. El alcance de los guantes es de 5000 metros, si el objeto se encuentra fuera de
ese rango no dispara.
JARVIS al detectar un enemigo lo atacará hasta destruirlo, la potencia del disparo es inversamente
proporcional a la distancia al a que se encuentra el enemigo y se descontará de la resistencia del
enemigo. El enemigo se considera destruido si su resistencia es menor o igual a cero.
JARVIS solo podrá disparar si el dispositivo está sano y si su nivel de batería lo permite. Si tiene
los dos guantes sanos podrá disparar con ambos guantes haciendo más daño. Resolver utilizando
un for each para recorrer el arreglo y un while para destruir al enemigo.
Acciones Evasivas
Desarrollamos un método para que JARVIS que analice todos los objetos del radar y si son
hostiles que les dispare. Modificar ese método para que si el nivel de batería es menor al 10% se
corten los ataques y se vuelve lo suficientemente lejos para que el enemigo no nos ataque.
Deberíamos alejarnos por lo menos 10 km enemigo. Tener en cuenta que la velocidad de vuelo
promedio es de 300 km / hora.
16
Bibliografía
Información sacada de las paginas:
- https://www.oracle.com/ar/database/what-is-a-relational-database/
- https://www.geeksforgeeks.org/sql-tutorial/
17
ACCESO A BASES
DE DATOS DESDE
JAVA: JDBC
• Qué es y cómo se compone JDBC
• Cómo se conecta a la base de datos
• Qué es un driver
• Ejecutar Querys desde Java
• Obtener datos de la base de datos
• Usar el Patrón de Diseño DAO
P¿QUE ES JDBC?P
Java™ Database Connectivity (JDBC) es la especificación JavaSoft de una Interfaz de
Programación de Aplicaciones (API) estándar que permite que los programas Java accedan a
sistemas de gestión de bases de datos. La API JDBC consiste en un conjunto de interfaces y
clases escritas en el lenguaje de programación Java.
Con estas interfaces y clases estándar, los programadores pueden escribir aplicaciones que se
conecten con bases de datos, envíen consultas escritas en el lenguaje de consulta estructurada
(SQL) y procesen los resultados.
Puesto que JDBC es una especificación estándar, un programa Java que utilice la API JDBC
puede conectar con cualquier sistema de gestión de bases de datos (DBMS), siempre y cuando
haya un driver para dicho DBMS en concreto.
Las API son mecanismos que permiten a dos componentes de software

comunicarse entre sí mediante un conjunto de definiciones y
protocolos.
¿CUÁLES SON LOS COMPONENTES DE JDBC?

En general, hay dos componentes principales de JDBC a través de los cuales puede interactuar
con una base de datos. Son los que se mencionan a continuación:
JDBC Driver Manager: carga el driver específico de la base de datos en una aplicación para
establecer una conexión con una base de datos. Se utiliza para realizar una llamada específica a la
base de datos para procesar la solicitud del usuario.
1
API JDBC: Es un conjunto de interfaces y clases, que proporciona varios métodos e interfaces
para una fácil comunicación con la base de datos. Proporciona dos paquetes de la siguiente
manera que contiene las plataformas java SE y java EE para exhibir capacidades WORA (write
once run everything).
Estos paquetes son:
1. java.sql.*;
2. javax.sql.*;
Las clases e interfaces principales de JDBC son:
• java.sql.DriverManager
• java.sql.Connection
• java.sql.Statement
• java.sql.ResultSet
• java.sql.PreparedStatement
• javax.sql.DataSource
¿CÓMO ACCEDE JDBC A LA BASES DE DATOS?

JDBC nos permitirá acceder a bases de datos desde Java. Para ello necesitaremos contar con un
SGBD (sistema gestor de bases de datos) además de un driver específico para poder acceder a
este SGBD. La ventaja de JDBC es que nos permitirá acceder a cualquier tipo de base de datos,
siempre que contemos con un driver apropiado para ella.
Figura 1: Arquitectura de JDBC
Como se observa en la Figura 1, cuando se construye una aplicación Java utilizando JDBC para el
acceso a una base de datos, en la aplicación siempre se utiliza la API estándar de JDBC, y la
implementación concreta de la base de datos será transparente para el usuario.
2
¿QUÉ ES UN DRIVER JDBC?
Vimos que dentro de los componentes de JDBC existe el Driver Manager que es el encargado de
cargar el driver, pero ¿qué es el driver exactamente?
La API JDBC define las interfaces y clases Java™ que utilizan los programadores para conectarse
con bases de datos y enviar consultas. Un driver JDBC implementa dichas interfaces y clases para
un determinado proveedor de DBMS.
Un programa Java que utiliza la API JDBC carga el controlador especificado para el DBMS
particular antes de conectar realmente con una base de datos. Luego la clase
JDBC DriverManager envía todas las llamadas de la API JDBC al controlador cargado.
El DBMS que venimos usando y seguiremos usando es MySQL, uno de

los más populares del mundo.
Cada base de datos debe aportar sus propias implementaciones y es ahí donde el Driver JDBC
realiza sus aportes. El concepto de Driver hace referencia al conjunto de clases necesarias que
implementa de forma nativa el protocolo de comunicación con la base de datos en un caso será
Oracle y en otro caso será MySQL.
Por lo tanto para cada base de datos deberemos elegir su Driver .¿Cómo se encarga Java de
saber cuál tenemos que usar en cada caso?. Muy sencillo, Java realiza esta operación en dos
pasos. En el primero registra el driver con la instrucción:
Class.forName("com.mysql.jdbc.Driver");
Una vez registrado el Driver , este es seleccionado a través de la propia cadena de conexión que
incluye la información sobre cual queremos usar, en la siguiente línea podemos ver que una vez
especificado el tipo de conexión define el Driver “MySql”
String url= "jdbc:mysql://localhost:3306/biblioteca";
En este momento instalaremos el driver. Sigue todos los pasos,

cuidadosamente, que se encuentran al final de la guía. Recuerda que la
mayoría de los pasos se realizan una sola vez, excepto el último que lo
haremos en cada proyecto que usemos JDBC.
3
PCOMPONENTES DEL API DE JDBCP
Nombramos cuales eran los componentes del API de JDBC, ahora los veremos en profundidad:
• Driver: Es el enlace de comunicaciones de la base de datos que maneja toda la

comunicación con la base de datos. Normalmente, una vez que se carga el controlador, el
desarrollador no necesita llamarlo explícitamente.
• Connection: Es una interfaz con todos los métodos para contactar una base de datos. El
objeto de conexión representa el contexto de comunicación, es decir, toda la
comunicación con la base de datos es solo a través del objeto de Connection.
• Statement: Encapsula una instrucción SQL que se pasa a la base de datos para ser
analizada, compilada, planificada y ejecutada.
• ResultSet: Los ResultSet representan un conjunto de filas recuperadas debido a la

ejecución de una consulta.
CONEXIÓN CON LA BASE DE DATOS

Para comunicarnos con una base de datos utilizando JDBC, se debe en primer lugar establecer
una conexión con la base de datos a través del driver JDBC apropiado. El API JDBC especifica la
conexión en la interfaz java.sql.Connection.
La clase DriverManager permite obtener objetos Connection con la base de datos.
Para conectarse es necesario proporcionar:
• URL de conexión, que incluye:
o Nombre del host donde está la base de datos.
o Nombre de la base de datos a usar.
• Nombre del usuario en la base de datos.
• Contraseña del usuario en la base de datos.
Idealmente las llaves primarias poseen un valor autogenerado y se

sugiere no se elija llave primaria algún otro atributo de la tabla. Esto se
debe a buenas prácticas de manipulación de los datos en bases de
datos: la llave primaria debe ser un valor abstracto de la tabla en sí y su
única función debe ser identificar una tupla, diferenciándola de otras.
4
El siguiente código muestra un ejemplo de conexión y obtención de datos en JDBC a una base de
datos MySQL:
En este ejemplo, primero se revisa el driver con la sentencia ClassForName. Después, la clase
DriverManager intenta establecer una conexión con la base de datos database-name utilizando el
driver JDBC que proporciona MySQL. Para poder acceder al RDBMS MySQL es necesario
introducir un username y un password válidos. En el API JDBC, hay varios métodos que pueden
lanzar la excepción SQLException.
CONEXIÓN A LA BASE DE DATOS (OBJETO CONNECTION)

Una vez cargado el driver apropiado para nuestro SGBD se debe establecer la conexión con la
BD. Para ello se utiliza el siguiente método:
Connection con = DriverManager.getConnection(url, login, password);

La conexión a la BD está encapsulada en un objeto Connection, y para su creación se debe
proporcionar la url de la BD y el username y password para acceder a ella. El formato de la url
variará según el driver que se utilice.
El objeto Connection representa el contexto de una conexión con la base de datos, es decir:
• Permite obtener objetos Statement para realizar consultas SQL.
• Permite obtener metadatos acerca de la base de datos (nombres de tablas, etc.)
• Permite gestionar transacciones.
5
POBTENIENDO DATOS DE LA BASE DE DATOSP
Una vez que tengamos la conexión con el objeto Connection, la vamos a usar para crear un objeto
Statement, este objeto recibe la consulta para ejecutarla y enviársela a la base de datos. La
información que recibimos de la base de datos va a ser capturada por el objeto ResulSet para
después poder mostrar la información.
CREACIÓN Y EJECUCIÓN DE SENTENCIAS SQL (OBJETO STATEMENT)

Una vez obtenida la conexión a la BD, se puede utilizar para crear sentencias. Estas sentencias
están encapsuladas en la clase Statement, y se pueden crear de la siguiente forma:
Statement stmt = con.createStatement();
• Los objetos Statement permiten realizar consultas SQL en la base de datos.
• Se obtienen a partir de un objeto Connection.
Tienen distintos métodos para hacer consultas:
• executeQuery: envía a la base de datos sentencias SQL para que recuperen datos y
devuelvan un único objeto ResultSet. Es usado para leer datos (típicamente consultas
SELECT).
• executeUpdate: para realizar actualizaciones que no devuelvan un ResultSet. Es usado

para insertar, modificar o borrar datos (típicamente sentencias INSERT, UPDATE y
DELETE).
Una vez obtenido este objeto se puede ejecutar sentencias utilizando su método executeQuery()
al que se proporciona una cadena con la sentencia SQL que se quiere ejecutar:
stmt.executeQuery(sentenciaSQL);
Estas sentencias pueden utilizarse para consultas al base de datos.
Las sentencias SQL van a ser las mismas que veníamos trabajando en MySQL Workbench, se van
a poner entre comillas dobles ya que el objeto Statement recibe String, como dato para las
sentencias.
String sentenciaSQL = "SELECT nombre, apellido FROM alumnos";

Como podemos ver las sentencias van a tener la misma sintaxis que veníamos trabajando, la única
diferencia, se va a presentar a la hora de trabajar con datos de tipo String y de tipo Date. Como
estos datos suelen ir en comillas dobles en Java y en SQL, y nuestra sentencia ya está entre
comillas dobles, deberemos poner los datos entre comillas simples para diferenciarlos.
6
String:
"SELECT nombre, apellido FROM Alumnos WHERE nombre = 'Agustin'";

Date:
"SELECT nombre FROM Alumnos WHERE fechaNacimiento = '01-11-1990'";
OBTENCIÓN DE DATOS (OBJETO RESULSET)

Para obtener datos almacenados en la BD se utiliza una consulta SQL (query). La consulta se
puede ejecutar utilizando el objeto Statement, con el método executeQuery() al que le se le pasa
una cadena con la consulta SQL. Los datos resultantes se devuelven como un objeto ResultSet.
ResultSet result = stmt.executeQuery(sentenciaSQL);
La consulta SQL devolverá una tabla, que tendrá una serie de campos y un conjunto de registros,
cada uno de los cuales consistirá en una tupla de valores correspondientes a los campos de la
tabla.
En la guía de MySQL vimos que una tupla es un conjunto de datos.

Sirve para agrupar, como si fueran un único valor, varios valores que,
por su naturaleza, deben ir juntos.
El objeto ResultSet proporciona el acceso a los datos de estas filas mediante un conjunto de
métodos get que permiten el acceso a las diferentes columnas de la filas. El método
ResultSet.next se usa para moverse a la siguiente fila del ResultSet, convirtiendo a ésta en la fila
actual.
El formato general de un ResultSet es una tabla con cabeceras de columna y los valores
correspondientes devueltos por la “query”. Por ejemplo, si la “query” es SELECT a, b, c FROM
Table1, el resultado tendrá una forma semejante a:
a b c
12345 Argentina 10,5
31245 Brasil 22,7
47899 Perú 56,7
El siguiente fragmento de código es un ejemplo de la ejecución de una sentencia SQL que

devolverá una colección de filas, con la columna 1 como un int, la columna 2 como una String y la
columna 3 como un real:
7
Filas ResulSet
Un ResultSet mantiene un cursor que apunta a la fila actual de datos. El cursor se mueve una fila
hacia abajo cada vez que se llama al método next. Inicialmente se sitúa antes de la primera fila,
por lo que hay que llamar al método next para situarlo en la primera fila convirtiéndola en la fila
actual. Las filas de ResultSet se recuperan en secuencia desde la fila más alta a la más baja.
Columnas ResultSet
Los métodos getX suministran los medios para recuperar los valores de las columnas de la fila
actual. Dentro de cada fila, los valores de las columnas pueden recuperarse en cualquier orden,
pero para asegurar la máxima portabilidad, deberían extraerse las columnas de izquierda a
derecha y leer los valores de las columnas una única vez.
Puede usarse, o bien el nombre de la columna o el número de columna, para referirse a esta. Por
ejemplo: si la columna segunda de un objeto ResultSet rs se denomina “nombre” y almacena
valores de cadena, cualquiera de los dos ejemplos siguientes nos devolverá el valor almacenado
en la columna.
String s = rs.getString("nombre");
String s = rs.getString(2);
Nótese que las columnas se numeran de izquierda a derecha comenzando con la columna 1.
Además, los nombres usados como input en los métodos getX son insensibles a las mayúsculas.
Algunos de los datos que podemos traer con el método get es:
Método Explicación
Sirve para obtener un numero entero de la base de

getInt() datos
getLong() Sirve para obtener un número long de la base de datos
getDouble() Sirve para obtener un número real de la base de datos
getBoolean() Sirve para obtener un booleano de la base de datos
getString() Sirve para obtener una cadena de la base de datos
getDate() Sirve para obtener una fecha de la base de datos
8
OPTIMIZACIÓN DE SENTENCIAS
Cuando se quiere invocar una determinada sentencia repetidas veces, puede ser conveniente
dejar esa sentencia preparada para que pueda ser ejecutada de forma más eficiente. Para hacer
esto se utiliza la interfaz PreparedStatement, que podrá obtenerse a partir de la conexión a la BD
de la siguiente forma:
PreparedStatement ps = con.prepareStatement("SELECT * FROM nombreTabla

WHERE campo2> 1200 AND campo2< 1300");
Vemos que, a este objeto, a diferencia del objeto Statement visto anteriormente, se le proporciona
la sentencia SQL en el momento de su creación, por lo que estará preparado y optimizado para la
ejecución de dicha sentencia posteriormente.
Sin embargo, lo más común es que se necesite hacer variaciones sobre la sentencia, ya que
normalmente no será necesario ejecutar repetidas veces la misma sentencia exactamente, sino
variaciones de ella. Por ello, este objeto nos permite parametrizar la sentencia. Para ello se deben
establecer las posiciones de los parámetros con el carácter '?' dentro de la cadena de la
sentencia, tal como se muestra a continuación:
PreparedStatement ps = con.prepareStatement("UPDATE FROM nombreTabla
SET campo1 = 'valor'
WHERE campo2 > ? AND campo2 < ?");

En este caso se tienen dos parámetros, que representan un rango de valores en el cual se quiere
actualizar. Cuando se ejecute esta sentencia, el campo1 de la tabla nombreTabla se establecerá a
valor1 desde el límite inferior hasta límite superior indicado en el campo2.
Para dar valor a estos parámetros se utiliza el método setXXX() donde XXX será el tipo de los
datos que asignamos al parámetro, indicando el número del parámetro (que empieza desde 1) y el
valor que le queremos dar. Por ejemplo, para asignar valores enteros a los parámetros se debe
hacer:
ps.setInt(1,1200);
ps.setInt(2,1300);
Una vez asignados los parámetros, se puede ejecutar la sentencia llamando al método
executeUpdate() del objeto PreparedStatement:
int n = ps.executeUpdate();
Igual que en el caso de los objetos Statement, se puede utilizar cualquier otro de los métodos
para la ejecución de sentencias, executeQuery() o execute(), según el tipo de sentencia que se
vaya a ejecutar.
9
PPATRÓN DE DISEÑO DAOP
Para la realización de los ejercicios y en los videos, vamos a trabajar JDBC usando el patrón de
diseño DAO. Pero primero debemos saber qué es un patrón de diseño.
¿QUE ES UN PATRÓN DE DISEÑO?

Un patrón de diseño es una solución probada que resuelve un tipo específico de problema en el
desarrollo de software referente al diseño.
Las ventajas de usar un patrón de diseño son, que permiten tener el código bien organizado,
legible y mantenible, además te permite reutilizar código y aumenta la escalabilidad en tu
proyecto. En sí proporcionan una terminología estándar y un conjunto de buenas prácticas en
cuanto a la solución en problemas de desarrollo de software.
PATRÓN DE DISEÑO DAO

A la hora de trabajar con JDBC y base de datos, una de las grandes problemáticas es que la
implementación y formato de la información puede variar según la fuente de los datos.
Implementar la lógica de acceso a datos en la capa de lógica de negocio puede ser un gran
problema, pues tendríamos que lidiar con la lógica de negocio en sí, más la implementación para
acceder a los datos
Dado lo anterior, el patrón DAO propone separar por completo la lógica de negocio de la lógica
para acceder a los datos, de esta forma, el DAO proporcionará los métodos necesarios para
insertar, actualizar, borrar y consultar la información; por otra parte, la capa de negocio solo se
preocupa por lógica de negocio y utiliza el DAO para interactuar con la fuente de datos.
CLASES QUE USAREMOS

Esto lo vamos a lograr a través de cuatro clases:
Entidad: va a ser la clase que va a representar a la tabla que queremos trabajar de la base de
datos. Va tener como atributos las columnas de la tabla de la base de datos.
Servicio o Business Service: va a tener toda la lógica de negocio del proyecto, usualmente se
genera una para cada entidad. Es la que se encarga de obtener datos desde la base de datos y
enviarla al cliente, o a su vez recibir la clase desde el cliente y enviar los datos al servidor, por lo
general tiene todos los métodos CRUD (create, read, update y delete).
DAO: representa una capa de acceso a datos que oculta la fuente y los detalles técnicos para
recuperar los datos. Esta clase va a ser la encargada de comunicarse con la base de datos, de
conectarse con la base de datos, enviar las consultas y recuperar la información de la base de
datos.
EntidadDaoExt: esta clase va a extender de la clase DAO y se va encargar de generar las

sentencias para enviar a la clase DAO, como un insert, select, etc. Y si estuviéramos haciendo un
select, sería también, la encargada de recibir la información, que recupera la clase DAO de la base
de datos sobre una entidad, para después enviarla al servicio, que será la encargada de imprimir
dicha información. Este es un objeto plano que implementa el patrón Data Transfer Object (DTO),
el cual sirve para transmitir la información entre el DAO y el Business Service.
10
Cada clase tendrá su servicio y su DAO correspondiente.
PAQUETES
Esto representado en un proyecto tendría las siguientes clases y paquetes:
Nota: estos conceptos van a poder verlos en más profundidad en los videos, donde verán clase
por clase y tendrán un ejemplo para descargar y poder verlo ustedes mismos también.
11
Para la realización de los ejercicios que se describen a continuación, es necesario el script
estancias.sql dentro del archivo MaterialJDBC.zip que pueden encontrar en el aula virtual.
1. Tienda
Nos han pedido que hagamos una aplicación Java para una tienda con sus productos. El
objetivo es realizar consultas para saber el stock de ciertos productos o que productos hay,
etc. Utilizando el lenguaje JAVA, una base de datos MySQL y JDBC para realizar la ejecución
de operaciones sobre la base de datos (BD).
Para este ejercicio vamos a usar el script de la base de datos llamada “tienda.sql” que lo
trabajamos en la guía de MySql, igualmente lo van a encontrar dentro del archivo
persistencia.zip. Deberá obtener un diagrama de entidad relación igual al que se muestra a
continuación:
Paquetes del Proyecto Java
Crear un nuevo proyecto en Netbeans del tipo “Java Application” con el nombre Tienda y
agregar dentro 3 paquetes, a uno se lo llamará entidades, al otro se le llamará servicios y al
otro persistencia:
12
Para crear los paquetes de esta manera, se deben crear desde el paquete principal, sería nos
paramos en el paquete tienda -> Click derecho -> New Java Package y creamos los paquetes.
También es importante agregar en “Libraries” la librería “MySQL JDBC Driver” para permitir
conectar la aplicación de Java con la base de datos MySQL. Esto se explica en el Instructivo
que ya leíste al final de esta guía.
Paquete persistencia
En este paquete estará la clase DAO encarga de conectarse con la base de datos y de
comunicarse con la base de datos para obtener sus datos. Además, estará las clases de
EntidadDaoExt para cada entidad / tabla de nuestro proyecto.
Es importante tener la conexión creada a la base de datos, como lo explica el Instructivo en la

pestaña de Services en Netbeans.
Paquete entidades:
Dentro de este paquete se deben crear todas las clases necesarias que vamos a usar de la
base de datos. Por ejemplo, una de las clases a crear dentro de este paquete es la clase
“Producto.java” con los siguientes atributos:
• private int codigo;

• private String nombre;
• private double precio;
• private int codigoFabricante;
Agregar a cada clase el/los constructores necesarios y los métodos públicos getters y setters
para poder acceder a los atributos privados de la clase. La llave foránea se pondrá como dato
nada más, no como objeto.
Paquete servicios:
En este paquete se almacenarán aquellas clases que llevarán adelante lógica del negocio. En
general se crea un servicio para administrar cada una de las entidades y algunos servicios
para manejar operaciones muy específicas como las estadísticas.
Realizar un menú en Java a través del cual se permita elegir qué consulta se desea realizar.
Las consultas a realizar sobre la BD son las siguientes:
a) Lista el nombre de todos los productos que hay en la tabla producto.
b) Lista los nombres y los precios de todos los productos de la tabla producto.
c) Listar aquellos productos que su precio esté entre 120 y 202.
d) Buscar y listar todos los Portátiles de la tabla producto.
e) Listar el nombre y el precio del producto más barato.
f) Ingresar un producto a la base de datos.
g) Ingresar un fabricante a la base de datos
h) Editar un producto con datos a elección.
13
PEJERCICIOS DE APRENDIZAJE EXTRASP
continuar con el tema siguiente. Por último, recuerda que la prioridad es ayudar a los compañeros
1. Estancias en el extranjero
Nos han pedido que hagamos una aplicación Java de consola para una pequeña empresa que
se dedica a organizar estancias en el extranjero dentro de una familia. El objetivo es el
desarrollo del sistema de reserva de casas para realizar estancias en el exterior, utilizando el
lenguaje JAVA, una base de datos MySQL y JDBC para realizar la ejecución de operaciones
sobre la base de datos (BD).
Creación de la Base de Datos MySQL
La información que se desea almacenar en la base de datos es la siguiente:
• Se tienen contactos con familias de diferentes países que ofrecen alguna de las
habitaciones de su hogar para acoger algún chico (por un módico precio). De cada una de
estas familias se conoce el nombre, la edad mínima y máxima de sus hijos, número de
hijos y correo electrónico.
• Cada una de estas familias vive en una casa, de la que se conoce la dirección (calle,
numero, código postal, ciudad y país), el periodo de disponibilidad de la casa
(fecha_desde, fecha_hasta), la cantidad de días mínimo de estancia y la cantidad máxima
de días, el precio de la habitación por día y el tipo de vivienda.
• Se dispone también de información de los clientes que desean mandar a sus hijos a
alguna de estas familias: nombre, dirección (calle, numero, código postal, ciudad y país) y
su correo electrónico.
• En la BD se almacena información de las reservas y estancias realizadas por alguno de los

clientes. Cada estancia o reserva la realiza un cliente, y además, el cliente puede reservar
varias habitaciones al mismo tiempo (por ejemplo para varios de sus hijos), para un
periodo determinado (fecha_llegada, fecha_salida).
• El sistema debe también almacenar información brindada por los clientes sobre las casas
en las que ya han estado (comentarios).
Según todas estas especificaciones se debe realizar:
Para este ejercicio vamos a usar el script de la base de datos llamada “estancias_exterior.sql”
lo van a encontrar en el archivo persistencia.zip Deberá obtener un diagrama de entidad
relación igual al que se muestra a continuación:
14
Paquetes del Proyecto Java
Crear un nuevo proyecto en Netbeans del tipo “Java Application” con el nombre Estancias y
agregar dentro 3 paquetes, a uno se lo llamará entidades, al otro se lo llamará servicios y al
otro persistencia:
15
Paquete persistencia
En este paquete estará la clase DAO encarga de conectarse con la base de datos y de
comunicarse con la base de datos para obtener sus datos. Además, estará las clases de
EntidadDaoExt para cada entidad / tabla de nuestro proyecto.
Es importante tener la conexión creada a la base de datos, como lo explica el Instructivo en la

pestaña de Services en Netbeans.
Agregar en “Libraries” la librería “MySQL JDBC Driver” para permitir conectar la aplicación de
Java con la base de datos MySQL.
Paquete entidades
Dentro de este paquete se deben crear todas las clases necesarias que queremos persistir en
la base de datos. Por ejemplo, una de las clases a crear dentro de este paquete es la clase
“Familia.java” con los siguientes atributos:
• private int id;

• private String nombre;
• private int edad_minima;
• private int edad_maxima;
• private int num_hijos;
• private String email;
Agregar a cada clase el/los constructores necesarios y los métodos públicos getters y setters
para poder acceder a los atributos privados de la clase.
Paquete servicios:
En este paquete se almacenarán aquellas clases que llevarán adelante lógica del negocio. En
general se crea un servicio para administrar cada una de las entidades y algunos servicios
para manejar operaciones muy específicas como las estadísticas.
Para realizar las consultas con la base de datos, dentro del paquete servicios, creamos las
clases para cada una de las entidades con los métodos necesarios para realizar consultas a la
base de datos. Una de las clases a crear en este paquete será: FamiliaServicio.java, y en esta
clase se implementará, por ejemplo, un método para listar todas las familias que ofrecen
alguna habitación para realizar estancias.
Realizar un menú en java a través del cual se permita elegir qué consulta se desea realizar.
Las consultas a realizar sobre la BD son las siguientes:
a) Listar aquellas familias que tienen al menos 3 hijos, y con edad máxima inferior a 10 años.
b) Buscar y listar las casas disponibles para el periodo comprendido entre el 1 de agosto de
2020 y el 31 de agosto de 2020 en Reino Unido.
c) Encuentra todas aquellas familias cuya dirección de mail sea de Hotmail.
d) Consulta la BD para que te devuelva aquellas casas disponibles a partir de una fecha dada
y un número de días específico.
e) Listar los datos de todos los clientes que en algún momento realizaron una estancia y la
descripción de la casa donde la realizaron.
16
f) Listar todas las estancias que han sido reservadas por un cliente, mostrar el nombre, país y
ciudad del cliente y además la información de la casa que reservó. La que reemplazaría a
la anterior
g) Debido a la devaluación de la libra esterlina con respecto al euro se desea incrementar el

precio por día en un 5% de todas las casas del Reino Unido. Mostar los precios
actualizados.
h) Obtener el número de casas que existen para cada uno de los países diferentes.
i) Busca y listar aquellas casas del Reino Unido de las que se ha dicho de ellas (comentarios)
que están ‘limpias’.
j) Insertar nuevos datos en la tabla estancias verificando la disponibilidad de las fechas.
Para finalizar, pensar junto con un compañero cómo sería posible optimizar las tablas de la BD
para tener un mejor rendimiento.
17
ACCESO A BASE DE
DATOS DESDE JAVA:
JPA
En esta guía aprenderemos:
• Qué es JPA y cómo funciona.
• Mapear entidades y atributos.
• Mapear relaciones entre clases.
• Persistir, buscar, modificar y eliminar entidades de la

base de datos desde Java
• Crear consultas a la base de datos desde Java
PPERSISTENCIA EN JAVA CON JPAP

JPA (Java Persistence API) es la propuesta estándar que ofrece Java para implementar un
Framework Object Relational Mapping (ORM), que permite interactuar con la base de datos por
medio de objetos, de esta forma. JPA es el encargado de convertir los objetos Java en
instrucciones para el Manejador de Base de Datos (DBMS). El objetivo que persigue el diseño de
esta API es no perder las ventajas de la orientación a objetos al interactuar con una base de datos
(siguiendo el patrón de mapeo objeto-relacional).
Cuando empezamos a trabajar con bases de datos en Java utilizamos el API de JDBC el cual nos
permite realizar consultas directas a la base de datos a través de consultas SQL nativas. JDBC por
mucho tiempo fue la única forma de interactuar con las bases de datos, pero representaba un
gran problema y es que Java es un lenguaje orientado a objetos y se tenían que convertir los
atributos de las clases en una consulta SQL como SELECT, INSERT, UPDATE, DELETE, etc. Lo que
ocasionaba un gran esfuerzo de trabajo y provocaba muchos errores en tiempo de ejecución,
debido principalmente a que las consultas SQL se tenían que generar frecuentemente al vuelo.
JPA es una especificación, es decir, no es más que un documento en el cual se plasman las reglas
que debe de cumplir cualquier proveedor que desee desarrollar una implementación de JPA, de
tal forma que cualquier persona puede tomar la especificación y desarrollar su propia
implementación de JPA. Existen varios proveedores como lo son los siguientes:
• Hibernate
• ObjectDB
• EclipseLink
• OpenJPA
1
PERSITENCIA DE OBJETOS
JPA representa una simplificación del modelo de programación de persistencia. La
especificación JPA define explícitamente la correlación relacional de objetos, en lugar de basarse
en implementaciones de correlación específicas del proveedor. JPA crea un estándar para la
importante tarea de la correlación relacional de objetos mediante la utilización de anotaciones o
XML para correlacionar objetos con una o más tablas de una base de datos. Para simplificar aún
más el modelo de programación de persistencia:
• La API EntityManager puede actualizar, recuperar, eliminar o aplicar la persistencia de

objetos de una base de datos.
• JPA proporciona un lenguaje de consulta, que amplía el lenguaje de consulta EJB

independiente, conocido también como JPQL, el cual puede utilizar para recuperar
objetos sin grabar consultas SQL específicas en la base de datos con la que está
trabajando.
• El programador no necesita programar código JDBC ni consultas SQL.
• El entorno realiza la conversión entre tipos Java y tipos SQL.
• El entorno crea y ejecuta las consultas SQL necesarias.
ARQUITECTURA JPA - COMPONENTES
La arquitectura de JPA está diseñada para gestionar Entidades y las relaciones que hay entre
ellas. A continuación, detallamos los principales componentes de la arquitectura
Entity: Clase Java simple que representa una fila en una tabla de base de datos con su formato
más sencillo. Los objetos de entidades pueden ser clases concretas o clases abstractas. Podemos
decir que cada Entidad corresponderá con una tabla de nuestra Base de Datos
Persistence: Clase con métodos estáticos que nos permiten obtener instancias de
EntityManagerFactory.
EntityManagerFactory: Es una factoría de EntityManager. Se encarga crear y gestionar múltiples

instancias de EntityManager
EntityManager: Es una interfaz que gestiona las operaciones de persistencia de las entidades, ya
sea crear, editar, eliminar, traer de la base de datos una entidad, etc. Es la base de todo proyecto
de JPA. A su vez trabaja como factoría de las Querys.
2
Query: Es una interfaz para obtener la relación de objetos que cumplen un criterio
EntityTransaction: Agrupa las operaciones realizadas sobre un EntityManager en una única

transacción de Base de Datos.
Hay muchos términos nuevos en esta guía. Recuerda que siempre

puedes volver y buscar la información. Es más importante entender el
proceso que tener todo de memoria.
PMAPEO CON ANOTACIONESP

Como sabemos las bases de datos relacionales almacenan la información mediante tablas, filas, y
columnas, de manera que para almacenar un objeto en la base de datos, hay que realizar una
correlación entre el sistema orientado a objetos de Java y el sistema relacional de nuestra base
de datos. JPA nos permite realizar dicha correlación de forma sencilla, realizando por nosotros
toda la conversión entre nuestros objetos y las tablas de una base de datos. Esta conversión se
llama ORM (Object Relational Mapping - Mapeo Relacional de Objetos), y puede configurarse a
través de metadatos (anotaciones). A estos objetos, las cuales son clases comunes y corrientes,
los llamaremos desde ahora entidades.
Las anotaciones nos permiten configurar el mapeo de una entidad dentro del mismo archivo
donde se declara la clase, de este modo, relaciona las clases contra las tablas y los atributos
contra las columnas. Mediante las anotaciones vamos a explicarle al ORM, como transformar la
entidad en una tabla de base de datos.
Las anotaciones comienzan con el símbolo “@” seguido de un identificador. Las anotaciones son
utilizadas antes de la declaración de clase, propiedad o método. A continuación, se detallan las
principales:
@Entity: Declara la clase como una Entidad
@Table: Declara el nombre de la Tabla con la que se mapea la Entidad
@Id: Declara un atributo como la clave primaria de la Tabla
@GeneratedValue: Declara como el atributo que va a ser a la clave primaria va a ser inicializada.
Manualmente, Automático o a partir de una secuencia.
@Column: Declara que un atributo se mapea con una columna de la tabla
@Enumerated: Declara que un atributo es de alguno de los valores definidos en un Enumerado

(lista de valores constantes). Los valores de un tipo enumerado tienen asociado implícitamente un
tipo ordinal que será asociada a la propiedad de este tipo.
@Temporal: Declara que se está tratando de un atributo que va a trabajar con fechas, entre
paréntesis, debemos especificarle que estilo de fecha va a manejar en la base de datos:
@Temporal(TemporalType.DATE), @Temportal(TemporalType.TIME),
@Temporal(TemporalType.TIMESTAMP)
3
DECLARAR ENTIDADES CON @ENTITY
Como ya discutimos hace un momento, las entidades son simples clases Java como cualquier
otra, sin embargo, JPA debe de ser capaz de identificar que clases son entidades para de esta
forma poder administrarlas y convertirlas en tablas. Es aquí donde nace la importancia de la
anotación @Entity, esta anotación se debe de definir a nivel de clase y sirve únicamente para
indicarle a JPA que esa clase es un Entity, veamos el siguiente ejemplo:
En el ejemplo vemos una clase común y corriente la cual representa a un Empleado, hasta este
momento la clase Empleado, no se puede considerar una entidad, pues a un no tiene la anotación
@Entity que la señale como tal. Ahora bien, si a esta misma clase le agregamos la anotación
@Entity le estaremos diciendo a JPA que esta clase es una entidad y deberá ser administrada
por el EntityManager, veamos el siguiente ejemplo:
En este punto la clase ya se puede considerar una Entidad.
DEFINIR LLAVE PRIMARÍA CON @ID

Al igual que en las tablas, las entidades también requieren un identificador o clave primaria(ID).
Dicho identificador deberá de diferenciar a la entidad del resto. Como regla general, todas las
entidades deberán definir un ID, de lo contrario provocaremos que el EntityManager marque error
a la hora de instanciarlo.
El ID es importante porque será utilizado por el EntityManager a la hora de persistir un objeto, y es

por este que puede determinar sobre que registro hacer el select, update o delete.
@Entity
public class Empleado {
@Id
private Long id;
private String nombre;
}
Se ha agregado @Id sobre el atributo id, de esta manera, cuando el EntityManager inicie sabrá
que el campo id es el Identificador de la clase Empleado.
4
ANOTACIÓN @GENERATEDVALUE
Esta anotación se utiliza para autogenerar el ID (Identity) como en el caso de MySQL. JPA cuenta
con la anotación @GeneratedValue para indicarle a JPA qué regla de autogeneración de la lleva
primaria vamos a utilizar.
Identity
Esta estrategia para generar Id es la más fácil de utilizar pues solo hay que indicarle la estrategia y
listo, no requiere nada más, JPA cuando persista la entidad no enviará este valor, pues asumirá
que la columna es auto generada. Esto provoca que el contador de la columna incremente en 1
cada vez que un nuevo objeto es insertado.
MAPEO DE FECHAS CON @TEMPORAL

Mediante la anotación @Temporal es posible mapear las fechas con la base de datos de una
forma simple. Una de las principales complicaciones cuando trabajamos con fecha y hora es
determinar el formato empleado por el manejador de base de datos. Sin embargo, esto ya no será
más problema con @Temporal.
Mediante el uso de @Temporal es posible determinar si el atributo almacena Hora, Fecha u Hora y
Fecha. Para esto podemos utilizar la clase Date o Calendar. Se pueden establecer tres posibles
valores para la anotación:
DATE: Acotara el campo solo a la fecha, descartando la hora.
@Temporal(TemporalType.DATE)
TIME: Acotara el campo solo a la hora, descartando a la fecha.
@Temporal(TemporalType.TIME)
TIMESTAMP: Toma la fecha y hora.
@Temporal(TemporalType.TIMESTAMP)
Ejemplo:
5
PLAS RELACIONESP
Como sabemos en Java, los objetos pueden estar relacionados entre sí mediante las relaciones
entre clases y sabemos que en MySQL las tablas tienen 4 tipos de relaciones posibles. Entonces,
supongamos que tenemos dos objetos que están relacionados entre sí y queremos que esa
relación también esté representada en las tablas.
Es por esto que JPA, nos da cuatro anotaciones para cuando tenemos una relación entre dos
clases en Java y le queremos explicar a la base de datos, que tipo de relación tendrán las tablas
entre sí. Estas anotaciones solo van a afectar a las tablas, sirven para especificar como se van a
relacionar los registros de una tabla, con los registros de otra tabla. Recordemos que las
anotaciones cumplen el propósito de “traducir” nuestro código de Java para que lo entienda la
base de datos, por lo que las anotaciones, no van a afectar nunca a nuestro código.
Las anotaciones que nos da JPA, son los tipos de relaciones entre tablas que vimos en la guía de
MySQL. Estas anotaciones son:
• @OneToOne: relación entre tablas uno a uno
• @OneToMany: relación entre tablas uno a muchos
• @ManyToOne: relación entre tablas muchos a uno
• @ManyToMany: relación entre tablas muchos a muchos
Es importante entender la manera en la que pensamos nuestras

relaciones. La primera palabra de la anotación se aplica a la clase que
tendrá la relación y la segunda palabra se aplica a la clase que será
atributo de la primera.
@ONETOONE
Entonces, supongamos que tenemos dos clases, Curso y Profesor, entre las cuales existe una
relación de 1 a 1 en Java. Un Curso por lo tanto tiene 1 Profesor y un Profesor pertenece a un
Curso. Esto en nuestro código Java sería algo así:
6
Por ahora lo único que hemos creado es una referencia a la clase Profesor sin utilizar JPA para
nada. El siguiente paso será anotar la clase con anotaciones de JPA para que se construya la
relación a nivel de persistencia. Decidimos que la relación entre tablas también sea 1 a 1, por lo
que pondremos la anotación @OneToOne
Con esta anotación nos quedará unas tablas en MySQL de la siguiente manera:
Como podemos observar en la tabla Curso, existe una llave foránea de la tabla Profesor, de la
misma manera que en nuestra clase Curso existe un objeto de tipo Profesor.
La relación OneToOne en nuestra tabla va a especificar que, para un registro de un Curso, solo
hay un registro de un Profesor. En otras palabras, sería que un Curso no puede tener dos
Profesores o que, a cada Curso, solo podemos asignarle/persistir un Profesor.
@MANYTOONE
Usamos esta anotación cuando queremos que entre nuestras tablas haya una relación de muchos
a uno. Por ejemplo, muchos Álbumes pueden pertenecer a un Autor. Esta relación se representa
en Java de la siguiente manera:
@ManyToOne
private Autor autor;
La relación ManyToOne en nuestra tablas va a especificar que para uno o varios registros de
Álbumes va a haber un Autor. En otras palabras sería que uno o más Álbumes van a tener el
mismo Autor. Esto nos daría la posibilidad de que, a uno o muchos Álbumes asignarle el mismo
Autor, esta posibilidad no existe con la OneToOne, ya que a cada registro solo le podemos
asignar un registro.
Como el Autor solo va a ser 1, nosotros lo representamos en Java con un solo objeto, si fuera
muchos autores, pondríamos una colección, esto es igual a las relaciones entre clases normales
de Java.
7
@MANYTOMANY
Usamos esta anotación para tablas que están relacionadas con muchos elementos de un tipo
determinado, pero al mismo tiempo, estos últimos registros no son exclusivos de un registro en
particular, si no que pueden ser parte de varios. Por lo tanto, tenemos una Entidad A, la cual
puede estar relacionada como muchos registros de la Entidad B, pero al mismo tiempo, la Entidad
B puede pertenecer a varias instancias de la Entidad A. Por ejemplo: podríamos tener una familia
donde cada padre tiene varios hijos y a su vez cada hijo tiene dos padres.
Algo muy importante a tomar en cuenta cuando trabajamos con relaciones @ManyToMany o
@OneToMany, es que en realidad este tipo de relaciones no existen físicamente en la base de
datos, y en su lugar, es necesario crear una tabla intermedia que relacione las dos entidades.
@ManyToMany
private List<Tarea> tareas;
Cuál clase va a tener la referencia a la otra clase va a ser decisión del

programador.
TABLA INTERMEDIA
El concepto de tabla intermedia se presenta cuando tenemos una entidad que va a pertenecer a
varias instancias de otra entidad. Por ejemplo, un Empleado o varios Empleados pueden hacer
una o varias Tareas y a su vez, una o varias Tareas pueden ser realizadas por uno o varios
Empleados. Esto en SQL sería que un registro tiene varios registros asignados a el mismo.
El problema es que en SQL solo podemos poner un dato por columna, supongamos que el
Empleado tiene tres Tareas con los identificadores(id) 1,2,3. Nosotros no podemos tener una
columna que tenga tres valores separados. Lo que podríamos hacer es que se repita el registro de
Empleado tres veces con los tres identificadores, pongamos un ejemplo de una tabla que cumpla
ese requisito:
Empleado
ID Nombre Apellido IdTarea
1 Adriana Cardello 1
Esto parecería estar bien, pero si pensamos en las reglas de SQL, no podemos tener dos
identificadores iguales en el mismo registro y en nuestra tabla Empleado hay tres veces el mismo
identificador para el Empleado, ya que necesitamos que se repita.
Por lo que, para este tipo de relación se crea una tabla intermedia conocida como tabla asociativa.
Por convención, el nombre de esta tabla debe estar formado por el nombre de las tablas
participantes (en singular y en orden alfabético) separados por un guion bajo (_).
8
Esta tabla está compuesta por las claves primarias de las tablas que se relacionan con ella, así se
logra que la relación sea de uno a muchos, en los extremos, de modo tal que la relación se lea:
Un empleado tiene muchas tareas.
Una tarea puede ser hecha por muchos empleados.
Las tablas se verían así:
Empleado Tarea
ID Nombre ID Nombre
95 Adriana 915 Ordenar
28 Mariela 624 Limpiar
31 Agustín 567 Cocinar
Tabla intermedia
Empleado_Tarea
ID_Empleado ID_Tarea
95 624
95 915
28 567
28 624
Como podemos observar la tabla intermedia solo tiene dos columnas, el id del empleado y el id de
la tarea. Esta tabla no toma las columnas como llaves primarias, sino como llaves foráneas, esto
nos permite repetir los valores para asignar las tareas al empleado.
Las tablas en MySQL se verían así:
Notemos que en la tabla Empleado no existe una columna que haga referencia a Tarea, ni en
Tarea a Empleado, si no que es la tabla intermedia la encargada de hacer el cruce entre las dos
tablas.
9
Recordemos que esta tabla intermedia se va a generar con las
anotaciones @OneToMany y @ManyToMany.
RELACIONES JPA Y UML

En Java, nosotros tenemos dos posibles relaciones entre clases, uno a uno o de uno a muchos,
además son las dos que podemos representar en código. En cambio, en MySQL tenemos cuatro
tipo de relaciones, el problema es que hay relaciones de MySQL que no podemos representar en
Java.
Por ejemplo, la relación muchos a uno, no podemos representarla en Java, ya que una clase no
puede ser un List para representar el muchos. Por lo que Java al ver que hay una referencia a una
clase de un solo objeto, en el caso, por ejemplo, de la ManyToOne, esto lo va a tomar como una
relación de uno a uno.
Esto va a generar que cuando veamos un UML de nuestro proyecto JPA, no veamos las relaciones
ManyToOne o ManyToMany, ya que, como dijimos, en Java solo existen las uno a uno o uno a
muchos
Pongamos un ejemplo, tenemos la Clase Autor y la clase Álbum, vamos a decir que para muchos
Álbumes existe el mismo autor, por lo que sería una ManyToOne. Si la representásemos en
código sería así:
@ManyToOne
Ahora si tuviéramos una OneToOne, la representación en código sería esta:
@OneToOne
Si miramos el código, podemos observar que para las dos relaciones escribimos lo mismo.
Entonces, para Java la relación ManyToOne la va a representar como una OneToOne (1…1) en UML
y lo mismo nos pasaría con la OneToMany y la ManyToMany.
Por lo que si nos encontramos con un UML que tiene una relación uno a uno (1…1) y nos piden
decidir qué relación entre tablas usar, deberíamos considerar, que puede ser una OneToOne o
una ManyToOne; o que si tiene una relación uno a muchos (1…n), puede ser una OneToMany o
una ManyToMany.
Esto es porque, como habíamos visto previamente las relaciones muchos a uno y muchos a
muchos son propias de MySQL, no de Java. Entonces es importante, porque a la hora de pensar
en qué anotaciones le vamos a poner a nuestras entidades, pensemos en las tablas, ya que
estamos trabajando sobre cómo va a ser la relación entre las tablas y no las clases.
10
PPERSISTENCIA EN JPA CON ENTITYMANAGERP
Ahora que entendemos cómo a través de las anotaciones del ORM podemos unificar las tablas
de la base de datos con los objetos, que pasan a llamarse entidades. Ahora tenemos que ver
cómo hacemos para poder guardar, editar, eliminar, etc. a esas entidades en la base de datos.
JPA tiene como interface medular al EntityManager, el cual es el componente que se encarga
de controlar el ciclo de vida de todas las entidades definidas en la unidad de persistencia (cómo
configurar la unidad de persistencia se va a encontrar al final del PDF).
El EntityManager nos dará la posibilidad de poder crear, borrar, actualizar y consultar todas estas
entidades de la base de datos. También es la clase por medio de la cual se controlan las
transacciones. Los EntityManager son configurados siempre a partir de las unidades de
persistencia definidas en el archivo persistence.xml.
EntityManager em =
Persistence.createEntityManagerFactory("nombreUnidadDePersistencia")
.createEntityManager();
En esta línea se puede ver que se obtiene una instancia de la Interfaz EntityManagerFactory,
mediante la clase Persistence, esta última recibe como parámetro el nombre de la unidad de
persistencia que definimos en el archivo persistence.xml. Una vez con el EntityManagerFactory se
obtiene una instancia de EntityManager para finalmente ser retornada para ser utilizada.
OPERACIONES ENTITYMANAGER
Las entidades pueden ser cargadas, creadas, actualizadas y eliminadas a través del
EntityManager. Vamos a mostrar los métodos del EntityManager que nos permiten lograr estas
operaciones.
Persist()
Este método nos deja persistir una entidad en nuestra base de datos. Persistir es la acción de
preservar la información de un objeto de forma permanente, en este caso en una base de datos,
pero a su vez también se refiere a poder recuperar la información del mismo para que pueda ser
nuevamente utilizado.
Antes de ver cómo persistimos un objeto, también tenemos que entender el concepto de
transacciones, ya que para persistir un objeto en la base de datos, la operación debe estar
marcada como una transacción.
Una transacción es un conjunto de operaciones sobre una base de datos, que suelen crear, editar
o eliminar un registro de la base de datos, que se deben ejecutar como una unidad. Por lo que
una consulta a la base de datos no se la considera una transacción.
Entendiendo esto veamos un ejemplo del método Persist():
// Creamos un EntityManager
EntityManager em =
Persistence.createEntityManagerFactory("nombreUnidadDePersistencia").creat
eEntityManager();
//Creamos un objeto Alumno y le asignamos un nombre
Alumno alumno = new Alumno();
a1.setNombre("Nahuel");
11
//Iniciamos una transacción con el método getTransaction().begin();
em.getTransaction().begin();
//Persistimos el objeto
em.persist(alumno);
//Terminamos la transacción con el método commit. Commit en programación
significa confirmar un conjunto de cambios, en este caso persistir el
objeto
em.getTransaction().commit();
Find()
Este método se encarga de buscar y devolver una Entidad en la base de datos, a través de su
clave primaria(Id). Para ello necesita que le pasemos la clave y el tipo de Entidad a buscar.
// Creamos un EntityManager
EntityManager em =
eEntityManager();
// Usamos el método find para buscar una persona con el id 123 en nuestra
base de datos
Persona persona = em.find(Persona.class, 123);

De esta manera podremos obtener una Persona de la base de datos para usar ese objeto como
queramos.
Merge()
Este método funciona igual que el método persist pero, sirve para actualizar una entidad en la
base de datos.
EntityManager em =
eEntityManager();
//Usamos el método find para buscar el alumno a editar
Alumno alumno = em.find(Alumno.class,1234);
//Le asignamos un nuevo nombre
alumno.setNombre("Francisco");
//Actualizamos el alumno
em.merge(alumno);
12
Remove()
Este método se encarga de eliminar una entidad de la base de datos.
EntityManager em =
eEntityManager();
//Usamos el método find para buscar el alumno a borrar
Alumno alumno = em.find(Alumno.class,1234);
//Borramos el alumno
em.remove(alumno);
PJAVA PERSISTENCE QUERY LANGUAGE (JPQL)P

Es un lenguaje de consulta orientado a objetos independiente de la plataforma definido como
parte de la especificación Java Persistence API (JPA). JPQL es usado para hacer consultas contra
las entidades almacenadas en una base de datos relacional. Está inspirado en gran medida por
SQL, y sus consultas se asemejan a las consultas SQL en la sintaxis, pero opera con objetos
entidad de JPA en lugar de hacerlo directamente con las tablas de la base de datos.
CLAUSULAS SELECT – FROM

La cláusula FROM define de qué entidades se seleccionan los datos. Cualquier implementación
de JPA, mapea las entidades a las tablas de base de datos correspondientes. Esto significa que
vamos a utilizar el nombre de las entidades en vez del nombre de las tablas y los atributos de
las entidades en vez de las columnas de las tablas.
La sintaxis de una cláusula FROM de JPQL es similar a SQL pero usa el modelo de entidad en
lugar de los nombres de tabla o columna. El siguiente fragmento de código muestra una consulta
JPQL simple en la que selecciono todas las entidades Autor.
SELECT a FROM Autor a;

En la query se ve que, se hace referencia a la entidad Autor en lugar de la tabla de autor y se le
asigna la variable de identificación a. La variable de identificación a menudo se llama alias y es
similar a una variable en su código Java.
Se utiliza en todas las demás partes de la consulta para hacer referencia a esta entidad. Por
ejemplo, si queremos seleccionar un atributo de la entidad Autor, en vez de todos, usaríamos el
alias asi:
SELECT a.nombre, a.apellido FROM Autor a;
13
CLAUSULA WHERE
La sintaxis es muy similar a SQL, pero JPQL admite solo un pequeño subconjunto de las
características de SQL.
JPQL admite un conjunto de operadores básicos para definir expresiones de comparación. La

mayoría de ellos son idénticos a los operadores de comparación admitidos por SQL, y puede
combinarlos con los operadores lógicos AND, OR y NOT en expresiones más complejas.
Operadores:
• Igual: author.id = 10
• Distinto: author.id <> 10
• Mayor que: author.id > 10
• Mayor o Igual que: author.id => 10
• Menor que: author.id < 10
• Menor o igual que: author.id <= 10
• Between: author.id BETWEEN 5 and 10
• Like: author.firstName LIKE :‘%and%’
• Is null: author.firstName IS NULL
Se lo puede negar con el operador NOT, para traer todos los que no son nulos
• In: author.firstName IN (‘John’,‘Jane’)
Va a traer todos los autores con el nombre John o Jane.
UNIR ENTIDADES
Si necesitamos seleccionar datos de más de una entidad, por ejemplo, todos los libros que ha
escrito un autor, debe unir las entidades en la cláusula FROM. La forma más sencilla de hacerlo es
utilizar las asociaciones definidas de una entidad como en el siguiente fragmento de código.
SELECT a FROM Libro a JOIN a.autor b;

La definición de la entidad Libro proporciona toda la información necesaria para unirla a la entidad
Autor, y no es necesario que proporcione una declaración ON adicional.
También podemos utilizar el operador “.”, para navegar a través del atributo de autor de la entidad
Libro y traer los libros que tengan un autor con un nombre a elección. Esto generaría una relación
implícita entre las dos entidades, sin la necesidad de usar un Join.
SELECT a FROM Libro a WHERE a.autor.nombre LIKE : "Homero";
14
PCREAR CONSULTAS / QUERYS CON ENTITYMANAGERP
El EntityManager nos permite crear querys dinámicas con el lenguaje JPQL. Esto se logra
mediante el método createQuery(query). El método createQuery, recibe una query SQL, la envía a
la base de datos, que está anclada con la Unidad de Persistencia y devuelve el resultado de la
consulta.
Para obtener estos resultados vamos a usar dos métodos de la clase Query. Un método es
getResultList(), que nos deja atrapar el resultado de la query y guardarlo en una lista y el otro
método es getSingleResult(), que sirve para cuando queremos traer un solo resultado de la
consulta.
Igualmente, recomendamos usar siempre getResultList(), ya que, si la

consulta llega a traer más de un resultado nos va a generar una
excepción, entonces, para evitar esto usamos el getResultList por las
dudas.
// Para esto vamos a tener que crear un EntityManager
EntityManager em =
eEntityManager();
// Usamos el metodo createQuery y le ponemos la query de JPQL
List<Autor> autores = em.createQuery("SELECT a FROM Autor a")

.getResultList();
// Ponemos una lista del tipo de dato que vamos a traer en la query y
// usamos el getResultList() para atrapar todos los resultados de la
query.
De esta manera ya tenemos todos los autores de la base de datos guardados en una lista, solo
nos quedaría imprimir la lista de autores y mostrar todos los autores.
AGREGAR PARÁMETROS QUERY

Supongamos que tenemos la siguiente query:
“SELECT p FROM Persona p WHERE p.edad LIKE :20”

De esta manera la query no es dinámica, ya que siempre va a buscar personas con la edad de 20,
si queremos hacer que los parámetros de las querys sean dinámicas, vamos a hacerlo mediante el
método de la clase Query, setParameter().
El método recibe un String y una variable para ingresar a la Query. El String tiene que tener el
mismo nombre que el parámetro que vamos a poner en la query y el método setParameter(), va a
asignarle esa variable al parámetro de la query. Pongamos un ejemplo
15
La query, utiliza un parámetro llamado edad, y en el setParameter(), le decimos que el parámetro
“edad” de la query va a ser igual al valor que está en la variable entera age. Esto nos permite
“dinamizar” la query. Solo deberíamos pedirle al usuario un valor distinto para edad, cada vez que
se haga la query.
16
Para la realización de los ejercicios que se describen a continuación, sigue siendo necesario el
conector de MySQL y es necesario leer el Instructivo Unidad de Persistencia este se encuentra al
final de la guía o lo tenemos para descargar en el aula virtual.
1. Sistema de Guardado de una Librería
El objetivo de este ejercicio es el desarrollo de un sistema de guardado de libros en JAVA

utilizando una base de datos MySQL y JPA como framework de persistencia.
Creación de la Base de Datos MySQL:
Lo primero que se debe hacer es crear la base de datos sobre el que operará el sistema de
reservas de libros. Para ello, se debe abrir el IDE de base de datos que se está utilizando
(Workbench) y ejecutar la siguiente sentencia:
CREATE DATABASE libreria;

De esta manera se habrá creado una base de datos vacía llamada librería.
Paquetes del Proyecto Java:
Los paquetes que se utilizarán para este proyecto son los siguientes:
• entidades: en este paquete se almacenarán aquellas clases que se quiere persistir en la

base de datos.
• servicios: en este paquete se almacenarán aquellas clases que llevarán adelante la lógica
del negocio. En general se crea un servicio para administrar las operaciones CRUD
(Create, Remove, Update, Delete) cada una de las entidades y las consultas de cada
entidad.
Nota: En este proyecto vamos a eliminar entidades, pero no es considerado una buena
práctica. Por esto, además de eliminar nuestras entidades, vamos a practicar que nuestras
entidades estén dadas de alta o de baja. Por lo que las entidades tendrán un atributo “activo”
de tipo booleano, que estará en true al momento de crearlas y en false cuando las demos de
baja, para evitar eliminarlas de la base de datos.
17
a) Entidades
Crearemos el siguiente modelo de entidades:
Entidad Libro
La entidad libro modela los libros que están disponibles en la biblioteca para ser prestados. En
esta entidad, el atributo “ejemplares” contiene la cantidad total de ejemplares de ese libro,
mientras que el atributo “ejemplaresPrestados” contiene cuántos de esos ejemplares se
encuentran prestados en este momento y el atributo “ejemplaresRestantes” contiene cuántos
de esos ejemplares quedan para prestar.
Entidad Autor
La entidad autor modela los autores de libros.
Entidad Editorial
La entidad editorial modela las editoriales que publican libros.
b) Unidad de Persistencia
Para configurar la unidad de persistencia del proyecto, se recomienda leer el Instructivo

Unidad de Persistencia recuerde hacer click con el botón derecho sobre el proyecto y
seleccionar nuevo. A continuación, se debe seleccionar la opción de Persistence Unit como se
indica en la siguiente imagen.
18
Base de Datos
Para este proyecto nos vamos a conectar a la base de datos Librería, que creamos
previamente.
Generación de Tablas
La estrategia de generación de tablas define lo que hará JPA en cada ejecución, si debe crear
las tablas faltantes, si debe eliminar todas las tablas y volver a crearlas o no hacer nada.
Recomendamos en este proyecto utilizar la opción: “Create”
Librería de Persistencia
Se debe seleccionar para este proyecto la librería “EclipseLink”.
c) Servicios
AutorServicio
Esta clase tiene la responsabilidad de llevar adelante las funcionalidades necesarias para
administrar autores (consulta, creación, modificación y eliminación).
EditorialServicio
administrar editoriales (consulta, creación, modificación y eliminación)
LibroServicio
administrar libros (consulta, creación, modificación y eliminación).
19
d) Main
interactuar con el usuario. En esta clase se muestra el menú de opciones con las operaciones
disponibles que podrá realizar el usuario.
e) Tareas a realizar
Al alumno le toca desarrollar, las siguientes funcionalidades:
1) Crear base de datos Librería
2) Crear unidad de persistencia
3) Crear entidades previamente mencionadas (excepto Préstamo)
4) Generar las tablas con JPA
5) Crear servicios previamente mencionados.
6) Crear los métodos para persistir entidades en la base de datos librería
7) Crear los métodos para dar de alta/bajo o editar dichas entidades.
8) Búsqueda de un Autor por nombre.
9) Búsqueda de un libro por ISBN.
10) Búsqueda de un libro por Título.
11) Búsqueda de un libro/s por nombre de Autor.
12) Búsqueda de un libro/s por nombre de Editorial.
13) Agregar las siguientes validaciones a todas las funcionalidades de la aplicación:
• Validar campos obligatorios.
• No ingresar datos duplicados.
20
PEJERCICIOS DE APRENDIZAJE EXTRASP
continuar con el tema siguiente. Por ultimo, recordá que la prioridad es ayudar a los compañeros
1. Sistema de Reservas de una Librería
Vamos a continuar con el ejercicio anterior. Ahora el objetivo de este ejercicio es el desarrollo
de un sistema de reserva de libros en JAVA. Para esto vamos a tener que sumar nuevas
entidades a nuestro proyecto en el paquete de entidades y crearemos los servicios de esas
entidades.
Usaremos la misma base de datos y se van a crear las tablas que nos faltan. Deberemos
agregar las entidades a la unidad de persistencia.
a) Entidades
Crearemos el siguiente modelo de entidades:
Entidad Cliente
La entidad cliente modela los clientes (a quienes se les presta libros) de la biblioteca. Se
almacenan los datos personales y de contacto de ese cliente.
Entidad Préstamo
La entidad préstamo modela los datos de un préstamo de un libro. Esta entidad registra la
fecha en la que se efectuó el préstamo y la fecha en la que se devolvió el libro. Esta
entidad también registra el libro que se llevo en dicho préstamo y quien fue el cliente al
cual se le prestaron.
21
b) Servicios
ClienteServicio
administrar clientes (consulta, creación, modificación y eliminación).
PrestamoServicio
generar prestamos, va a guardar la información del cliente y del libro para persistirla en la
base de datos. (consulta, creación, modificación y eliminación).
c) Tareas a realizar
1) Al alumno le toca desarrollar, las siguientes funcionalidades:
2) Creación de un Cliente nuevo
3) Crear entidad Préstamo
4) Registrar el préstamo de un libro.
5) Devolución de un libro
6) Búsqueda de todos los préstamos de un Cliente.
• Agregar validaciones a todas las funcionalidades de la aplicación:
• Validar campos obligatorios.
• No ingresar datos duplicados.
• No generar condiciones inválidas. Por ejemplo, no se debe permitir prestar más

ejemplares de los que hay, ni devolver más de los que se encuentran prestados.
No se podrán prestar libros con fecha anterior a la fecha actual, etc.
22
PINSTRUCTIVO CONEXIÓN NETBEANS - MYSQLP
DESCARGAR EL CONECTOR
1) Primero debemos descargar el conector a utilizar (Por única vez). Este se encuentra en el
drive en la carpeta de persistencia.
• Descargar el archivo mysql-connector-java-5.1.48. Nota: si estamos usando alguna

versión de Netbeans que no sea la 8.2, deberán descargar de internet cualquier conector
de versión 8.
• Ubicarlo en la carpeta:
o C:\Program Files\NetBeans 8.2\ide\modules\ext
2) Segundo debemos verificar los permisos en MySQL (Por única vez).
• Descargar Script ALTER USER del drive.
• Ingresar MySQL Worbench.
• Ingresar con nuestra contraseña a la conexión LocalHost.
• Ejecutar el Script provisto.
• Se deberá ver de la siguiente manera:
3) Tercero cargar la librería en NetBeans (Por única vez)
• Dejar prevista la librería en mi IDE de trabajo.
• Tools à Libraries à MySQL JDBC Driver à Add JAR / Folder à Busco el archivo cargado
con antelación à OK (Es decir, vinculo el conector).
Nota: Cuando carguemos nuestro conector es importante eliminar, el archivo mysql-

connector-java-5.1.23 (Es el que viene por defecto cuando instalamos NetBeans). Para
eso sale la opción de remove en Netbeans.
El conector cargado nos debería quedar así:
23
OPCION A PARA CREAR UNA CONEXIÓN
Crear un proyecto en NetBeans (Para cada proyecto que hará uso de JDBC)
• En Worbench MySQL dejar creada mi base de datos a utilizar con el proyecto puntual.
• Creo mi proyecto en NetBeans.
• En la carpeta de Libraries de mi proyecto à Botón Derecho à Add Library à Selecciono

MySQL JDBC Driver
Nota: Esto le avisara a NetBeans que el proyecto que cree va a necesitar de esta librería
específica para ejecutarse..
• Voy a la pestaña Services de mi panel de exploración à Databases à Botón Derecho à

Register MySQL Server à Completar la configuración de PROPERTIES
Nota: Si no aparece la pestaña Services en mi explorador. Barra à Windows à Reset

Windows (se reiniciara la vista de NetBeans).
Configuración Pestaña Basic Properties:
Importante verificar que los 4 campos estén completos.
24
Configuración Pestaña Admin Properties:
• Path/URL to admin tool: C:\Program Files\MySQL\MySQL Workbench

8.0\MySQLWorkbench.exe
• Arguments: DEJAR EN BLANCO
• Path to start command: C:\Program Files\MySQL\MySQL Server 8.0\bin\mysqld.exe
• Arguments: --console
• Path to start command: C:\Program Files\MySQL\MySQL Server 8.0\bin\mysqladmin.exe
• Arguments: -u root shutdown
• Si todo funciono bien, podrá ver una conexión creada al Localhost
• Posicionarme sobre la misma à Connect (Esto permite dejar NetBeans y MySQL

conectados)
• Una vez que me conecte, debo realizar Connect sobre la base con la que voy a trabajar
(Esto permite dejar conectados Netbeans con la base de datos específica a trabajar).
OPCION B PARA CREAR UNA CONEXIÓN (SOLO UTILIZAR SI NO FUNCIONA

LA OPCION A O USAS MAC)
• Crear una conexión individual a la base con la que voy a trabajar.
• Voy a la pestaña Services de mi panel de exploración à Drivers à Mysql (Connector – J

Driver) à Connect Using à
Nos saldrá otra pantalla donde deberemos rellenar lo siguiente:
o Database: escribir el nombre de la base de datos con la que voy a trabajar. Debe estar
creada previamente
o Username: revisar que nuestro UserName esté correcto
o Password: ingresar el pass (Dejar marcado el box de remember pass )
Nos quedará asi:
25
• Verificar si la conexión quedo OK à Test Connection
• Finish
• Verificaremos que la conexión esta activa con la base vinculada.
SUMAR DRIVER A PROYECTO NETBEANS

Una vez hecho todo esto a cada proyecto que queramos conectar con NetBeans deberemos
sumarle el driver a las propiedades del proyecto.
Para esto vamos a darle click derecho al proyecto à Properties à Libraries à Add Library à
MySQL JDBC Driver à Add Library.
Nos va a quedar así:
26
27

Java - Egg

Cargado por

Información del documento

Descripción original:

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

Java - Egg

Cargado por

Copyright:

Formatos disponibles

Introducción a Java

● Utilizar el nuevo IDE.

Java es un lenguaje de programación de alto nivel, estos permiten escribir

Primero deberemos ir a File -> New Project

O podemos hacer click en la siguiente opción:

Por último deberemos ponerle un nombre a nuestro proyecto

Aquí colocamos el nombre del proyecto de la siguiente manera:

¿Cómo se ve un programa en java?

El siguiente programa Java muestra un mensaje en la consola con el texto

public class HolaMundo {

public static void main(String[] args) {

//La línea 12 muestra el mensaje por pantalla al ejecutar el

¿Cuáles son los comentarios?

El segundo comentario es // La línea 12 muestra el mensaje por pantalla al

El lenguaje de programación de la tecnología Java le provee la sentencia

La declaración package, en caso de existir, debe estar al principio del archivo

Una clase está formada por una parte correspondiente a la declaración de la

En la plantilla de ejemplo se ha simplificado el aspecto de la Declaración de

public static void main(String[] args){

A continuación, describiremos cada uno de los modificadores y componentes

static: es un modificador el cual indica que la clase no necesita ser instanciada

void: indica que la función o método main() no devuelve ningún valor.

El método main() debe aceptar siempre, como parámetro, un vector de strings,

Luego, al indicarle a la máquina virtual que ejecute una aplicación el primer

Si no se han comprendido hasta el momento muy bien todos estos conceptos,

Una vez que el programa se ha editado, es necesario compilarlo y ejecutarlo

Los elementos de un programa son: identificadores, variables, constantes,

¿Qué son las palabras reservadas?

¿Qué son los Identificadores?

Dentro de toda la información que vamos a manejar, a veces, necesitaremos

Declaración de variables en Java

Tipos de dato en Java

byte Es un entero con signo de 8 bits, el mínimo valor que se

short Es un entero con signo de 16 bits. El valor mínimo es -32,768

int Es un entero con signo de 32 bits. El valor mínimo es

long Es un entero con signo de 64 bits, el valor mínimo que puede

float Es un número decimal de precisión simple de 32 bits (IEEE

double Es un número decimal de precisión doble de 64 bits (IEEE 754

El tipo de dato carácter es un simple carácter unicode de 16

String Además de los tipos de datos primitivos el lenguaje de

Encerrando la cadena de caracteres con comillas dobles se

String cadena = “Sebastián”;

public class HolaMundo {

public static void main(String[] args) {

En Java, podemos definir una variable y al mismo tiempo podemos asignarle un

<tipo_de_dato> <nombre_variable> = expresion;

public static void main(String[] args) {

Valores por defecto

public static void main(String[] args) {

Primeramente, proceden los operadores unarios, luego los aritméticos,

+ Operador Unario de Suma; indica que el valor es positivo.

- Operador Unario de Resta; indica que el valor es negativo.

> Mayor que

>= Mayor o igual que

< Menor que

<= Menor o igual que

public static void main(String[] args) {

int suma = num1 + num2;

double division = num1 / num2;

boolean logico = num2 < num1;

✓ Instrucciones de inicio/fin, son utilizadas para delimitar bloques de

✓ Instrucciones de bifurcación, mediante estas instrucciones el

Entrada y Salida de Información