codificación java-netbeans8
-
Upload
danixa-marjhorie-avila-chuctaya -
Category
Documents
-
view
70 -
download
10
description
Transcript of codificación java-netbeans8
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));