Ejercicios de Clase

ArraysNot1.
Calcular el factorial de 25 con un bucle while
public static void main(String[] args) {

// Do while
//1. Definción de las variables
int i = 0;
//2. Comenzar el bucle
do {
i++;
System.out.print(i+ ", ");

} while (i<10);
//3. Evaluar la condición

}

2.Resolver la potencia de 2 elevado a 8 con do-while
int exp = 1;
int cont = 1;
do {
exp = exp * 2;
cont = cont + 1;
} while (cont <= 8);
System.out.println("Dos elevado a la 8 potencia es " +exp);
}
3. Solicitar por consola un nombre de alumno y una nota. Preguntar si se
desea continuar escribiendo información. Hacerlo con un bucle do while

// Declaración de Variables
double nota, suma = 0;
int contadorAlumnos=0;
String nombre;
String respuesta = "";
Scanner s1 = new Scanner(System.in);
do {
System.out.println("Escriba el nombre del alumno --> ");
nombre = s1.next();
System.out.println("Escriba la nota --> ");
nota = s1.nextDouble();
System.out.println("Desea continuar S/N ");
respuesta = s1.next();

contadorAlumnos++;
suma += nota; // suma = suma + nota

}while (respuesta.equalsIgnoreCase("s"));
System.out.println("El número de alumnos es --> " + contadorAlumnos );
System.out.println("La nota promedio es --> " +
(suma/contadorAlumnos));
}

}

//Declaración de un array
int[] notas = new int[4];
notas[0]= 9;
notas[1] = 8;
notas[2] = 7;
notas[3] = 6;
System.out.println("Numero de elementos " + notas.length);

for (int i = 0; i < notas.length; i++) {
System.out.println("La nota en la posición " + i + " es --> " +
notas[i]);
}

//Declaración de un array (Segund forma)
int notas1[] = new int[4];
notas1[0]= 9;
notas1[1] = 8;
notas1[2] = 7;
notas1[3] = 6;
System.out.println("Numero de elementos " + notas1.length);

//Breve ejemplo para ver la diferencia entre una declaración y otra
int[] v1,v2; //v1 y v2 son vectores
v1 = new int[3];
v2 = new int[3];
int v3[], v4; // v3 es un vector , v4 es un entero
v3 = new int[3];
//Declarar un array que de antemano se conozcan sus valores
int[] numeros = {1,3,7,9};
for (int i = 0; i < numeros.length; i++) {
System.out.println("El número de la posición --> " + i + " es -> " +
numeros[i]);
}
Ejemplo de Array
Solicitar el número de notas que se van a grabar. Instanciar el array y solicitar
por consola los datos. Al final por medio de un bucle mostrar las notas.

// Declaración de Variables
double notas[], suma = 0;
int contador=0;
//Se solicita la dimensión del array
System.out.println("Escriba el número de notas a grabar");
contador = s1.nextInt();
notas = new double[contador];
System.out.println("Escriba la nota --> ");
notas[i] = s1.nextDouble();
suma += notas[i];
}
System.out.println("La nota promedio es --> " + (suma/notas.length));

System.out.println("La nota de la posición " + i + " es " + notas[i]);
}
}
Ejercicio Array 2
Crear un bloque de código que pinte las vocales y solo las vocales que existen
en un array de caracteres. El programa debe de ir comprobando, con un bucle,
para determinar si cada carácter del array es o no una vocal.

/*
Crear un bloque de código que pinte las vocales y solo las vocales que
existen en un array de caracteres.
El programa debe de ir comprobando, con un bucle, para determinar si
cada carácter del array es o no una vocal.
*/
System.out.println("--- Solución 1 ---");
char[] caracteres = {'w','f','a','h','u','g','b','i','o'};
char letra;

for(int i = 0; i<caracteres.length; i++){

letra = caracteres[i];
switch (letra){
case 'a':
case 'e':
case 'i':
case 'o':
case 'u':
case 'A':
case 'E':
case 'I':
case 'O':
case 'U':
System.out.println(letra);
break;
}
}
System.out.println("--Solución 2---");
String palabra = "SUpercalifragilisticexpialidocious".toLowerCase();
char[] letras = palabra.toCharArray();
for(int i = 0; i<letras.length; i++){
letra = letras[i];
switch (letra){
case 'a':
case 'e':
case 'i':
case 'o':
case 'u':

System.out.println(letra);
break;
}
}
}

Crear un bloque de código que lea las componentes de un array de enteros y
me pinte cuales con pares, cuales impares y cuales con múltiplos de tres. Para
este ejercicio utilizar un bucle que recorra el array y utilizar el operador %.

int[] enteros = {3,9,5,4,8,12,2,7};
for (int i = 0; i < enteros.length; i++) {

if (enteros[i] % 2 == 0){
System.out.println("El enteros en la posición "+ i + " " + enteros[i]
+" es par");
}else{
System.out.println("El enteros en la posición "+ i + " " + enteros[i]
+ " es impar");
}
if (enteros[i] % 3 == 0){

System.out.println("El enteros en la posición "+ i + " " +enteros[i]
+ " es divisible por 3");
}
}
24/03/2020
x1. - Crear un bucle que pinte por consola todas las componentes de un array
en orden inverso a como están guardadas en el array
Método arraycopy de System

// Copiar los elementos de un array en otro
//1. Definición de arrays
int[] nums1 = {2,4,6,8,10};
int[] nums2 = new int[10];
nums2[0]=5;
nums2[1] = 10;
//2. Realizar la copia
System.arraycopy(nums1, 0, nums2, 2, 5);
System.out.println("Array nums2 --> " + Arrays.toString(nums2));
}
2.- Crear un bloque de código que recorra los siguientes arrays y me cree otro
que contenga las componentes de ambos dos. Los arrays son los siguientes:
int[] array1 = new int[]{1,2,3,4,5};
int[] array2 = new int[]{334,23,4};
/*
Crear un bloque de código que recorra los siguientes arrays y
se cree otro que contenga las componentes de ambos dos.
Los arrays son los siguientes:
int[] array1 = new int[]{1,2,3,4,5};
int[] array2 = new int[]{334,23,4};
*/
int[] array1 = {1, 2, 3, 4, 5};
int[] array2 = {334, 23, 4};
int[] array3 = new int[array1.length + array2.length];
int posicionArray3 = 0;
for(int i = 0; i< array1.length; i++){

array3[posicionArray3] = array1[i];
posicionArray3++;
}
for(int i = 0; i< array2.length; i++){

array3[posicionArray3] = array2[i];
posicionArray3++;
}
System.out.println("El resultado es " + Arrays.toString(array3));

}
Ejercicio 3
Dado los siguientes arrays, hacer un bloque de código que construya un array
de la siguiente manera:
char[] cars1 = {'1','2','3','4','5','6'};
char[] cars2 = {'a','e','r','t','y','u'};
El array resultado que se debe de construir es el siguiente:
char[] result = new char[]{'1','a','2','e','3','r','4','t','5','y','6','u'};

// TODO code application logic here
char[] cars1 ={'1', '2', '3', '4', '5', '6'};
char[] cars2 = {'a', 'e', 'r', 't'};
char[] result = new char[cars1.length + cars2.length];

while (posicionArray3 < result.length) {

if (posicionArray1 < cars1.length) {
result[posicionArray3] = cars1[posicionArray1];
posicionArray1++;
posicionArray3++;
}
if (posicionArray2 < cars2.length) {

result[posicionArray3] = cars2[posicionArray2];
posicionArray2++;
posicionArray3++;
}
}

System.out.println("El resultado es --> " + Arrays.toString(result));
}

Sintaxis del for each

// 1. Definir un array
int[] numeros = {1,4,7,4,8};

for (int elemento : numeros) {
System.out.println("Elemento -> " + elemento);
}

}

Ejercicio 4

Dado el siguiente array, crear un bloque de código que pinte, SOLO, las
consonantes que existan en dicho array
char[] letras ={'2','f','f','u','u','g','h','i','4'};
char[] letras = new char[]{'2', 'f', 'f', 'u', 'u', 'g', 'h', 'i', '4'};
char[] consonantes = {'b', 'c', 'd', 'f', 'g', 'h', 'j', 'k', 'l', 'm', 'n', 'p', 'q', 'r',
's', 't', 'v', 'w', 'x', 'y', 'z'};
for (char letra : letras) {

for (char consonante : consonantes) {
if (letra == consonante) {
System.out.print(letra + " ");
break;
}
}
}
System.out.println("");
25/03/2021
Ejercicio 1
Dado el siguiente array crear un bloque de código que sume todas las
componentes del array, para ello hacer uso de un bucle que vaya obteniendo
todos los valores del array
float[] decimales = {3.4F,5.67F,12.0F,3.141615F,0.0F};
float[] decimales = new float[]{3.4F, 5.67F, 12.0F, 3.141615F, 0.0F};
float suma = 0;
for (float numero : decimales) {

suma += numero;
}
System.out.println("La suma de todos los elementos del array es " +

suma);
}

Ejercicio 2

Dado el siguiente array de números, crear un bloque de código que sume
por un lado solo los números pares y devuelva el resultado y por otro solo los
impares y también pinte el resultado
int[] numeros ={1,2,7,3,4,65,23,78,98,34,342,45,57};
int[] numeros = new int[]{1,2,7,3,4,65,23,78,98,34,342,45,57};

Ejemplo de declaración de Matrices de dos dimensiones
int[][] numMatriz = new int[2][3];

numMatriz[0][0] = 5;
numMatriz[1][0] = 10;

for (int i = 0; i < numMatriz.length; i++) {
for (int j = 0; j < numMatriz[i].length; j++) {
numMatriz[i][j]= 5*i;
}
System.out.println("la fila " + i + Arrays.toString(numMatriz[i]));
}

System.out.println("Datos de la matriz de dos dimensione -> " +
Arrays.deepToString(numMatriz));

//Declarar una matriz de 2x3 con valores predefinidos
int[][] numeros = {{1,3,5},{7,4,9}};
for (int i = 0; i < numeros.length; i++) {
for (int j = 0; j < numeros[i].length; j++) {
System.out.println("Elemento [" + i + "," + j + "] = " + numeros[i]
[j]);
}

}
Ejercicio 3
Dado los dos siguientes arrays, crear un bloque de código que me sume las
Componentes de ambos arrays de la siguiente manera:
Array1 Array2 Resultado Resultado
1 2 3 4 (1+3) (2+4) ---> 4 6
0 5 5 8 (0+5) (5+8) 5 13
Los arrays son los siguientes:
int[][] matriz1 = { {1,2}, {0,5} };
int[][] matriz2 = { {3,4}, {5,8} };
int[][] matriz1 = {{1, 2}, {0, 5}};

int[][] matriz2 = {{3, 4}, {5, 8}};
int[][] resultado = new int[2][2];
for (int fila= 0; fila<matriz1.length; fila++){

for (int columna = 0; columna < matriz1[fila].length; columna++){
resultado[fila][columna] = matriz1[fila][columna] + matriz2[fila]
[columna];
}
}
for (int [] fila : resultado){

for (int dato : fila){
System.out.print(dato + " ");
}
System.out.println("");
}
Ejercicio 4
Dado la siguiente matriz, crear un bloque de código que me pinte sus

componentes de la siguiente manera:
{3 4 5 78}
{0 0 0 0}
{1 1 1 1}
{6 6 6 -1}
El array bidimensional es el siguiente:
int[][] numeros = new int[][]{ {3, 4, 5, 78},
{0, 0, 0, 0},
{1, 1, 1, 1},
{6, 6, 6, -1} };
for (int[] fnumero : numeros) {

resultado = "{";
for (int numero : fnumero) {
resultado += String.valueOf(numero) + " ";
}
System.out.println(resultado.substring(0, resultado.length() -1) + "}");
}
Ejemplo de matriz NO cuadrada
// Ejemplo de matriz NO cuadrada

int[][] mNoCuadrada = {{1,3,5},{4,5,6,7,8}, {4,3,2}};

for (int i = 0; i < mNoCuadrada.length; i++) {
for (int j = 0; j < mNoCuadrada[i].length; j++) {
System.out.println("Elemento [" + i + ","+ j+"] -> " +
mNoCuadrada[i][j]);
}
}
Ejemplo 5
Solicitar por pantalla, el nombre del alumno, numero de faltas (dos
digitos), nota con dos decimales, si a aprobado (true/false), con un cabecero

String[] lineas = new String[20];
String nombre, respuesta;
int faltas, renglon=0;
float nota;
boolean aprobado;

while (true) {
System.out.println("Escriba el nombre del alumno --> ");
nombre = s1.next();
System.out.println("Escriba las faltas del alumno --> ");
faltas = s1.nextInt();
System.out.println("Escriba la nota del alumno --> ");
nota = s1.nextFloat();
System.out.println("¿Ha aprobado?");
aprobado = s1.nextBoolean();
lineas[renglon] = String.format("%-20s \t %2d \t %.2f \t %b
\n",nombre, faltas, nota, aprobado);
renglon++;
System.out.println("Desea continuar s/n ");
if (respuesta.equalsIgnoreCase("n")) {
break;
}

}
System.out.printf("%-20s \t %s \t %s \t %s \n\n", "Nombre", "faltas",
"Notas", "Aprobado");
for (int i = 0; i < renglon; i++) {
System.out.println(lineas[i]);
}
26/03/2021
// Clase LocalDate

LocalDate hoy = LocalDate.now();
System.out.printf("Fecha de hoy %s %n", hoy);

LocalDate nuevoAnio = LocalDate.of(2022, 1, 1);
System.out.printf("Fecha de año nuevo %s %n", nuevoAnio);

LocalDate inicioVacacones = LocalDate.of(2021, Month.AUGUST, 1);
System.out.printf("Fecha de inicio vacaciones %s %n", inicioVacacones);

//Declarar la fecha de inicio del curso y le sumamos 10 días
LocalDate fInicioCurso = LocalDate.of(2021, 3, 15);
System.out.printf("Sumar 10 días a la fecha de inicio del curso %s %n",
fInicioCurso.plusDays(10));
System.out.printf("Restar días 11 días a la fecha de hoy %s %n",
LocalDate.now().minusDays(11));

//Formar fechas con Clock ZoneId
LocalDate hoyReloj = LocalDate.now(Clock.systemDefaultZone());
System.out.printf("Fecha actual de la zona horario por defecto %s %n",
hoyReloj);

LocalDate hoyZonaHoraria =
LocalDate.now(ZoneId.of("Australia/Sydney"));
System.out.printf("Fecha actual con zona horaria %s %n",
hoyZonaHoraria);

LocalDate fechaDia100 = LocalDate.ofYearDay(2021, 100);
System.out.printf("Fecha del año actual día 100 %s %n", fechaDia100);

LocalDate fFinalCurso = LocalDate.parse("2021-10-20");
System.out.printf("Fecha a partir de un string usando el patron por
defecto yyyy-MM-dd %s %n", fFinalCurso);

LocalDate fEpoca = LocalDate.ofEpochDay(100);
System.out.printf("Fecha 1970 día 100 %s %n", fEpoca);

//Definir una fecha para navidad y otra para noche vieja y compararlas
con los métodos isBefore isAfter
LocalDate fNavidad = LocalDate.of(2021,12,25);
LocalDate fNocheVieja = LocalDate.of(2021,12,31);
System.out.printf("Noche vieja es despues de navidad %s %n",
fNocheVieja.isAfter(fNavidad));
System.out.printf("Noche vieja es antes de navidad %s %n",
fNocheVieja.isBefore(fNavidad));

//Clase LocalTime HH:mm:ss

LocalTime horaActual = LocalTime.now();
System.out.printf("Hora actual %s %n", horaActual);

LocalTime horaFormada = LocalTime.of(15, 55);
System.out.printf("Hora de conexion a la clase %s %n", horaFormada);

LocalTime horaReloj = LocalTime.now(Clock.systemDefaultZone());
System.out.printf("Hora usando la zona horaria por defecto %s %n",
horaReloj);

LocalTime horaAustralia = LocalTime.now(ZoneId.of("Australia/Sydney"));
System.out.printf("Hora Australia %s %n", horaAustralia);

LocalTime horaAPartirSegundos = LocalTime.ofSecondOfDay(43200);
System.out.printf("Hora a partir de segundos %s %n",
horaAPartirSegundos);

LocalTime horaDesdeString = LocalTime.parse("15:55:55.99");
System.out.printf("Hora convertido desde String %s %n",
horaDesdeString);

// Sumar una hora y 30 min a la hora de Australia
System.out.printf("HoraAustralia mas una hora y 30 min %s %n",
horaAustralia.plusHours(1).plusMinutes(30));

//Clase LocalDateTime
LocalDateTime fechaHora = LocalDateTime.now();
System.out.printf("Fecha hora actual %s %n", fechaHora);
System.out.printf("FechaHora del año actual extraer la fecha %s %n",
fechaHora.toLocalDate());
System.out.printf("FechaHora del año actual extraer la hora %s %n",
fechaHora.toLocalTime());

/* Instant
Representa el tiempo máquina comenzando por el Unix Epoch
*/

Instant fechaInstant = Instant.now();
System.out.printf("Fecha formada comenzando por el Unix Epoch %s
%n", fechaInstant);
System.out.printf("Obtenr el número de segundos desde el Unix Epoch
%s %n", fechaInstant.getEpochSecond());
System.out.printf("Diferencia entre el Instant y el LocalDate %s %s %n",
hoy, fechaInstant);

/*
La Clase Period Representa una cantidad de tiempo en términos de años,
meses y días
Tipicamente es usado para utilizarla con el método between con dos
fechas tipo LocalDate
*/

LocalDate fFabricacion = LocalDate.of(2020, 7, 14);
LocalDate fExpiración = LocalDate.of(2027, Month.SEPTEMBER, 15);
Period periodoOk = Period.between(fFabricacion, fExpiración);
System.out.printf("Mostrar el periodo entre las dos fechas %s %n",
periodoOk);
System.out.printf("Extraer del periodoOK años: %d meses : %d días %d
%n", periodoOk.getYears(), periodoOk.getMonths(), periodoOk.getDays());

System.out.printf("Periodo de 100 días %s %n", Period.ofDays(100));
System.out.printf("Sumar el periodo a la fecha de hoy %s %n",
LocalDate.now().plusDays(100));
System.out.printf("Sumar el periodo a la fecha de hoy %s %n",
LocalDate.now().plusDays(Period.ofDays(100).getDays()));

/*
Clase Duration
Representa una cantidad de tiempo en términos de hora, minutos,
segundos y fracciones de segundos
Usado típicamente para diferencias entre el método between con objetos
LocalTime

*/

LocalDateTime comidaSabado =
LocalDateTime.now().plusDays(1).minusHours(4);
Duration tHasta = Duration.between(LocalDateTime.now(),
comidaSabado);
System.out.printf("Tiempo que falta para la comida del sabado %s %n",
tHasta);

System.out.printf("Especificar una duración en base a segundos %s %n",
Duration.of(3600, ChronoUnit.SECONDS));
System.out.printf("Duración de 2 horas %s %n", Duration.ofHours(2));
System.out.printf("Duración de minutos %s %n",
Duration.ofMinutes(15));
System.out.printf("Duración de Segundos %s %n",
Duration.ofSeconds(51));
System.out.printf("Duración de Milisegundos %s %n",
Duration.ofMillis(12));
System.out.printf("Duración de 2 NanoSegundos %s %n",
Duration.ofNanos(1200));
System.out.printf("Duración a partir de un String %s %n",
Duration.parse("P2DT10H30M"));

/*
Clase DateTimeFormatter -> para dar formato a Fechas y Hora
Constantes predefinidas de formatos
ISO_DATE(2021-03-26)
ISO_TIME(11:25:47.624)
*/

LocalTime horaLevantarse = LocalTime.of(6, 45);
 System.out.printf("Hora de levantarse %s %n",
DateTimeFormatter.ISO_TIME.format(horaLevantarse));
 //Personalizar el formato de fecha
 DateTimeFormatter formatoPersonalizado =
DateTimeFormatter.ofPattern("dd MMM yyyy");
System.out.printf("formato personalizado %s %n",
formatoPersonalizado.format(LocalDate.now()));

//Declarar un array de String para representar algunos formatos
String [] formatosPersonalizados = {"dd-MM-yyyy" , "d '('E')' MMM,
YYYY", "w'º semana de ' YYYY", "EEEE, dd MMM YYYY"};

for (String elemento : formatosPersonalizados) {
System.out.printf("Patron \"%s\" es %s %n", elemento,
DateTimeFormatter.ofPattern(elemento).format(LocalDateTime.now()));
}

Ejercicios

 Calcular la fecha resultante sumando 35 semanas al 15 de marzo de 2021.
 Calcular los años trabajados en una empresa de un empleado que inició a
trabajar el 6 de Julio de 2012
 Calcular la edad de una persona que nació el 7 de agosto de 2007
 Calcular la fecha en que se tiene que iniciar un proyecto si su duración es
200 días y se tiene que entregar el 2 de octubre de 2021
 Si un proyecto inicia el 15 de marzo y termina el 20 de octubre cuál es su
periodo

05/04/2021
//1. Atributos
public String nombre;
public double sueldo;
public LocalDate fNacimiento;
//2. Métodos
public double calcularNomina(){
return sueldo * 0.92;
}
public long calcularEdad(){

return ChronoUnit.YEARS.between(fNacimiento, LocalDate.now());
}
Gó
//Instanciar un objeto del tipo empleado

Empleado e1 = new Empleado();
// Asignar valor a los atributos
e1.nombre = "Luis Ramirez";
e1.sueldo = 2_500;
e1.fNacimiento = LocalDate.of(1992, 8, 30);
System.out.println("Calcular nómina -> " + e1.calcularNomina());

System.out.println("Calcular edad -> " + e1.calcularEdad());
public class Saludo {

public String saludar(){
return "Bienvenidos al curso de Java";
}
}
public class ProbarSaludo {
/**
* @param args the command line arguments
*/
Saludo objSaludo = new Saludo();
System.out.println(objSaludo.saludar());
}

}
06/04/2021
EJERCICIO 3
Crear la clase Areas con métodos para calcular el área de un circulo y el área
de un
rectángulo. Desde una clase principal realizar ambos cálculos y mostrarlos por
pantalla.
public class Areas {
public double areaCirculo(double radio) {

return Math.PI * Math.pow(radio, 2);
}
public double areaRectangulo(double base, double altura) {

return base * altura;
}
}

double radio, base, altura;
System.out.println("Cual el radio -->");
radio = s1.nextDouble();
Areas objAreas = new Areas();
System.out.println("El area del círculo es --> " +
objAreas.areaCirculo(radio));

System.out.println("Solicitar los datos del rectangulo");
System.out.println("Cual es la base -->");
base = s1.nextDouble();
System.out.println("Cual es la altura -->");
altura = s1.nextDouble();
System.out.println("El area del rectangulo es --> " +
objAreas.areaRectangulo(base, altura));
}
public class Producto {

//1. Atributos
public int productoid;
public double precio;

//2. Métodos

public double calcularPrecioFinal(double iva){
return precio * (1 + iva);
}

public String mostrarInformacion(){
return "Productoid - " + productoid + " nombre - " + nombre + " precio -
" + precio;
}

//3. Constructores
public Producto(){

}

public Producto (int productoId){
productoid = productoId;
}

public Producto (String nombre){
this.nombre = nombre;
}

public Producto (double precio){
this.precio = precio;
}

public Producto (int productoid, String nombre, double precio){
this.productoid = productoid;
}
}
cAPA PRESENTACION
//1. Instanciar la clase
Producto p1;
p1 = new Producto();
//2. Dar valor a los atributos
p1.nombre = "Teclado negro";
p1.precio = 12.05;
p1.productoid = 501;
//3. Ejecutar los métodos
System.out.println("Calcular el precio final " +
p1.calcularPrecioFinal(0.21));
System.out.println("Mostrar el estado (informacion) -> " +
p1.mostrarInformacion());

//Instanciar un producto pero con el constructor de productoid
Producto p2 = new Producto(1);
System.out.println("La información " + p2.mostrarInformacion());

Producto p3 = new Producto(12.50);
System.out.println("La informacion de p3 " + p3.mostrarInformacion());

Producto p4 = new Producto(3, "teclado gris", 12.89);
System.out.println("La información de p4 " + p4.mostrarInformacion());

}
}
EJERCICIO 4
Realizar una clase llamada Campos con dos métodos uno muestra y el otro
incrementa. El método muestra, es una función que da como resultado el valor
de x, El
método incrementa: incrementa el valor de X.,en el constructor se da Campel
valor
inicial al campo X.,Crear una instancia en el módulo principal de la aplicación,
incrementar y mostrar el resultado.
public class Campos {
//Atributos
public int x;

//Métodos
public String muestra() {

return "El el valor de x es -> " + x;
}
public void incrementa() {

++x;
}
//Constructores
public Campos() {
}
public Campos(int x) {

this.x = x;
}
public class ProbarCampos {

//Instanciar la clase campos
Campos c1 = new Campos();
System.out.println(c1.muestra());
c1.incrementa();

//Instanciar otro objeto de la clase Campos
System.out.println("Objeto 2");
Campos c2 = new Campos(7);
c2.incrementa();
}
}
EJERCICIO 5
Construir una aplicación que imprima por pantalla las tablas de multiplicar. Debe
contar con un constructor que indica la tabla que se va a mostrar. Debe contar con un
método que dé como resultado un string para mostrar diez línea de la tabla del
número dado en el constructor
EJERCICIO 6
Construir una aplicación que muestre por pantalla el nombre de alumno y su nota final.
Para ello construir una clase Alumno que contenga:
 Un campo que sea una matriz para almacenar las calificaciones de los parciales.
 El constructor deberá inicializar las variables de NombreCompleto y dimensionar
el array de Parciales.
 Un método de escritura para asignar los valores de los parciales.
 Un método para calcular el promedio de los parciales.
 Un método para mostrar las calificaciones de los parciales.
07/07/2021
Encapsulación
public class Coche {
private String color;

public void setColor(String color){
this.color = color;
}

public String getColor(){
return color;
}

}
Coche c1 = new Coche();

c1.setColor("negro");
System.out.println("El atributo color tiene el valor -> " + c1.getColor());

public class FechaEncapsulada {

private int anio;
private int mes;
private int dia;

public void setAnio(int anio){
this.anio = anio;
}

public void setMes(int mes){
this.mes = mes;
}

public void setDia(int dia){
this.dia = dia;
}

public int getAnio(){
return anio;
}

public int getMes(){
return mes;
}

public int getDia(){
return dia;
}
}
public class ProbarFecha {
/**
*/
//Instanciar la fecha
FechaEncapsulada fe1 = new FechaEncapsulada();
fe1.setAnio(2021);
fe1.setMes(4);
fe1.setDia(7);

System.out.println("Fecha -> " + fe1.getAnio() + "/" + fe1.getMes() + "/" +
fe1.getDia());
}

}
Clase Animal
public class Animal {

//1. Atributos
public double peso;
public String especie;

//2. Métodos

public String mover(){
return "El animal con el nombre " + nombre + " se está moviendo ...";
}

public double comer(){
return peso *0.1;
}

public String mostrarInfo() {
return "Animal{" + "peso=" + peso + ", especie=" + especie + ", nombre=" +
nombre + '}';
}

}
public class Empleado {

//1. Atributos
public double sueldo;
public LocalDate fNacimiento;

//2. Métodos
public double calcularNomina(){
return sueldo * 0.92;
}

public long calcularEdad(){
return ChronoUnit.YEARS.between(fNacimiento, LocalDate.now());
}
}

//1. Atributos
public int productoid;
public double precio;

//2. Métodos

public double calcularPrecioFinal(double iva){
return precio * (1 + iva);
}

public String mostrarInformacion(){
return "Productoid - " + productoid + " nombre - " + nombre + " precio - " +
precio;
}

//3. Constructores
public Producto(){

}

public Producto (int productoId){
productoid = productoId;
}

public Producto (String nombre){
}

public Producto (double precio){
}

public Producto (int productoid, String nombre, double precio){
this.productoid = productoid;
}
}
EJERCICIO 7
Los métodos serán: Seis para dibujar por pantalla la imagen de los números. Otro para
lanzar(), que generará un número aleatorio entre 1 y 6, invocará al método dibujar
que le corresponda. En el constructor instanciar un objeto Random.
public class Dado {
/*
Los métodos serán: Seis para dibujar por pantalla la imagen de los números. Otro para
lanzar(),
que generará un número aleatorio entre 1 y 6,
invocará al método dibujar que le corresponda.
En el constructor instanciar un objeto Random.
*/
//Atributos
private Random aleatorio;
//Métodos
//Constructores
public Dado() {

aleatorio = new Random();

}
public String dibujaUno() {

return "\n" + " * " + "\n";
}
public String dibujaDos() {

return "\n" + "*" + "\n *";
}
public String dibujaTres() {

return "* \n * \n *";
}
public String dibujaCuatro() {

return "* *\n \n* *";
}
public String dibujaCinco() {

return "* *\n * \n* *";
}
public String dibujaSeis() {

return "* *\n* *\n* *";
}
public String lanzar() {

int numero = aleatorio.nextInt(6) + 1;
String resultado;
switch (numero) {
case 1:
resultado = dibujaUno();
break;
case 2:
resultado = dibujaDos();
break;
case 3:
resultado = dibujaTres();
break;
case 4:
resultado = dibujaCuatro();
break;
case 5:
resultado = dibujaCinco();
break;
case 6:
resultado = dibujaSeis();
break;
default:
resultado = "";
}
return resultado;
}
}
public class ProbarDado {
/**
*/
Dado d1 = new Dado();
String respuesta;
do {
System.out.println(d1.lanzar());
System.out.println("¿Quieres continuar ?");
} while (!respuesta.equalsIgnoreCase("n"));
}
}
EJEMPLO DE SOBRECARGA
public class Circulo {

//Atributo

private int radio;

// Métodos
public double area(){
return Math.PI * Math.pow(radio, 2);
}
//SobreCarga de un Método
/*
Cuando un método se llama de la misma forma pero tiene una definición diferente
*/
public String colorear(int rojo, int verde, int azul){
return "Se está usando la función RGB con los valores rojo : " + rojo + " verde: " +
verde + " azul : " + azul;
}

public String colorear(float matiz, float saturacion, float brillo){
return "Se está usando la función HSB con los valores matriz : " + matiz + "
saturación : " + saturacion + " brillo : " + brillo;
}

//Mostrar la información
@Override
public String toString() {
return "Circulo{" + "radio=" + radio + '}';
}

//Constructores
public Circulo() {

}
public Circulo(int radio) {

this.radio = radio;
}

//Setters y Getters
public int getRadio() {

return radio;
}
public void setRadio(int radio) {

this.radio = radio;
}

}
public class ProbarCirculo {
/**
*/
// Instanciar un objeto de la Clase Circulo, el nombre de objeto miCirculo

Circulo miCirculo = new Circulo();
miCirculo.setRadio(1);
System.out.println("Area del circulo es --> " + miCirculo.area());
System.out.println("Usando el RGB " + miCirculo.colorear(0, 0, 254));
System.out.println("Usando el HSB " + miCirculo.colorear(5.5f, 6.6f, 7.7f));
}

}
HERENCIA
public class Empleado {
//1. Atributos
private String nombre;
private double sueldo;
private LocalDate fNacimiento;
@Override
return "Empleado{" + "nombre=" + nombre + ", sueldo=" + sueldo + ",
fNacimiento=" + fNacimiento + '}';
}
public String getNombre() {

return nombre;
}
public void setNombre(String nombre) {

}
public double getSueldo() {

return sueldo;
}
public void setSueldo(double sueldo) {

this.sueldo = sueldo;
}
public LocalDate getfNacimiento() {

return fNacimiento;
}
public void setfNacimiento(LocalDate fNacimiento) {

this.fNacimiento = fNacimiento;
}

}
public class Gerente extends Empleado{

private int numSubordinados;
@Override
return "Gerente{" + "numSubordinados=" + numSubordinados + '}' +
super.toString();
}
public Gerente() {
}
public Gerente(int numSubordinados, String nombre, double sueldo, LocalDate

fNacimiento) {
super(nombre, sueldo, fNacimiento);
this.numSubordinados = numSubordinados;
}

public Gerente(String nombre, double sueldo, LocalDate fNacimiento) {
super(nombre, sueldo, fNacimiento);
}

public int getNumSubordinados() {

return numSubordinados;
}
public void setNumSubordinados(int numSubordinados) {

this.numSubordinados = numSubordinados;
}

}
public class ProbarHerencia {

// Instanciar un Emmpleado
Empleado e1 = new Empleado();

e1.setNombre("Luis Ramirez");
e1.setSueldo(3_500);
e1.setfNacimiento(LocalDate.of(1990, 2, 13));

System.out.println(e1.toString());

// Instanciar un Gerente

Gerente g1 = new Gerente();
g1.setNombre("José Ramos");
g1.setSueldo(5_000);
g1.setfNacimiento(LocalDate.of(1972,3,18));
g1.setNumSubordinados(10);

System.out.println(g1.toString());

//Instanciar un Gerente utilizando el constructor de tres argumentos

Gerente g2 = new Gerente("Adrian Bueno", 6_500, LocalDate.of(1970, 7, 7));

//Instanciar un Gerente utilizando el contructor de 4 argumentos

Gerente g3 = new Gerente(8, "Luis Cuellar", 4_500, LocalDate.of(1977, 8, 10));

}
}
EJERCICIO 1
 Crear la clase Figura encapsulada con las siguientes propiedades: coordenadaX y
coordenadaY (ambas de tipo entero) y un método posición() que devuelva la
posición de la figura.
 Crear las clases encapsuladas Círculo y Rectángulo heredando de la clase figura.
 La clase Círculo además tendrá la propiedad radio de tipo double y la clase
Rectángulo tendrá el ancho y el alto del rectángulo también de tipo double.
 Sobrescribir el método posición() para cada una de las clases y utilizar el
operador super para llamar al método sobrescrito.
 Crear la clase TestFiguras donde se crearán objetos de las tres clases, se darán
valores y mostraremos la posición de cada figura.
12/04/2021
public class InstrumentoMusical {

//1, Atributos
protected String marca;
//2. Métodos
public String emitirSonido(){
return "El instumento emite sonido";
}
@Override
return "InstrumentoMusical{" + "marca=" + marca + '}';
}
//3. Constructores

public InstrumentoMusical() {
}
public InstrumentoMusical(String marca) {
this.marca = marca;
}
//4. Getters y Setters
public String getMarca() {

return marca;
}
public void setMarca(String marca) {

this.marca = marca;
}

}
public Bateria() {
}
public Bateria(int nPlatillos, String marca) {

super(marca);
this.nPlatillos = nPlatillos;
}
public int getnPlatillos() {

return nPlatillos;
}
public void setnPlatillos(int nPlatillos) {

this.nPlatillos = nPlatillos;
}

}
public class Flauta extends InstrumentoMusical{

private String material;
@Override
public String emitirSonido() {
return "flu flu ..."; //To change body of generated methods, choose Tools
| Templates.
}
@Override
return "Flauta{" + "material=" + material + '}' + super.toString();
}
public Flauta() {

}
public Flauta(String material, String marca) {

super(marca);
this.material = material;
}
public String getMaterial() {

return material;
}
public void setMaterial(String material) {

this.material = material;
}

}
public class Guitarra extends InstrumentoMusical {
private String tiposCuerda;
@Override
public String emitirSonido() {
return "dl dl ..."; //To change body of generated methods, choose Tools |
Templates.
}
@Override
return "Guitarra{" + "tiposCuerda=" + tiposCuerda + '}' +
super.toString();
}
public Guitarra() {

}
public Guitarra(String tiposCuerda, String marca) {

super(marca);
this.tiposCuerda = tiposCuerda;
}
public String getTiposCuerda() {

return tiposCuerda;
}
public void setTiposCuerda(String tiposCuerda) {

this.tiposCuerda = tiposCuerda;
}

}
public class ProbarInstrumentos {
/**
*/

// Instanciar las 4 clases
InstrumentoMusical im1 = new InstrumentoMusical("Yamaha");
Bateria b1 = new Bateria(6, "Yamaha");
Flauta f1 = new Flauta("madera", "no tiene");
Guitarra g1 = new Guitarra("nylon", "Yamaha");

System.out.println("Información de cada objeto");
System.out.println(im1.toString());
System.out.println(b1.toString());
System.out.println(f1.toString());

System.out.println("Emitir sonido");
System.out.println(im1.emitirSonido());
System.out.println(b1.emitirSonido());
System.out.println(f1.emitirSonido());
System.out.println(g1.emitirSonido());

InstrumentoMusical[] instrumentos = new InstrumentoMusical[4];
instrumentos[0] = im1;
instrumentos[1] = b1;
instrumentos[2] = f1;
instrumentos[3] = g1;
System.out.println("---- Emitir sonido por bucle ----");
for (InstrumentoMusical elemento : instrumentos) {
System.out.println(elemento.emitirSonido());
}

}

}
EJERCICIO 1
Crear la clase abstracta Planta con un método abstracto:
void regar(int cantidad, int tiempo)
además crearemos todas propiedades y métodos que se os ocurran
Creamos las clases PlantaTropical, Cactus donde implementaremos el método abstracto.
Desde una clase principal crear objetos utilizando polimorfismo.
public abstract class Planta {

private char tipo; // 'E'-->exterior, 'I'-->interior
public abstract String regar(int cantidad, int tiempo);

@Override
return "Planta{" + "nombre=" + nombre + "tipo=" + tipo + '}';
}
public Planta(String nombre, char tipo) {

this.tipo = tipo;
}

return nombre;
}

}
public char getTipo() {

return tipo;
}
public void setTipo(char tipo) {

this.tipo = tipo;
}

}
public class PlantaTropical extends Planta {
public PlantaTropical(String nombre, char tipo) {

super(nombre, tipo);
}
@Override
public String regar(int cantidad, int tiempo) {
return "Regando una planta tropical. "

+ "La planta " + getNombre()
+ " se debe regar cada " + tiempo + " dias con " + cantidad + " litros de agua";
}
}
public class Cactus extends Planta {
public Cactus(String nombre, char tipo) {

super(nombre, tipo);
}
@Override
public String regar(int cantidad, int tiempo) {
return "Regando un cactus"
+ "La planta " + getNombre()
+ " se debe regar cada " + tiempo + " dias con " + cantidad + " litros de agua";
}

Planta objPlantaTropical = new PlantaTropical("Palmera", 'E');
Planta objCactus = new Cactus("Cephalocereus polylopha ", 'I');

Planta[] plantas = new Planta[2];

plantas[0] = objPlantaTropical;
plantas[1] = objCactus;

for (Planta elemento : plantas) {
System.out.println(elemento.regar(5, 5));
}
}
13/04/2021
Ejercicio de la pagina 65 del libro de teoría
Ejemplo de interfaces
Clase Vehículo
public interface ObjetoVolador {

String despegar();
String aterrizar();
String volar();
}
public class Vehiculo {

private String marca;
public String moverse(){

return "El vehículo se está moviendo";
}
@Override
return "Vehiculo{" + "marca=" + marca + '}';
}
public Vehiculo() {

}
public Vehiculo(String marca) {

this.marca = marca;
}
public String getMarca() {

return marca;
}
public void setMarca(String marca) {

this.marca = marca;
}

}
public class Avion extends Vehiculo implements ObjetoVolador{

private int numPasajeros;
@Override
public String despegar() {
return "El avión está despegando ...";
}
@Override
public String aterrizar() {
return "El avión está aterrizando ...";
}
@Override
public String volar() {
return "El avión está volando ...";
}
@Override
return "Avion{" + "numPasajeros=" + numPasajeros + '}';
}
public Avion() {

}
public Avion(int numPasajeros, String marca) {

super(marca);
this.numPasajeros = numPasajeros;
}
public int getNumPasajeros() {

return numPasajeros;
}
public void setNumPasajeros(int numPasajeros) {

this.numPasajeros = numPasajeros;
}

}
public class Animal {

public String comer(){
return "El animal está comiendo";
}

}
public class Ave extends Animal implements ObjetoVolador {

@Override
return "El ave está despegando ...";
}
@Override
return "El ave está aterrizando ...";
}
@Override
return "El ave está volando ...";
}

public String hacerNido(){
return "El ave está haciendo el nido ...";
}

public String ponerHuevos(){
return "El ave está poniendo huevos ...";
}
@Override
public String comer() {
return "El ave está comiendo...";
}

}
public class Kriptoniano extends Animal{
@Override
return "Kriptoniano comiendo ..."; //To change body of generated methods, choose
Tools | Templates.
}

}
public class Superman extends Kriptoniano implements ObjetoVolador{
@Override
return "Superman está despegando ...";
}
@Override
return "Superman está aterrizando ...";
}
@Override
return "Superman está volando ...";
}

public String saltarEdificio(){
return "Superman está saltando edificios para salvar a la gente atrapada ...";
}

public String detenerBala(){
return "Superman está deteniendo una bala";
}
@Override
return "Superman está comiendo su kriptonita"; //To change body of generated
methods, choose Tools | Templates.
}

}
public class ProbarInterfaces {
/**
*/
// Instanciar las clases que implementan el Objeto Volador

// Almacenar en un array de Objetos Voladores
ObjetoVolador[] voladores = new ObjetoVolador[5];

voladores[0] = new Avion(500, "BBXX");
voladores[1] = new Ave();
voladores[2] = new Superman();
voladores[3] = new Avion(350, "XXBB");
voladores[4] = new Ave();
for (ObjetoVolador elemento : voladores) {
System.out.println(elemento.getClass().getName());
System.out.println(elemento.despegar());
System.out.println(elemento.volar());
System.out.println(elemento.aterrizar());
}
}
}
EJERCICIO 2
Crear la clase abstracta Animal con los métodos abstractos comer() y moverse(). A
continuación crearemos varias clases Perro, Pez, Pajaro, Gusano, …etc.
 ¿Qué ocurre si no implemento todos los métodos?
 ¿Puedo crear instancias igualmente?
 ¿Puedo modificar parte de la definición de los métodos abstractos?
 ¿Puedo utilizar polimorfismo?
Crea clases extendiendo la clase Pajaro, por ejemplo Gorrión y Buitre.
 ¿También son abstractas estas clases?
EJERCICIO 2
Vamos a ampliar el ejercicio anterior creando otra interfaz ArticuloPeredecero
con el método: caducar()
Podemos crear otras clases Pan, Leche, …etc.
Tiene sentido crear dichas clases implementando ambas
interfaces(ArticuloVenta y ArticuloPeredecero)
Contesta a las siguientes preguntas:
 Estamos obligados a implementar todos los métodos?
 Qué ocurre si no los implementamos?
 Puedo cambiar el modificador de acceso a los métodos?
15/04/2021
EJERCICIO 1
Crear la clase globo con una variable estática entera para asignar la referencia
del globo.
En una clase principal PruebaGlobo se crearán distintos objetos y desde cada
uno de ellos se mostrará la referencia del globo.
EJERCICIO 2
Crear una clase Calculadora con métodos estáticos: suma, resta, multiplica y
divide. Desde una clase principal PruebasCalculadora invocar a los cuatro
métodos.
Ejercicio 2
Se quiere construir un programa para manejar una alcancía. En la alcancía es
posible guardar monedas de distintas
denominaciones: $50, $100, $200, $500 y $1000. No se guardan billetes o
monedas de otros valores.
El programa debe dar las siguientes opciones:
1. Agregar una moneda de una de las denominaciones que maneja,
2. Informar cuántas monedas tiene de cada denominación
3. Calcular el total de dinero ahorrado
4. Romper la alcancía, vaciando su contenido.
16/04/2021
public class Persona {

//1. Atributos

private final int id;
private String apellidos;

private static int contador = 0;

//2. Métodos

@Override
return "Persona{" + "id=" + id + ", nombre=" + nombre + ", apellidos=" +
apellidos + '}';
}
//3. Constructores

public Persona() {
this.id = ++contador;
}

public Persona(String nombre, String apellidos) {
this();
this.apellidos = apellidos;
}

//4. Setters y Getters

return nombre;
}

}
public String getApellidos() {

return apellidos;
}
public void setApellidos(String apellidos) {

this.apellidos = apellidos;
}
public static int getContador() {

return contador;
}
public static void setContador(int contador) {

Persona.contador = contador;
}

}

// Instanciar persona y mostrar los datos por consola

Persona p1 = new Persona();
System.out.println("Objeto p1 -> " + p1.toString());

Persona p2 = new Persona("Luis", "Lopez");
System.out.println("Objeto p2 -> " + p2.toString());
}

ENUMERACIONES AVANZADAS
public enum Palo {

PICAS("Picas"),
CORAZONES("Corazones"),
TREBOLES("Treboles"),
DIAMANTES("Diamantes");
//Atributo
private final String name;
//Constructor
private Palo(String name){
this.name = name;
}
//Getter
public String getName(){
return name;
}

}
public class NaipeBaraja {

//1.Atributos
private Palo palo;
private int rango;

//2. Métodos

@Override
return "NaipeBaraja{" + "palo=" + palo.getName() + ", rango=" + rango + '}';
}
public NaipeBaraja(Palo palo, int rango) {
this.palo = palo;
this.rango = rango;
}

//Setters y Getters

//
public Palo getPalo() {

return palo;
}
public void setPalo(Palo palo) {

this.palo = palo;
}
public int getRango() {

return rango;
}
public void setRango(int rango) {

this.rango = rango;
}
}

// Instanciar y mandar llamar al método toString

NaipeBaraja np1 = new NaipeBaraja(Palo.DIAMANTES, 0);
System.out.println(np1.toString());

}

Cambiar en el ejercicio de la Alcancía, cambiar valor por una enumeración

public enum Valor {
CINCUENTA(50),
CIEN(100),
DOSCIENTOS(200),
QUINIENTOS(500),
MIL(1000);

private final int valor; //atributo

private Valor(int valor){ //Contructor
this.valor = valor;
}
public int getValor() { //Getter

return valor;
}

}
public class Moneda {

//atributos
private Valor valor;
private int cantidad;

//Metodos

@Override
return "Moneda{" + "valor=" + valor + ", cantidad=" + cantidad + '}';
}

public Moneda() {

}
public Moneda(Valor valor) {

this.valor = valor;
}

public Moneda(Valor valor, int cantidad) {

this.valor = valor;
this.cantidad = cantidad;
}
public Valor getValor() {

return valor;
}
public void setValor(Valor valor) {

this.valor = valor;
}
public int getCantidad() {

return cantidad;
}
public void setCantidad(int cantidad) {

this.cantidad = cantidad;
}

}
public class Alcancia {

private Moneda[] monedas;

//Métodos
public String agregarMoneda(Valor valor){
String resultado = null;
for (Moneda e : monedas) {
if (e.getValor()==valor) {
e.setCantidad(e.getCantidad()+1);
resultado= "Se ha insertado una moneda de la denominación de -->" + valor;
break;
}
}

return resultado;
}
@Override
return "Alcancia{" + "monedas=" + Arrays.toString(monedas) + '}';
}

public int calcularTotal(){
int total = 0;
total+=e.getCantidad()*e.getValor().getValor();
}
return total;
}

public String romperAlcancia(){
String resultado = "Usted tiene ahorrado " + calcularTotal();
e.setCantidad(0);
}
return resultado;
}
public Alcancia() {
int indice = 0;
monedas = new Moneda[Valor.values().length];//Numero de celdas de monedas
for (Valor elemento : Valor.values()) {
monedas[indice++] = new Moneda(elemento, 0);
}
}
public Moneda[] getMonedas() {

return monedas;
}

}
public class ProbarAlcancia {
/**
*/
//Instanciar alcancía
Alcancia a1 = new Alcancia();
System.out.println(a1.agregarMoneda(Valor.CIEN));
System.out.println(a1.agregarMoneda(Valor.CINCUENTA));
System.out.println(a1.agregarMoneda(Valor.DOSCIENTOS));
System.out.println(a1.agregarMoneda(Valor.MIL));
System.out.println(a1.agregarMoneda(Valor.MIL));
System.out.println("Total ->" + a1.calcularTotal());
System.out.println(a1.toString());
System.out.println(a1.romperAlcancia());
System.out.println(a1.toString());
}

}
Ejercicio 3.
Realizar un proyecto en java para cumplir con los siguientes requerimientos:
Del empleado se maneja la siguiente información:
• Nombre
• Apellido
• Género (femenino o masculino).
• Fecha de nacimiento. De tipo LocalDate
• Fecha de ingreso a la empresa. De tipo LocalDate
• Salario básico.
El proyecto permite visualizar la información del empleado, y hacer los siguientes
cálculos:
• Edad del empleado, utilizando la fecha de nacimiento del empleado.
• Antigüedad del empleado, utilizando la fecha de ingreso del empleado.
• Prestaciones a las que tiene derecho el empleado. Para este cálculo se debe usar la
siguiente fórmula:
prestaciones= (antiguedad*salario)/12
19/04/2021
20/04/2021
Ejercicio 6
Desarrollar un programa para manejar las reservas de un vuelo. Se

sabe que el avión tiene 50 sillas, de las cuales 8 son de clase
ejecutiva y las demás de clase económica. Las sillas ejecutivas se
acomodan en filas de cuatro, separadas en el medio por el corredor.
Las sillas económicas se acomodan en filas de seis, tres a cada lado
del corredor.
Cuando un pasajero llega a solicitar una silla, indica sus datos
personales y sus preferencias con respecto a la posición de la silla en
el avión. Los datos del pasajero que le interesan a la aerolínea son el
nombre y el DNI. Para dar la ubicación deseada, el pasajero indica la
clase y la ubicación de la silla. Esta puede ser, en el caso de las
ejecutivas, ventana y pasillo, y en el de las económicas, ventana,
pasillo y centro. La asignación de la silla en el avión se hace en orden
de llegada, tomando en cuenta las preferencias anteriores y las
disponibilidades.
Ejercicios
21/04/2021
Ejercicio 4.
Se quiere crear un proyecto que permita simular el comportamiento de las
cuentas bancarias de un cliente. Un cliente puede
tener tres productos financieros básicos:
1. Una cuenta corriente. El cliente puede depositar o retirar dinero, pero no
recibe ningún interés por el dinero que se
encuentre allí depositado.
2. Una cuenta de ahorros. El cliente puede depositar o retirar dinero, y recibe
un interés mensual del 0.6% sobre el
saldo actual.
3. Un certificado de depósito a término CDT. Cuando el cliente abre un CDT,
define la cantidad de dinero que quiere
invertir y negocia con el banco el interés mensual que va a recibir. A diferencia
de la cuenta corriente o la cuenta de
ahorros, en un CDT no se puede consignar ni retirar dinero. La única operación
posible es cerrarlo, en cuyo caso, el
dinero y sus intereses pasan a la cuenta corriente.
Estos productos son independientes y tienen comportamientos particulares. El
saldo total de la cuenta es la suma de lo que el
cliente tiene en cada uno de dichos productos.
El programa debe permitir al usuario:
1. Visualizar el saldo de la cuenta corriente del cliente.
2. Visualizar el saldo de la cuenta de ahorros del cliente.
3. Visualizar el saldo del CDT del cliente.
4. Visualizar el saldo total que tiene el cliente en los productos del banco.
5. Invertir un monto de dinero en un CDT.
6. Cerrar la inversión en CDT.
7. Ingresar un monto de dinero en la cuenta corriente del cliente.
8. Retirar un monto de dinero en la cuenta corriente del cliente.
9. Ingresar un monto de dinero en la cuenta de ahorros del cliente.
10. Retirar un monto de dinero en la cuenta de ahorros del cliente.
29/04/2021
public class PrecioInvalidoExepcion extends Exception{
public PrecioInvalidoExepcion() {

super("El precio debe ser mayor o igual a cero");
}

public PrecioInvalidoExepcion(double precio) {
super("El precio debe ser mayor o igual a cero, el precio no valido es " + precio);
}

}

//Atributos
private int idProducto;
private String nombreProducto;
private double precio;

//Métodos
@Override
return "Producto{" + "idProducto=" + idProducto + ", nombreProducto=" +
nombreProducto + ", precio=" + precio + '}';
}

//Constructores
public Producto() {

}
public Producto(int idProducto, String nombreProducto, double precio) throws

PrecioInvalidoExepcion {
this.idProducto = idProducto;
this.nombreProducto = nombreProducto;
setPrecio(precio);
}

//Setters y getters
public int getIdProducto() {

return idProducto;
}
public void setIdProducto(int idProducto) {

this.idProducto = idProducto;
}
public String getNombreProducto() {

return nombreProducto;
}
public void setNombreProducto(String nombreProducto) {

this.nombreProducto = nombreProducto;
}
public double getPrecio() {

return precio;
}
public void setPrecio(double precio) throws PrecioInvalidoExepcion {

if (precio >= 0) {
}
else{
throw new PrecioInvalidoExepcion(precio);
}

}

}
public class ProbarPrecioUnitario {
/**
*/
// Instanciar la clase Producto
Producto p1 = new Producto();
try {
p1.setPrecio(100);
} catch (PrecioInvalidoExepcion pepito) {
System.out.println(pepito.toString());
}
System.out.println("Información del objeto -> " + p1.toString());
}

}
public class BicicletaException extends Exception{
public BicicletaException(String elemento, int cantidad) {

super(String.format("El elemento %s tiene un número inválido %d",elemento,
cantidad));
}

}
EJERCICIO 5
Cree un programa que implemente un diccionario. El diccionario debe contener
palabras en castellano y una lista de posibles significados de cada palabra.
Crear la clase Palabra que permita almacenar la información de una palabra,
junto con sus definiciones.
Utilizar un objeto HashMap para almacenar palabras en la clase Diccionario.
05/05/2021
Ejercicio 1
Solicitar por consola un texto, del cual se pide que se muestren las diferentes
palabras.
Ejercicio 1
Solicitar por consola un texto, del cual se pide que se muestren las diferentes palabras.
// 1. Declaración de variables
String[] palabras;
String[] puntuacion = {",",".",";",":"};
Set<String> diferentes= new HashSet();
String texto;

//Solicitar la frase

System.out.println("Escriba un texto para analizar -> ");
texto = s1.nextLine();

//Limpia la frase
for (String elemento : puntuacion) {
texto = texto.replace(elemento, " ");
}
// System.out.println("texto limpio -> " + texto);
palabras = texto.split(" ");

for (String elemento : palabras) {
if (elemento.trim().length()>0) {
diferentes.add(elemento.trim());
}

}
Iterator<String> recorrer = diferentes.iterator();
while (recorrer.hasNext()) {
System.out.println("palabra -> (" + recorrer.next()+")");
}

}

Contar las veces que las palabras
se repiten

String[] palabras;
String[] puntuacion = {",",".",";",":"};
Map<String,Integer> diferentes= new HashMap();
String texto;

//Solicitar la frase

System.out.println("Escriba un texto para analizar -> ");
texto = s1.nextLine();

//Limpia la frase
for (String elemento : puntuacion) {
texto = texto.replace(elemento, " ");
}
// System.out.println("texto limpio -> " + texto);
palabras = texto.split(" ");

for (String elemento : palabras) {
if (elemento.trim().length()>0) {
Integer valor = diferentes.get(elemento);
if (valor==null) {
diferentes.put(elemento, 1);
}else{
diferentes.put(elemento, ++valor);
}

}

}

System.out.println("el hashtable es "+ diferentes);

}

}
public class MainArrayLIst {
/**
*/
// Menú principal
ArrayList<Double> alturas = new ArrayList();
String opcion;
do {
System.out.println("Elegir la opción \n");
System.out.println("1. Nueva altura");
System.out.println("2. Altura media");
System.out.println("3. Altura máxima");
System.out.println("4. Altura mínima");
System.out.println("5. Mostrar todas las alturas");
System.out.println("6. Salir");
opcion = s1.next();
switch (Integer.parseInt(opcion)) {

case 1:
System.out.println("Escriba la altura ->");
Double altura = s1.nextDouble();
añadirAltura(alturas, altura);
break;
case 2:
System.out.println("Media -> " + calcularMedia(alturas));
break;
case 3:
System.out.println("Altura Máxima -> " + calcularMaxima(alturas));
break;
case 4:
System.out.println("Altura Mínima -> " + calcularMinima(alturas));
break;
case 5:
System.out.println("Las alturas son : " + alturas);
break;

}
} while (!opcion.equals("6"));
}
private static void añadirAltura(ArrayList<Double> alturas, Double altura) {

alturas.add(altura);
}
private static double calcularMedia(ArrayList<Double> alturas) {
double suma = 0;
for (Double elemento : alturas) {
suma += elemento;
}
return suma / alturas.size();
}
private static double calcularMaxima(ArrayList<Double> alturas) {

Collections.sort(alturas);
return alturas.get(alturas.size() - 1);
}
private static double calcularMinima(ArrayList<Double> alturas) {

Collections.sort(alturas);
return alturas.get(0);
}
}

}
06/05/2021
Ejemplo de implementacion del Comparable y Comparator
public class Estudiante implements Comparable<Estudiante>{

private String idEstudiante;
private Double nota;
@Override
public int compareTo(Estudiante o) {
return idEstudiante.compareTo(o.idEstudiante);
}
@Override
return "Estudiante{" + "idEstudiante=" + idEstudiante + ", nombre=" + nombre +
", nota=" + nota + '}'+"\n";
}
public Estudiante() {

}
public Estudiante(String idEstudiante, String nombre, Double nota) {

this.idEstudiante = idEstudiante;
this.nota = nota;
}
public String getIdEstudiante() {

return idEstudiante;
}
public void setIdEstudiante(String idEstudiante) {

this.idEstudiante = idEstudiante;
}

return nombre;
}

}
public Double getNota() {

return nota;
}
public void setNota(Double nota) {

this.nota = nota;
}

}
public class PorNombre implements Comparator<Estudiante>{
@Override
public int compare(Estudiante o1, Estudiante o2) {
return o1.getNombre().compareTo(o2.getNombre());
}

}
public class PorNota implements Comparator<Estudiante>{
@Override
public int compare(Estudiante o1, Estudiante o2) {
return o1.getNota().compareTo(o2.getNota());
}

}

// Instanciar un Array de Estudiantes
List<Estudiante> estudiantes = new ArrayList();
estudiantes.add(new Estudiante("3", "Raul Ramirez", 5.6));
estudiantes.add(new Estudiante("1", "Victor Rodriguez", 8.5));
estudiantes.add(new Estudiante("2", "Ana Alvarez", 7.5));
estudiantes.add(new Estudiante("4", "Carolina Contreras", 5.5));

System.out.println("--- Mostrar los datos antes de ordenarlos ---");
System.out.println(estudiantes);

Collections.sort(estudiantes);

System.out.println("--- Mostrar los datos después de ordenarlos por
idEstudiante---");

System.out.println("--- Mostrar los datos después de ordenarlos por nota---");
PorNota pn1 = new PorNota();
Collections.sort(estudiantes, pn1);

System.out.println("--- Mostrar los datos desués de ordenarlos por nombre ---");
PorNombre pn2 = new PorNombre();
Collections.sort(estudiantes, pn2);

}

}
Ordenando por 2 criterios

EJERCICIO 1
Cree un programa que represente una urna de la que se pueden sacar y meter bolas.
Debemos tener en cuenta lo siguiente:
 El número de bolas que puede haber en la urna puede ser definido bien en el
constructor o bien con un método que cambie el número de bolas.
 Se ha de tener en cuenta que no hay bolas repetidas por lo que definiremos la urna
como una colección de este tipo.
 Crear un método cambiaBolas que elimina las actuales y añade nuevas bolas.
 También tendremos un método meterBola donde se añadirá una nueva bola a la urna.
 El método sacarBola devolverá una bola siempre que la urna no esté vacía.
Desde el método principal se realizarán las siguientes operaciones:
 se creará la urna con 10 bolas
 se sacarán 3 de ellas
 se cambia el número de bolas de la urna a 100
 se añade una nueva bola que no debe ser repetida, si es así mostraremos un mensaje.
11/05/2021
EJERCICIO 1
Crear una clase hilo llamada Contador con una propiedad incremento que
será inicializada con un valor pasado al constructor.
El hilo creará un bucle con 15 iteraciones donde se mostrará un número,

posteriormente se incrementará con el valor de la propiedad incremento y
dormiremos el hilo durante 10 milisegundos.
Desde una clase principal denominada PruebaContador generaremos dos

hilos, les asignaremos una prioridad y los arrancaremos.
EJERCICIO 2
Crear una clase llamada Ratones que herede de la clase Thread con dos
métodos sincronizados comer y llenar.
El programa consiste en crear dos hilos de este clase y que coman mientras
haya comida en el plato. Cuando el plato esté vacío se deberá llenar de nuevo.
Recurso
Productor
Consumidor
Main
// Leer de la consola y escribir en un fichero plano (texto)
Scanner s1 = new Scanner(System.in, "ISO-8859-1");
PrintWriter fSalida;

try {
//Instanciar el FileWriter
fSalida = new PrintWriter("bitacora.txt");
while (true) {
System.out.println("Escriba una línea para ser grabada en el archivo
bitacora");
String linea = s1.nextLine();
fSalida.write(linea+"\n");
System.out.println("Desea escribir otra linea S/N");
String respuesta = s1.nextLine();
if (respuesta.equalsIgnoreCase("n")) {
break;

}
}
// fSalida.flush();
fSalida.close();
} catch (IOException ex) {
System.out.println(ex.toString());
}

Lectura de fichero

// Leer el fichero bitacora.txt con la clase FileReader y BufferedReader
// tiene métodos de read y readline

//Definir variables
FileReader fEntrada;
BufferedReader buffer;
String linea;

try {
//Instanciar las clases de FileReader y BufferedReader
fEntrada = new FileReader("bitacora.txt");
buffer = new BufferedReader(fEntrada);
while ((linea=buffer.readLine())!=null) {
//Entra si no es nulo
System.out.println(linea);

}
fEntrada.close();
} catch (FileNotFoundException ex) {
}

}

}

USO DE ARGUMENTOS DE ENTREADA DE PROYECTO
// Recorrer los argumentos que entran al proyecto
for (String elemento : args) {
System.out.println("Argumentos del proyecto -> " + elemento);
}
}

USO DE PROPIEDADES
Properties props = System.getProperties();
props.list(System.out);
}

UTILIZANDO COMO BUFFER UN ARRAY DE CHAR
public static void main(String[] nombreFicheros) {

FileReader input = null;
FileWriter output = null;
try {
input = new FileReader(nombreFicheros[0]);
output = new FileWriter(nombreFicheros[1]);
char[] buffer = new char[128];
int charsRead;
//Primera lectura
charsRead = input.read(buffer);
while (charsRead != -1) {
//Escribir lo leido
output.write(buffer, 0, charsRead);
// Lee el siguiente buffer
charsRead = input.read(buffer);
}
}
finally{
try {
output.close();
input.close();
}

}
}

UTILIZANDO LA CLASE BUFFEREDREADER
//Declaración de variables
FileReader input;
BufferedReader bufInput = null;
FileWriter output;
BufferedWriter bufOutput = null;

try {
//Instanciar los objetos
input = new FileReader(args[0]);
bufInput = new BufferedReader(input);
output = new FileWriter(args[1]);
bufOutput = new BufferedWriter(output);
String line;
//Se lee la linea
line = bufInput.readLine();
while (line != null) {
//Escribir lo leido
bufOutput.write(line, 0, line.length());
bufOutput.newLine();
line = bufInput.readLine();
}
}
finally{
try {
bufOutput.close();
bufInput.close();
}
}

}

}

EJERCICIO 1
Crear un programa que muestre la lista de ficheros y directorios del directorio:
C:\windows

17/05/2021
Ejercicio
Realizar un bucle para solicitar por la Consola precios.

Grabarlo en un fichero de salida con el nombre de precios.dat
Leer el fichero para calcular el promedio de los precios que se han almacenado
en el fichero
Clase Cliente
package com.vipper.modelo;
import java.io.Serializable;
public class Cliente implements Serializable{

private String nombre, NIF;
private double credito;
public Cliente() {

}
public Cliente(String nombre, String NIF, double credito) {

this.NIF = NIF;
this.credito = credito;
}
// SETT´S

}

public void setNIF(String NIF) {
this.NIF = NIF;
}
public void setCredito(double credito) {
this.credito = credito;
}

// GETT´S
return nombre;
}
public String getNIF() {

return NIF;
}
public double getCredito() {

return credito;
}

// METODOS
@Override
return "\tNIF:" + NIF+ "\t nombre:" + nombre +"\t Imp. Credito:"+
credito;
}
}
Clase GrabarCliente
package com.vipper.presentacion;
import com.vipper.modelo.Cliente;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.util.Scanner;
import java.util.logging.Level;
import java.util.logging.Logger;
public class Main04_GrabarClientes {


Scanner sc =new Scanner(System.in);
FileOutputStream fSalida;
ObjectOutputStream objeto;
Cliente cliente;
String salir;

try {
fSalida= new FileOutputStream("Cliente.dat",true);
objeto= new ObjectOutputStream(fSalida);

do{
cliente= new Cliente();
System.out.print("NIF Cliente: ");
cliente.setNIF(sc.next());
System.out.print("Nombre cliente: ");
cliente.setNombre(sc.next());
System.out.print("Importe Credito: ");
cliente.setCredito(sc.nextDouble());
objeto.writeObject(cliente);
System.out.print("Desea Salir [S/N]? ");
salir=sc.next().toUpperCase();
}while(salir.equals("N"));
fSalida.close();

Logger.getLogger(Main04_GrabarClientes.class.getName()).log(Level.SEVERE,
null, ex);

Logger.getLogger(Main04_GrabarClientes.class.getName()).log(Level.SEVERE,
null, ex);
}
}
Clase LeerCliente
package com.vipper.presentacion;
import com.vipper.modelo.Cliente;
import java.io.EOFException;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.util.logging.Level;
import java.util.logging.Logger;
public class Main04_LeerClientes {

FileInputStream fEntrada;
ObjectInputStream objeto;
Cliente cl1;
double tot_credit=0.0;
try {
fEntrada= new FileInputStream("Cliente.dat");
objeto= new ObjectInputStream(fEntrada);
while(true){

try {
cl1=(Cliente) objeto.readObject();
tot_credit+=cl1.getCredito();
System.out.println(cl1.toString());

} catch (EOFException ex) {
break;
} catch (ClassNotFoundException ex) {

Logger.getLogger(Main03_LecturaObjetos.class.getName()).log(Level.SEVERE,
null, ex);
}
}
System.out.println("\n\t El montante de los creditos es:
"+tot_credit+"\n");
fEntrada.close();

null, ex);

null, ex);
}
}
Crear fichero plano - grabar las alturas
public class CrearFicheroPlano {
/**
*/
Double altura;
FileWriter fs;
try {
fs = new FileWriter("alturas.txt", true);
while(true){
System.out.println("Escriba la altura -> ");
altura = s1.nextDouble();
if (altura == -1) {
break;
}
fs.write(altura.toString() + "|");
}
fs.close();
}
}
LEER ALTURAS

//1. Definicion de variables
BufferedReader buffer;
String[] alturas;
String linea, stringAlturas = "";
double suma = 0;

try {
//Se instancia el buffer
buffer = new BufferedReader(new FileReader("alturas.txt"));
while ((linea = buffer.readLine())!=null) {
stringAlturas += linea;
}
alturas = stringAlturas.split("[|]");
for (String elemento : alturas) {
suma += Double.parseDouble(elemento);
}
System.out.printf("El promedio de alturas es --> %.3f", suma /
alturas.length);

}

}
19/05/2021
try {
// Obtener datos asociados al servidor de google
InetAddress i1 = InetAddress.getByName("www.google.es");
System.out.println("Nombre del host --> " + i1.getHostName());
System.out.println("Nombre del host completo --> " +
i1.getCanonicalHostName());
System.out.println("Direccion IP -> " + i1.getHostAddress());
System.out.println("Direccion IP en octetos");
for (int i = 0; i < i1.getAddress().length; i++) {
System.out.println("Octeto -> " + i1.getAddress()[i]);
}
} catch (UnknownHostException ex) {
}
}

// Hacer una solicitud a un servidor desde el puerto 80
String url = "google.es";
int puerto = 80;
Socket sc;
BufferedReader bf;
PrintWriter out;
try {
sc = new Socket(url, puerto);
bf = new BufferedReader(new
InputStreamReader(sc.getInputStream()));
out = new PrintWriter(sc.getOutputStream(),true);
out.println("GET /");
String s = null;
System.out.println("---- Mensaje recibido por el servidor ---");
while ((s=bf.readLine())!= null) {
System.out.println(s);
}
bf.close();
out.close();
sc.close();

}

}

SERVIDOR

// Crear una clase que haga la funcion de un servidor
//1. Declarar variables
ServerSocket s = null;
PrintWriter out;

try {
//2. Instanciar el ServerSocket
s = new ServerSocket(3000);
while (true) {
System.out.println("El servidor está esperando una petición ....");
//3. Ponerlo a la escucha
Socket s1 = s.accept(); //espera hasta que llega un socket cliente al
servidor
//4. Leer la peticion
//5. Escribir la respuesta
out = new PrintWriter(new
OutputStreamWriter(s1.getOutputStream()));
out.write("Hola mundo desde el servidor \n");
out.close();
s1.close();
}

}
}

}
CLIENTE

//1. Declarar variables
Socket s1 = null;
BufferedReader bf;
try {
//2. Instanciar el socket
s1 = new Socket("localhost", 3000);
//3. Leer la contestacion del servidor
bf = new BufferedReader(new
InputStreamReader(s1.getInputStream()));
System.out.println(bf.readLine());
bf.close();
s1.close();

}
}
}
PROCESA CONEXION
public class ProcesaConexion extends Thread{

//atributos
Socket sc;
int peticion;

//constructor
public ProcesaConexion(Socket sc, int peticion) {

this.sc = sc;
this.peticion = peticion;
}

public void run(){
try {
//Stream (flujo de datos) para escribir en el socket
OutputStream salidaSocket = sc.getOutputStream();
PrintWriter out = new PrintWriter(salidaSocket);

//Stream (flujo de datos) para leer del socket
InputStream entradaSocket = sc.getInputStream();
InputStreamReader lecturaTextoSocket = new
InputStreamReader(entradaSocket);
BufferedReader bf = new BufferedReader(lecturaTextoSocket);

//recuperar la cadena enviada por el cliente
String nombre = bf.readLine();

//Envía 10 mensajes al cliente y le dice que número de petición es
out.print("----Peticion " + peticion + "----\n");
for (int i = 1; i <= 10; i++) {
out.print("mensaje " + i + " para el cliente " + nombre + "su numero de
petición es --> " + peticion + "\n");
out.flush();
Thread.sleep(200);
}
sc.close();

} catch (InterruptedException ex) {
}
}

}
SERVERSIMULACION
public class ServerSimulacion {
/**
*/
// Declarar variables
int puerto = 3000;
int peticion = 0;
try {
//Instanciar el ServerSocket (función de un demonio)
ServerSocket servidor = new ServerSocket(puerto);
//Bucle infinito para que esté escuchado peticiones
while (true) {
System.out.println("Esperando peticion ....");
//Cuando recibe una petición desde un cliente, crea un hilo para atenderlo,
//pasándole el socket que representa la conexion
Socket con = servidor.accept();
//(new ProcesaConexion(con, peticion)).start();
ProcesaConexion pc1 = new ProcesaConexion(con, peticion);
pc1.start();
peticion++;

}
}

}

}
CLIENTE SIMULACION
public class ClienteSimulacion {
/**
*/
int puerto = 3000;
String mensaje = null;
try {
//El cliente le tiene que enviar un socket al servidor
//Es por eso que instanciamos este socket
Socket conexion = new Socket("localhost", puerto);
//Escribir la respuesta en el socket
PrintWriter out = new PrintWriter(conexion.getOutputStream(), true);
//Solicitar por consola el nombre del usuario
InputStreamReader lecturaConsola = new InputStreamReader(System.in);
BufferedReader lecturaTeclado = new BufferedReader(lecturaConsola);
System.out.print("Escriba su nombre -->");
String nombre = lecturaTeclado.readLine();
out.println(nombre);
out.flush(); //Esto es lo que le llega al servidor
//Viene de vuelta del Servidor

//Leer la información del socket
InputStreamReader r1 = new InputStreamReader(conexion.getInputStream());
BufferedReader lectorSocket = new BufferedReader(r1);
while ((mensaje = lectorSocket.readLine()) != null) {
System.out.println("Mensaje recibido --> " + mensaje);
}
conexion.close();

}

}

}
20/05/201
CLIENTE
public class Cliente {
/**
*/
try {
Random r1 = new Random();
Socket s1 = new Socket("localhost", 3000);
PrintWriter peticion = new PrintWriter(s1.getOutputStream(),true);
peticion.println("Esta es la peticion ..." + r1.nextInt(101));
peticion.flush();

//Leer la respuesta que viene del servidor
InputStreamReader respuesta = new InputStreamReader(s1.getInputStream());
BufferedReader bRespuesta = new BufferedReader(respuesta);
System.out.println("Respuesta del servidor --> " + bRespuesta.readLine());
s1.close();
peticion.close();
respuesta.close();

}
}

}
SERVIDOR

try {
ServerSocket s = new ServerSocket(3000);
while (true) {
System.out.println("El servidor esta escuchando en el 3000 las peticiones de
los clientes...");
Socket s1 = s.accept();
//Leer la peticion del cliente
InputStreamReader r1 = new InputStreamReader(s1.getInputStream());
BufferedReader peticion = new BufferedReader(r1);
System.out.println("El servidor lee -> " + peticion.readLine());

//Escribir en un OutputStream
PrintWriter out = new PrintWriter(s1.getOutputStream());
out.write("Se ha recibido su petion \n");
out.close();
r1.close();
s1.close();
}
}
}

}
Ejercicio
Se desea simular una cadena de tiendas

Cada tienda al final del día va reportar sus ventas (idtienda, nombre de la tienda,
ventas).
El servidor debe estar en escucha para recibir los datos de cada tienda y generar un
fichero de texto plano recabando la información de cada tienda, incluyendo la fecha del
día.
public class Tienda {

//Atributos
private int idTienda;
private String nombreTienda;
private double ventas;

//Métodos
@Override
return String.format("%-15s %d %-15s %.4f %n" , LocalDate.now().toString(),
idTienda, nombreTienda, ventas);
}
public Tienda() {

}

public Tienda(int idTienda, String nombreTienda, double ventas) {
this.idTienda = idTienda;
this.nombreTienda = nombreTienda;
this.ventas = ventas;
}
public int getIdTienda() {

return idTienda;
}
public void setIdTienda(int idTienda) {

this.idTienda = idTienda;
}
public String getNombreTienda() {

return nombreTienda;
}
public void setNombreTienda(String nombreTienda) {

this.nombreTienda = nombreTienda;
}
public double getVentas() {

return ventas;
}
public void setVentas(double ventas) {

this.ventas = ventas;
}

}
CLIENTETIENDA

// 1. Solicitar los datos de las tiendas
Tienda t1 = solicitarDatosVenta();
try {
// 2. Crear la conexion con el servidor
Socket peticion = new Socket("localhost", 3000);
// 3. Escribir en el outputStream
PrintWriter sSalida = new PrintWriter(peticion.getOutputStream(),true);
sSalida.println(t1.toString());
// sSalida.flush();
// 4. Leer que ha llegado las ventas
BufferedReader bf = new BufferedReader(new
InputStreamReader(peticion.getInputStream()));
System.out.println(bf.readLine());
Logger.getLogger(ClienteTienda.class.getName()).log(Level.SEVERE, null,
ex);
}

}
private static Tienda solicitarDatosVenta() {

Tienda t1 = new Tienda();
System.out.print("Escriba el numero de la tienda ->");
t1.setIdTienda(s1.nextInt());
System.out.print("Escriba el nombre de la tienda ->");
t1.setNombreTienda(s1.next());
System.out.print("Escriba las ventas de la tienda ->");
t1.setVentas(s1.nextDouble());
return t1;

}

}
SERVIDORTIENDA

FileWriter fs = null;
int contadorTransaccion = 0;
try {
//1. Instanciar el ServerSocket
ServerSocket servidor = new ServerSocket(3000);
fs = new FileWriter("Ventas.txt", true);
//2. Ponerlo a la escucha
while (true) {
System.out.println("En espera de registrar ventas ...");
//3. Obtener el socket
Socket s1 = servidor.accept();
//4. Leer el Stream
contadorTransaccion++;
BufferedReader bf = new BufferedReader(new
InputStreamReader(s1.getInputStream()));
fs.write(bf.readLine() + "\n");
fs.flush();
//5. Escribir la confirmación de recibido
PrintWriter sRespuesta = new PrintWriter(s1.getOutputStream(),true);
sRespuesta.println("Se han recibido sus datos correctamente id -> " +
contadorTransaccion);

}

Logger.getLogger(ServidorTienda.class.getName()).log(Level.SEVERE, null,
ex);
}finally{
try {
fs.close();
}
}

}

}
25/05/2021
VERSION DE LA PROFESORA
public class EstadisticaCovid implements Serializable{

//Atributos
private LocalDate fecha;
private int incrementoMuertos;
private int muertos;
private double muertosMillon;
private int incrementoConfirmados;
private int confirmados;
private double cofirmadosCienMil;

//Métodos

public String formatoCSV() {
return String.format("%s,%s,%s,%s,%s,%s,%s",
fecha,incrementoMuertos, muertos , muertosMillon, incrementoConfirmados ,
confirmados , cofirmadosCienMil) ;
}
@Override
return "EstadisticaCovid{" + "fecha=" + fecha + ", incrementoMuertos="
+ incrementoMuertos + ", muertos=" + muertos + ", muertosMillon=" +
muertosMillon + ", incrementoConfirmados=" + incrementoConfirmados + ",
confirmados=" + confirmados + ", cofirmadosCienMil=" + cofirmadosCienMil +
'}';
}

public EstadisticaCovid crearAtributo(EstadisticaCovid ec1, int i, String
elemento) {
System.out.println("Entra a crear atributo -->" + elemento + "i-> " + i);
switch (i) {
case 0:
ec1.setFecha(LocalDate.parse(elemento));
break;
case 1:
ec1.setIncrementoMuertos(Integer.parseInt(elemento));
break;
case 2:
ec1.setMuertos(Integer.parseInt(elemento));
break;
case 3:
ec1.setMuertosMillon(Double.parseDouble(elemento));
break;
case 4:
ec1.setIncrementoConfirmados(Integer.parseInt(elemento));
break;
case 5:
ec1.setConfirmados(Integer.parseInt(elemento));
break;
case 6:
ec1.setCofirmadosCienMil(Double.parseDouble(elemento));
break;
}
return ec1;
}

//Constructores
public EstadisticaCovid() {

}
public EstadisticaCovid(LocalDate fecha, int incrementoMuertos, int muertos,

double muertosMillon, int incrementoConfirmados, int confirmados, double
cofirmadosCienMil) {
this.fecha = fecha;
this.incrementoMuertos = incrementoMuertos;
this.muertos = muertos;
this.muertosMillon = muertosMillon;
this.incrementoConfirmados = incrementoConfirmados;
this.confirmados = confirmados;
this.cofirmadosCienMil = cofirmadosCienMil;
}
public double getCofirmadosCienMil() {

return cofirmadosCienMil;
}
public void setCofirmadosCienMil(double cofirmadosCienMil) {

this.cofirmadosCienMil = cofirmadosCienMil;
}
public LocalDate getFecha() {

return fecha;
}
public void setFecha(LocalDate fecha) {

this.fecha = fecha;
}

public int getIncrementoMuertos() {

return incrementoMuertos;
}
public void setIncrementoMuertos(int incrementoMuertos) {

this.incrementoMuertos = incrementoMuertos;
}
public int getMuertos() {

return muertos;
}
public void setMuertos(int muertos) {

}
public double getMuertosMillon() {

return muertosMillon;
}
public void setMuertosMillon(double muertosMillon) {

}
public int getIncrementoConfirmados() {

return incrementoConfirmados;
}
public void setIncrementoConfirmados(int incrementoConfirmados) {

this.incrementoConfirmados = incrementoConfirmados;
}
public int getConfirmados() {

return confirmados;
}
public void setConfirmados(int confirmados) {

}

}
CLASE QUE LEE DESDE HTML
public class ObtenerTexto {
/**
*/
public static void main(String[] args) throws FileNotFoundException {
// Obtener el contenido de la pagina google

//1. Definir un objeto URL, un Buffered Reader, una String para leer cada
línea y un Stringbuilder para ir uniendo la cadena
URL u1;
BufferedReader b1;
String cad;
StringBuilder datos = new StringBuilder();
try {
u1 = new
URL("https://datosmacro.expansion.com/otros/coronavirus/espana");
//2. Obtener el stream
b1 = new BufferedReader(new InputStreamReader(u1.openStream()));
//3. Leer el stream obtenido
while ((cad = b1.readLine()) != null) {
datos.append(cad);
}
procesaDatos(datos.toString());
} catch (MalformedURLException ex) {
Logger.getLogger(ObtenerTexto.class.getName()).log(Level.SEVERE,
null, ex);
Logger.getLogger(ObtenerTexto.class.getName()).log(Level.SEVERE,
null, ex);
}
}
private static void procesaDatos(String datos) {
int posicionInicial;

int posicionFinal;
String tabla;
EstadisticaCovid ec1 = null;
//Definicion de variables para grabar el fichero de texto plano
PrintWriter fSalida = null;
//Definición de variables para grabar el fichero en binario
FileOutputStream fSalidaObjeto;
ObjectOutputStream objBinario = null;
try {
fSalida = new PrintWriter("EstadisticaCovid.txt");
objBinario = new ObjectOutputStream(new
FileOutputStream("EstadisticaCovid.dat"));
posicionInicial = datos.indexOf("<tbody>");
posicionFinal = datos.indexOf("</tbody>");
tabla = datos.substring(posicionInicial, posicionFinal);
posicionInicial = 0;
while (true) {
ec1 = new EstadisticaCovid();
for (int i = 0; i < 7; i++) { //Para obtener una fila
posicionInicial = tabla.indexOf("data-value", posicionInicial) +
"data-value=\"".length(); //Calcula la posición inicial
if (posicionInicial == -1) {
break;
}
posicionFinal = tabla.indexOf("\">", posicionInicial); //Calcula la
posición final
String elemento = tabla.substring(posicionInicial,
posicionFinal); // Extrae el dato
ec1 = ec1.crearAtributo(ec1, i, elemento);
posicionInicial = posicionFinal; //Empieza la nueva búsqueda en
donde terminó de extraer
}
//System.out.println("Fila " + ec1.toString());
fSalida.write(ec1.formatoCSV() + "\n"); //graba en el fichero plano
fSalida.flush();
objBinario.writeObject(ec1); //graba en el fichero binario

if (posicionInicial == -1) {
break;
}
}
} finally {
fSalida.close();
try {
objBinario.close();
}
}
}

}
FIN DE LA VERSION DE LA PROFESORA
VERSION DE LA MARIA ELENA
public class Tabla implements Serializable {
private String fecha;

private String inMuertos ;
private String muertos;
private String muertosMillon;
private String inConfirmados;
private String confirmados;
private String conf14Dias;
public Tabla() {

}

@Override
return fecha
+ "," + inMuertos + "," + muertos
+ "," + muertosMillon + "," + inConfirmados
+ "," + confirmados + "," + conf14Dias + "\n";
}
public String getFecha() {

return fecha;
}
public void setFecha(String fecha) {
this.fecha = fecha;
}
public String getInMuertos() {

return inMuertos;
}
public void setInMuertos(String inMuertos) {

this.inMuertos = inMuertos;
}
public String getMuertos() {

return muertos;
}
public void setMuertos(String muertos) {

}
public String getMuertosMillon() {

return muertosMillon;
}
public void setMuertosMillon(String muertosMillon) {

}
public String getInConfirmados() {

return inConfirmados;
}
public void setInConfirmados(String inConfirmados) {

this.inConfirmados = inConfirmados;
}
public String getConfirmados() {

return confirmados;
}
public void setConfirmados(String confirmados) {

}
public String getConf14Dias() {

return conf14Dias;
}
public void setConf14Dias(String conf14Dias) {

this.conf14Dias = conf14Dias;
}

}
MAIN
public class Main {
/**
*/
//URL
URL u1;
BufferedReader b1;
//clase
Tabla t1 = new Tabla();
//ficheros
FileWriter fSal;
FileOutputStream fSalBin;
ObjectOutputStream objeto;
//variables
String cad = "";
String[] cadenas;
String scad = "";
String[] dato;
String[] subdato;
int cont = 0;
try {
u1 = new
URL("https://datosmacro.expansion.com/otros/coronavirus/espana");
b1 = new BufferedReader(new InputStreamReader(u1.openStream()));
while ((cad = b1.readLine()) != null) {

scad += cad;
}
cadenas = scad.split("data-value=");
fSal = new FileWriter("tabla.txt", false);

fSalBin = new FileOutputStream("tabla.dat", false);
objeto = new ObjectOutputStream(fSalBin);
//Recogemos excluyendo el primer elemento del array

// El formato que tenemos es:
//"2021-05-20">20/05/2021</td><td class="numero"
//lo partimos para quedarnos con el dato formateado (20/05/2021)
for (int i = 1; i < cadenas.length; i++) {
cont++;
dato = cadenas[i].split(">");

subdato = dato[1].split("<");
//Grabamos en la clase tabla dependiendo del cont
switch (cont) {
case 1:
t1.setFecha(subdato[0]);
break;
case 2:
t1.setInMuertos(subdato[0]);
break;
case 3:
t1.setMuertos(subdato[0]);
break;
case 4:
t1.setMuertosMillon(subdato[0]);
break;
case 5:
t1.setInConfirmados(subdato[0]);
break;
case 6:
t1.setConfirmados(subdato[0]);
break;
case 7:
t1.setConf14Dias(subdato[0]);
//inicializanos contador para que grabe otro obj

cont = 0;
//escribimos en los ficheros

fSal.write(t1.toString());
objeto.writeUnshared(t1);
break;
}
}
//cerramos
b1.close();
fSal.close();
fSalBin.close();
} catch (MalformedURLException ex) {

}
}
}
FIN DE LA DE VERSION DE LA MARIA ELENA
VERSION DE CARLOS MARTIN FERNANDEZ
FIN VERSION DE CARLOS MARTIN FERNANDEZ
LEER UN FICHERO PLANO

// Declaración de variables
BufferedReader buf ;
String linea;
try {
buf = new BufferedReader(new FileReader("EstadisticaCovid.txt"));
while ((linea= buf.readLine())!=null) {
System.out.println("linea ->" + linea);
}
}

}
FIN DE LEER UN FICHERO PLANO
LECTURA DE FICHERO BINARIO GRABADO CON OBJECTOUTPUTSTREAM

// Declaración de variables
ObjectInputStream objEntrada;
FileInputStream fEntrada;
try {
fEntrada = new FileInputStream("EstadisticaCovid.dat");
objEntrada = new ObjectInputStream(fEntrada);
System.out.println("objeto entrada " + objEntrada.available());
while (fEntrada.available()> 0) {
System.out.println("El objeto que se lee es -->" +
((EstadisticaCovid) objEntrada.readObject()).toString());
}
} catch (IOException | ClassNotFoundException ex) {
}
}
FIN DE LECTURA DE FICHERO BINARIO GRABADO CON

OBJECTOUTPUTSTREAM
CIFRADO DE UN FICHERO
// Declarar las variables
FileInputStream fe = null;
Random r = new Random();
FileOutputStream fs = null;
byte[] texto = new byte[128];
byte[] textocifrado = new byte[128];
int aleatorio, leidos = 0;
try {
System.out.println("El numero aleatorio es " +(aleatorio=
r.nextInt(101)));
fe = new FileInputStream("bitacora.txt");
fs = new FileOutputStream("cifrado.txt");
leidos = fe.read(texto);
while (leidos!=-1) {
for (int i = 0; i < texto.length; i++) {
textocifrado[i] = (byte) (texto[i] ^ aleatorio);
}
fs.write(textocifrado, 0, leidos);

}
}finally{
try {
fe.close();
fs.close();
}
}
}
}
FIN DE CIFRADO DE UN FICHERO
DESCIFRADO DE UN FICHERO

// Declarar las variables
FileInputStream fe = null;
byte[] texto = new byte[128];
byte[] textocifrado = new byte[128];
int aleatorio, leidos = 0;
try {
System.out.println("Escriba la clave --> ");
aleatorio = s1.nextInt();
fe = new FileInputStream("cifrado.txt");

while (leidos!=-1) {
for (int i = 0; i < texto.length; i++) {
textocifrado[i] = (byte) (texto[i] ^ aleatorio);
System.out.print((char) textocifrado[i]);
}
}
}finally{
try {
fe.close();

}
}
}
}
FIN DE DESCIFRADO DE UN FICHERO

Ejercicios de Clase

Cargado por

Información del documento

Título 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

Ejercicios de Clase

Cargado por

Copyright:

Formatos disponibles

ArraysNot1.

Calcular el factorial de 25 con un bucle while

public static void main(String[] args) {

//3. Evaluar la condición

public static void main(String[] args) {

public static void main(String[] args) {

for(int i = 0; i<caracteres.length; i++){

for (int i = 0; i < enteros.length; i++) {

if (enteros[i] % 3 == 0){

Método arraycopy de System

public static void main(String[] args) {

int[] array3 = new int[array1.length + array2.length];

int posicionArray3 = 0;

for(int i = 0; i< array1.length; i++){

for(int i = 0; i< array2.length; i++){

System.out.println("El resultado es " + Arrays.toString(array3));

public static void main(String[] args) {

char[] result = new char[cars1.length + cars2.length];

int posicionArray1 = 0;

while (posicionArray3 < result.length) {

if (posicionArray2 < cars2.length) {

for (char letra : letras) {

for (float numero : decimales) {

System.out.println("La suma de todos los elementos del array es " +

int[] numeros = new int[]{1,2,7,3,4,65,23,78,98,34,342,45,57};

int[][] numMatriz = new int[2][3];

int[][] matriz1 = {{1, 2}, {0, 5}};

int[][] resultado = new int[2][2];

for (int fila= 0; fila<matriz1.length; fila++){

for (int [] fila : resultado){

Dado la siguiente matriz, crear un bloque de código que me pinte sus

for (int[] fnumero : numeros) {

Ejemplo de matriz NO cuadrada

// Ejemplo de matriz NO cuadrada

// Clase LocalDate

public long calcularEdad(){

//Instanciar un objeto del tipo empleado

System.out.println("Calcular nómina -> " + e1.calcularNomina());

public class Saludo {

public class ProbarSaludo {

public class Areas {

public double areaCirculo(double radio) {

public double areaRectangulo(double base, double altura) {

public static void main(String[] args) {

public class Producto {

public class Campos {

public String muestra() {

public void incrementa() {

public Campos() {

public Campos(int x) {

public class ProbarCampos {

public static void main(String[] args) {

public class Coche {

private String color;

Coche c1 = new Coche();

public class ProbarFecha {

public class Animal {

public class Empleado {

public class Producto {

public class Dado {

public Dado() {

public String dibujaUno() {

public String dibujaDos() {