TALLER DE PROGRAMACIÓN DISTRIBUIDA

AA02

Programación Básica y Programación Orientada a Objetos

Programación de Métodos

La programación de métodos consiste en pasar o transcribir

un algoritmo de programación (que responda a las

necesidades/requerimientos del usuario) a un código en un

lenguaje de programación orientado a objetos.

En nuestro caso, escribiremos métodos utilizando el

Lenguaje de Programación Java trabajando con el IDE

(Entorno de Desarrollo Integrado ) NetBeans.

HERRAMIENTAS DE PROGRAMACIÓN

Lenguaje: Java / IDE: NetBeans

Se debe tener en cuenta seleccionar el OBJETO y EVENTO

adecuados para programar el comportamiento (método) que

deberá tener el objeto.

NOTA: No olvidar que la P.O.O. es una Programación Basada en EVENTOS

(es decir, Programación Guiada por Eventos).

CONTROLES JAVA

JFrame

jLabel

jTextField

jButton

jPanel

jRadioButton

jButtonGroup

jComboBox

jFormattedTextField

jSpinner

jCheckBox

Renombrar los nombres por defecto de los objetos: Por ejemplo: jTextField1 TextNombres

ESTRUCTURAS DE CONTROL DE FLUJO DE PROGRAMAS

Estructura de Selección Múltiple

En Lenguaje Java esta estructura se representa con la instrucción: SWITCH CASE

Sintaxis:

switch <variable> { case <opción 1>: <conj. instr. 1>; break; case <opción 2>: <conj. instr. 2>; break; case <opción 3>: <conj. instr. 3>; break; case <opción N>: <conj. instr. N>; break; default: <conj. instr. N>; }

Aplicación Java: Ejemplo07

Control: jComboBox Ejemplo:

private void ComboNacionalidadActionPerformed(java.awt.event.ActionEvent evt) { // TODO add your handling code here: //Leer el texto que se seleccionó en el ComboBox y pasarlo a un String String Nacionalidad = (String) ComboNacionalidad.getSelectedItem(); //Evaluando Nacionalidad switch(Nacionalidad) { case "Peruana": case "Colombiana": case "Argentina": descuento = (float) 20.00; break; case "Española":

case "Francesa": descuento = (float) 25.00; break; case "Japonesa": descuento = (float) 30.00; break; default: descuento = (float) 0.00; } TextDescuento.setValue(descuento); }

Control: jFormattedTextField

Explicación: Máscara de Formato: # y 0 25 ##.## 25 ##.00 25 25.5 ##.## 25.5 ##.00 25.50 ##.#0 25.50 Métodos de jFormattedTextField: jTextField1.getText(); jFormattedTextField1.getValue(); Cuando el formato es numérico

jTextField1.setText(); jFormattedTextField1.setValue(); Cuando el formato es numérico

Control: jSpinner (Control Numérico)

Propiedad para configurar el objeto SpinEdad (JSpinner):

Clic para seleccionar

Cambiar los valores (Inicial, Mínimo, Máximo e Incremento) de acuerdo a los requerimientos, para nuestro caso:

Control: jCheckBox (Casilla de Verificación) Objeto booleano cuya función es seleccionar y deseleccionar opciones dentro de una aplicación. En otros lenguajes, puede ser conocido simplemente como CheckBox. De manera coloquial, también puede llegar a ser conocido como casilla de verificación.

Inicializando objetos en el formulario:

Activar el foco a otro objeto cuando se presiona ENTER: En el ejemplo para pasar de la caja Nombres a la caja Apellidos

Cerrar un formulario o ventana:

MANEJO DE FECHAS EN JAVA

_________________________________________________ A partir de la introducción de la versión Java 8, el manejo de las fechas y el tiempo ha

cambiado en Java. Desde esta versión, se ha creado una nueva API para el manejo de fechas

y tiempo en el paquete java.time, que resuelve distintos problemas que se presentaban

con el manejo de fechas y tiempo en versiones anteriores. Sin embargo, nos podemos

encontrar con la necesidad de tener que trabajar con código que usa versiones anteriores o

que sigue usando la clase Date del paquete java.util.

Clase Date (Paquete java.util)

La clase Date fue de las primeras en este paquete y como tal ha ido sufriendo cambios.

Bastantes métodos están “deprecados”. Un método deprecado (deprecated) es un método

“obsoleto” de uso no recomendado. Estos métodos han sufrido mejoras o cambios que se

reflejan en otros métodos o clases de uso recomendado en lugar del deprecated. Por

compatibilidad se permite el uso de estos métodos, aunque se recomienda su sustitución

por otros. El motivo por los que muchos de los métodos de esta clase son deprecated es

sobre todo por temas de internacionalización en el formato de fechas que no se tuvieron

en cuenta en las primeras versiones de Java. A pesar de todo, esta clase permite la

interpretación de fechas como año, mes, día, hora, minutos y segundos y continúa siendo

bastante usada entre la comunidad de programadores.

Algunas consideraciones que debemos tener en cuenta cuando usemos esta clase es que en

todos los métodos que acepten o devuelvan años, meses, días, horas, minutos y segundos

se trabaja de esta manera:

- Un año “y” se representa por el entero y – 1900. Por ejemplo el año 1982 se representaría

por el entero 1982 – 1900 = 82. De este modo, 82 representa 1982 y 92 representa 1992.

- Los meses son representados desde 0 hasta 11, así Enero es 0 y Diciembre es 11.

- Los días son normalmente representados desde 1 al 31.

- Las horas desde 0 a 23.

- Los minutos van desde 0 a 59.

- Los segundos normalmente van desde 0 hasta 59. (Excepcionalmente pueden existir los

segundos 60 y 61 para los años bisiestos).

Ejemplo 01

En el ejemplo que vamos a dar a continuación veremos cómo se puede usar la clase Date

para representar una fecha determinada. Aprovechando que implementa la interfaz

Comparable<Date>, compararemos 2 fechas para saber cuál va antes o después:

// Ejemplo Clase Date

import java.util.Date;

public class Programa {

public static void main (String []args) {

Date fecha1, fecha2;

fecha1 = new Date(82,4,1,10,30,15);

fecha2 = new Date(112,7,7,18,25,12);

System.out.println("Fecha 1 Local: "+fecha1.toLocaleString());

System.out.println("Fecha 2 Local: "+fecha2.toLocaleString());

System.out.println("Fecha 1 en GMT: "+fecha1.toGMTString());

System.out.println("Fecha 2 en GMT: "+fecha2.toGMTString());

System.out.println("Fecha 1: "+fecha1.toString());

System.out.println("Fecha 2: "+fecha2.toString());

System.out.println("¿Es la fecha 1 posterior a la fecha 2?: "+fecha1.after(fecha2));

}

}

El constructor que hemos utilizado es uno de los disponibles, en concreto Date (int year,

int month, int day, int hrs, int min, int sec) donde el primer número representa el año, el

segundo el mes, el tercero el día, el cuarto las horas, el quinto los minutos y el sexto los

segundos.

Al compilar nuestro Programa en BlueJ (otro IDE para Java) nos saldrá probablemente un

mensaje alertando del uso de métodos deprecados como ya hemos comentado

anteriormente:

Igual sucede si compilamos en NetBeans, nos indica el uso de métodos deprecados

tachando las clases y sus métodos, como se observa en la siguiente imagen:

El resultado de ejecución del programa, en NetBeans y en BlueJ respectivamente, nos

devuelve la siguiente salida:

Como podemos observar en la salida, imprimimos las fechas en varios formatos tanto la

fecha 1, como la fecha 2. El primero es el formato local donde se representa en este caso

las fechas con el formato del país donde nos encontremos. Esto se debe a que en tiempo de

ejecución se recupera el formato de fecha correspondiente al ordenador donde se esté

ejecutando la aplicación mediante una propiedad de la máquina virtual de java. Si estamos

en España, recuperaremos la hora de España y si estamos en México la de México, en Chile

la de Chile, etc.

En algunos casos nos interesa crear una fecha partiendo de un String, para ello podemos

utilizar el constructor utilizando la cadena String, pero si la fecha introducida en este caso

no sigue el formato local deberemos de utilizar la clase DateFormat para “parsear”

(transformar) el String y poder crear la fecha Date correspondiente.

El segundo par de formatos es el formato GMT donde podemos observar que se muestra con

2 horas menos en la salida con BlueJ (diferencia entre la hora local de España que es donde

se hizo el programa y la hora GMT) y 5 horas más en NetBeans (diferencia entre la hora local

de Perú que es donde se hizo este programa y la hora GMT). Mientras que el formato tercero

es el que por defecto muestra Date.

Por último observamos cómo podemos comparar dos fechas, utilizando los métodos before

o after (en este caso) además podríamos haber utilizado por supuesto el método

compareTo.

Ejemplo 02

Un ejercicio interesante puede ser el calcular la diferencia en días entre dos fechas dadas,

así vamos a realizar este ejercicio:

Las fechas creadas las interpretamos así:

(112, 7, 1, 10, 30, 15): (año, mes, día, hora, minutos, segundos): año 1900+112 = 2012,

mes 7 que es agosto (recuerda: el mes cero es enero), día 1, hora 10, minutos 30, segundos

15.

Por tanto la primera fecha es el 1 de agosto de 2012 a las 10 horas 30 minutos 15

segundos.

(112, 7, 7, 18, 25, 12): de la misma forma llegamos a la conclusión de que la fecha

representada es el 7 de agosto de 2012 a las 18 horas 25 minutos 12 segundos.

Entre el 1 de agosto y el 7 de agosto hay 6 días (7-1 = 6).

El método getTime() aplicado sobre un objeto object devuelve un entero largo (long) que

representa el número de milisegundos desde el 1 de enero de 1970 a las 0 horas GMT (este

es un valor de referencia que utiliza Java, podría haber sido otra fecha, pero los

desarrolladores de Java eligieron esta). Para pasar de milisegundos a segundos hemos de

dividir por 1000 y para pasar de segundos a días hemos de dividir por 24 horas * (3600

segundos/hora). Resulta una operación: numero / ( 3600000 *24) de forma que el valor de

milisegundos numero queda transformado en días.

En resumen lo que hacemos es obtener la diferencia en milisegundos entre las dos fechas y

transformarlo a días. El resultado lo almacenamos en un tipo long (entero largo) de forma

que si lleva decimales los decimales quedan truncados.

Nota: No todos los métodos de la clase Date están deprecados pero sí bastantes de ellos,

por eso se recomienda utilizar para versiones de Java previas a la 8 la

clase DateFormat para formatear y ”parsear” cadenas String a fechas y usar la

clase Calendar para conversiones de fechas y sus campos. Para versiones Java a partir de

la 8 se recomienda usar las clases del paquete java.time.

Paquete java.time

Java.time es un nuevo paquete que existe en Java 8.Este paquete es una extensión a las clases java.util.Date y java.util. Calendar que vemos un poco limitado para manejo de fechas, horas y localización. Las clases definidas en este paquete representan los principales conceptos de fecha - hora, incluyendo instantes, fechas, horas, periodos, zonas de tiempo, etc. Están basados en el sistema de calendario ISO, el cual el calendario mundial de-facto que sigue las reglas del calendario Gregoriano.

Cada instancia de fecha y hora se compone de campos. Para el acceso de nivel inferior a los campos consulte el paquete java.time.temporal. Cada clase incluye soporte para la visualización y análisis de todo tipo de fechas y horas. Consulte el paquete java.time.format para opciones de personalización.

El paquete java.time.chrono contiene el API para calendario localizado (neutral): ChronoLocalDate, ChronoLocalDateTime, ChronoZonedDateTime y Era. Esto es para uso de aplicaciones que necesitan utilizar calendarios localizados. Se recomienda que las aplicaciones utilicen la norma ISO-8601 de las clases de fecha y hora de este paquete a través de los límites del sistema, como a la base de datos o en toda la red. La API neutral calendario debe reservarse para la interacción con los usuarios.

Fechas y horas

Instant: es esencialmente una marca de tiempo numérico. La instantánea actual puede ser recuperada de un Clock Esto es útil para la tala y la persistencia de un punto en el tiempo y en el pasado ha sido asociado con almacenar el resultado de System.currentTimeMillis()

LocalDate: almacena una fecha sin hora. Esto almacena una fecha como '2010-12-03' y podría ser utilizado para almacenar un cumpleaños.

LocalTime: almacena un tiempo sin una fecha. Esto almacena un momento como '11: 30 'y podría ser utilizado para almacenar una abertura o cierre.

LocalDateTime: almacena una fecha y hora. Este almacena una fecha-hora como "2010-12-03T11: 30 '.

ZonedDateTime: almacena una fecha y hora con un huso horario. Esto es útil si desea realizar cálculos precisos de fechas y horas, teniendo en cuenta la ZoneId como "Europa / París". Donde sea posible, se recomienda utilizar una clase más simple sin un huso horario. El uso generalizado de zonas horarias tiende a añadir una considerable complejidad a una aplicación.

Duración y Período

Más allá de las fechas y horas, la API también permite el almacenamiento de los períodos y duraciones de tiempo. Un Duration es una simple medida de tiempo a lo largo de la línea de tiempo en nanosegundos. Un Period expresa una cantidad de tiempo en unidades significativas para los seres humanos, como años o días.

Tipos de valor adicionales

Month: Almacena un solo mes de año en forma aislada, como 'diciembre'.

DayOfWeek: lmacena un solo día de la semana en forma aislada, como 'Martes'.

Year: Almacena un solo año en forma aislada, como '2010'.

YearMonth: Almacena un año y mes, tales como '2010-12' y podría ser utilizado para una caducidad de la tarjeta de crédito.

MonthDay: Almacena un mes y días de mes, como '12-03' y podría ser utilizado para almacenar un evento anual, como un cumpleaños sin almacenar el año.

OffsetTime: Almacena un tiempo y desplazamiento desde UTC sin fecha. Esto almacena una fecha como '11: 30 + 01: 00 '. El ZoneOffset es de la forma '01: 00'.

OffsetDateTime: Almacena una fecha y hora y el desplazamiento de UTC. Esto almacena una fecha-hora como "2010-12-03T11: 30 + 01: 00 '. Esto a veces se encuentra en los mensajes XML y otras formas de persistencia, pero contiene menos información que un huso horario completo.

Ejemplos:

Clases de fecha

Las clases de fecha como el java.time.LocalDate manejan la fecha, pero, a diferencia del java.util.Date, es que es solo trabaja fecha, y no hora. Esto nos permitirá manipular la fecha para registrar fechas específicas como el día de cumpleaños o de matrimonio. Aquí unos ejemplos: LocalDate date = LocalDate.of(1999, Month.AUGUST, 23);

DayOfWeek dia=date.getDayOfWeek();

System.out.printf("El día que conocí a quien es mi esposa fue el %s y fue

un %s%n",date,dia);

Para representar el mes de un año específico, usamos la clase java.time.YearMonth y también podemos obtener la cantidad de días de ese mes, sobre todo cuando jugamos con los bisiestos: YearMonth mes = YearMonth.now();

System.out.printf("Este mes es %s y tiene %d días%n", mes,

mes.lengthOfMonth());

mes = YearMonth.of(2004, Month.FEBRUARY);

System.out.printf("El mes %s tuvo %d días,%n", mes, mes.lengthOfMonth());

mes = YearMonth.of(2002, Month.FEBRUARY);

System.out.printf("el mes %s tuvo %d días,%n", mes, mes.lengthOfMonth());

mes = YearMonth.of(2000, Month.FEBRUARY);

System.out.printf("el mes %s tuvo %d días%n", mes, mes.lengthOfMonth());

mes = YearMonth.of(1800, Month.FEBRUARY);

System.out.printf("Pero el mes %s tuvo %d días ¿Sabías que no es

considerado bisiesto?%n", mes, mes.lengthOfMonth());

La clase java.time.MonthDay representa a un día de un mes en particular, tal como decir que el año nuevo es el 1 de enero:

MonthDay dia=MonthDay.of(Month.FEBRUARY, 29);

System.out.printf("El día %s %s es válido para el año 2010%n",dia,

dia.isValidYear(2010)?"":"no");

//la respuesta será NO

Y la clase java.util.Year nos permite manipular y conocer sobre un año en específico, sin importar el día o mes:

Year año = Year.now();

System.out.printf("Este año es %s y %s es bisiesto%n", año, año.isLeap() ?

"sí" : "no");

Clase de Hora La clase java.time.LocalTime es similar a las otras cosas que comienza con el prefijo Local, pero se centra únicamente en la hora. Esta clase es muy útil para representar horas y tiempos de un día, tales como la hora de inicio de una película o el horario de atención de una biblioteca. Se centra únicamente en la hora de un día cualquiera, pero no en una fecha específica ¿Se entiende? Con el java.util.Date solo podemos manipular la hora de un día de un año en especial, de una zona de horario en especial, pero con el LocalTime solo nos centramos en la hora en sí, sin importar que día sea. Normalmente lo manipularíamos con una cadena y de ahí hacemos raros algoritmos para saber si esa cadena está dentro de la hora actual. Aquí un pequeño ejemplo de su uso:

LocalTime justoAhora = LocalTime.now();

System.out.printf("En este momento son las %d horas con %d minutos y %d

segundos\n",justoAhora.getHour(),justoAhora.getMinute(),

justoAhora.getSecond());

Como se puede ver, no tiene nada que ver la fecha, solo se manipuló la hora.

Clase de hora/fecha La clase java.time.LocalDateTime manipula la fecha y la hora sin importar la zona horaria. Esta clase es usada para representar la fecha (año, mes, día) junto con la hora (hora,

minuto, segundo, nanosegundo) y es - en efecto - la combinación de LocalDate y LocalTime. Esta clase puede ser usada para especificar un evento, tal como la final de Champions League 2014 en la hora local del evento. Además del método now() que viene en cada clase vista hasta ahora, la clase LocalDateTime tiene varios métodos of (o métodos con prefijo of) que crean una instancia de LocalDateTime. También hay un método from que convierte una instancia de otro formato de tiempo a la instancia LocalDateTime. También hay métodos para agregar y quitar horas, minutos, días, semanas y meses. Aquí muestro algunos ejemplos:

LocalDateTime ahora = LocalDateTime.now();

System.out.printf("La hora es: %s%n", ahora);

LocalDateTime algunDia = LocalDateTime.of(1976, Month.MARCH, 27, 6, 10);

System.out.printf("Yo nací el %s%n", algunDia);

System.out.printf("Hace seis meses fue %s%n",

LocalDateTime.now().minusMonths(6));