Carátula para entrega de prácticas

Facultad de Ingeniería Laboratorios de docencia

Laboratorio de Computación
Salas A y B
Tista García Edgar M.I.
Profesor:

Asignatura: Programación Orientada a Objetos

Grupo: 3

No de Práctica(s): 3

Integrante(s): Barrera Peña Víctor Miguel

No. de Equipo de 21
cómputo empleado:

Semestre: 2019-2

Fecha de entrega: 25/02/2019

Observaciones:

CALIFICACIÓN: ________________
 Contenido
Objetivo: ................................................................................................................. 3

Introducción: ........................................................................................................... 3

Desarrollo: .............................................................................................................. 3

Primera parte: Arreglos Ejercicio 1.- Simulando una pila..................................... 4

Solución: ............................................................................................................. 4

Observaciones: ................................................................................................... 5

Evidencias de implementación ............................................................................ 5

Ejercicio 2. Arreglos irregulares .......................................................................... 6

Solución: ............................................................................................................. 6

Observaciones: ................................................................................................... 6

Evidencias de implementación ............................................................................ 7

Segunda Parte: Clases envolventes ................................................................... 7

Ejercicio 3. .......................................................................................................... 8

Evidencias de implementación: ........................................................................... 8

Observaciones: ................................................................................................... 8

Tercera parte: Fechas en java ............................................................................ 9

Para verificar el funcionamiento de fechas en java realiza las siguientes

actividades: .................................................................................................................... 9

Ejercicio 4.- Elabora una clase para el manejo de fechas que tenga los siguientes
métodos ......................................................................................................................... 9

Observaciones: ................................................................................................... 9

Conclusión ........................................................................................................... 11

Bibliografía ........................................................................................................... 12

2
 Objetivo: Utilizar bibliotecas propias del lenguaje para realizar algunas
tareas comunes y recurrentes.

Introducción:

Un lenguaje se cree que es poderoso, cuando las posibilidades de emplear

sus utilidades son mayores, para lograr ello en Java es necesario aprender
como emplear la biblioteca que contienen miles de funciones ya hechas por
desarrolladores.

Pero ¿Por qué tenemos que usar algo ya hecho, no ese es el sentido de la
programación? Si y no, hacer nuevas funcionalidades es la esencia de la
programación, pero no vas a escribir bit por bit el código, entonces porque no
usas herramientas que te ayudaran a crear herramientas aun mas
poderosas.

Esta práctica esta contemplada para comprender las bases del manejo de la
biblioteca y con ello lo que implica. Siendo los métodos , estructuras que
estos proveen, las herramientas que se han de utilizar para la realización de
los programas de esta práctica y las subsecuentes.

Desarrollo:
Ejercicios previos (análisis de diferencia entre la práctica suministrada
por la división contra la teoría instruida por el profesor):

Teórica (clase) Práctica (La división)

Arreglos Si Si
Manejo de cadenas Si Si
Uso clases Si Si
Uso de listas Si Si
Manejo de cadenas Si Si
Wrappers Si Si
Autoboxing Si Si
Colecciones Si Si

3
 Hashtable No Si
Biblioteca Math No Si

Ejercicios propuestos por el profesor:

Primera parte: Arreglos Ejercicio 1.- Simulando una pila

A. Crea una clase para simular una pila, que tendrá como atributos un valor entero
para indicar el tope de la pila y un arreglo que va a funcionar como la lista asociada
a la pila, y como métodos las funciones push, pop, isEmpty y top para una pila.
Recuerda que una pila solo se puede ingresar elementos mientras haya espacio
en ella y al extraer algún elemento deberá ser el último que ingresó Crea una
segunda clase para probar las funciones de la pila de la siguiente manera.
B. Crea una primera pila donde el usuario ingresará los valores deseados (10)
C. Mediante dos pilas adicionales, y utilizando solo los métodos de la pila, encuentra
el valor más grande ingresado por el usuario

Solución:
La implementación que encontré fue crear una clase Pila que en secuencia contiene
todos los métodos necesarios para que funcione. Use Private en las variables propias de
la pila , para que desde otra clase no pudieran ser modificadas y mantener la integridad de
la estructura.

Designe que la pila tuviera un constructor que solo fuera pasado como parámetro el
tamaño de la pila, podría haber dejado que el tamaño de ella fuera variable de acuerdo a
los elementos que se le fueran agregados, pero para efectos prácticos, con designar una
cantidad especifica el usuario es suficiente.

Todos los métodos que se implementan en esta clase son de acceso público , para
poder ser utilizada la pila.

Para esta implementación designe tres pilas de tamaño fijo, para no ofuscar más el
código. No se uso una función externa, proveniente de la biblioteca.

4
 Observaciones:
No existió alguna complicación, lo único que falto en este programa es el uso de
excepciones, siendo para isEmpty() y IsFull() muy necesarias, además de para pop()
donde no es posible indicarle que ya esta vacía a la clase principal.

Otra observación es la adición del método isFull() que no esta contemplado en la

práctica , pero es de gran utilidad para saber si todavía puedo añadir datos a la pila.

Evidencias de implementación

Ilustración 2 Ejecución Programa 1 parte 2

Ilustración 1 Ejecución Programa 1 parte 1

5
 Ejercicio 2. Arreglos irregulares
A. Escribe una clase que permita la creación de arreglos irregulares
B. En dicha clase deberá haber un método para crear el arreglo irregular, solicitando
al usuario la cantidad de renglones y la cantidad de columnas por renglón
C. También habrá un método para imprimir el arreglo, dicho método deberá ser
genérico y funcionar para cualquier tamaño de arreglo irregular

Solución:
El texto del ejercicio decía claramente que se tenia que implementar un método para
la creación de arreglos irregulares y de la cual su citan 2 razones a consideración:

1) Hacer el método que menciona en el cuerpo principal al no especificar en que

clase se desea hacerlo.
2) Hacerlo en el cuerpo principal, porque este es el único funcionamiento del
programa, y como es pedir datos al usuario, lo más lógico es implementarlo
como tema principal del programa.

Yo opte por la segunda opción, para poder esta jugando con los arreglos irregulares
y probar su funcionalidad, y creo que ese es el objetivo de cada programa , podría
haber usado la consideración 1 para crear un clase , que se llamara
Arreglo_irregular pero no es necesario, solo habría de mover el constructor y usar
la declaración que se muestra en la ilustración 3, y a través de usar this asignarle
los renglones por columna. Si hay alguna penalización por mi objeción de no usar la
consideración 1, aquí queda justificada mi razón de usar la razón 1.

Ilustración 3 Código del cuerpo del programa 2 en la clase principal.

Observaciones:
Al jugar con el código de esta práctica me he percatado que es posible hacer
arreglos de mayores dimensiones que N=2 , además de poder crear arreglos, asignarle
valores y posteriormente darle esos arreglos llenos al arreglo irregular, si lo vemos con
isomorfismo de objetos, este arreglo irregular es un arreglo de arreglos “Especial”.

6
 Evidencias de implementación

Ilustración 4 Ejecución del programa 2 versión 1

Segunda Parte: Clases envolventes

Todas las clases envolventes cuentan con dos maneras de crear objetos:
La primera es tomar el tipo primitivo asociado al objeto que se esta construyendo
Integer enterol = new Integer(43); (1)
Float flotantel = new Float (24.32); (2)
La segunda es tomar una cadena (String) y convertirla en el objeto necesario
Integer entero2 = new Integer("1234"); (3)
Float flotante2 = new Float ("12.664") ; (4)
Cuando se necesita convertir un valor de una clase envolvente a un tipo primitivo, se puede usar alguno
de los métodos ***Value. Estos métodos no necesitan argumentos.
Integer envolvente = new Integer(83); ................................................ (5)
byte b = envolvente .byteValue () ; .................. (6)
short s = envolvente.shortValue() ; .................. (7)
double d = envolvente.doubleValue(); .................. (8)
Float envolvente2 = new Float (10.32) ; .................. (9)
short s = envolvente2. shortValue () ; .................. (10)
System.out.println(s) ......... . ....... (11)
Los métodos parse*** están relacionados con el método ValueOf, ya que toman una cadena (String) como
argumento. Los primeros devuelven un primitivo y ValueOf devuelve un objeto(clase envolvente)

int otro = Integer.parseInt (" 10") ; //parseInt devuelve un entero ..(12)

double d3= Double.parseDouble (50,25) //parseDouble devuelve un doble ..(13)

7
 Integer wrap = Integer.ValueOf("1100"); ..... (14)

Double wrap2= Double.ValueOf("3.141519"); ..... (15)

Ejercicio 3.
En una nueva clase agrega las 15 líneas indicadas previamente y realiza en el reporte
los comentarios de lo que te parezca relevante, si lo deseas puedes modificar el código
para conocer más a detalle el funcionamiento de las clases envolventes.

Evidencias de implementación:

Ilustración 5 Ejecución programa 3 versión 1 (error)

Ilustración 6 Ejecución programa 3 versión 2

Ilustración 7 Ejecución programa 3 versión 3

Ilustración 8 Ejecución programa 3 versión 4

Observaciones:
• Tomando como referencia la ilustración 5 podemos apreciar que existen 2 errores
dados las siguientes circunstancias:

8
 o El primero “ 10” es porque existe un espacio en la función, y el valor queda
afuera de su rango
o En la Ilustración 6 se ejecuta el programa comentando las líneas que dan
positivo al error, lo que da como resultado la impresión en pantalla del
numero “83”
o En la Ilustración 6 se aprecia como al quitar el comentario de su línea
aparece un error que esta asociado a la variable S ya que anteriormente esta
declarada, lo único que hice fu cambiarle el nombre por Si, imprimiendo esta
variable como 10 en pantalla.
• En este programa es posible observar los errores más comunes de transformación
dados por un espacio, un tipo incompatible, además de la posibilidad de no solo
transformar una cadena a base 10 , sino que es posible a otras bases (2,8,16)

Tercera parte: Fechas en java

Para verificar el funcionamiento de fechas en java realiza las
siguientes actividades:
Ejercicio 4.- Elabora una clase para el manejo de fechas que tenga los
siguientes métodos
A. Método que calcule la diferencia en días entre dos fechas ingresadas como
cadenas con el formato dd/mm/yy.
B. Método que dada una fecha en formato dd/mm/yy, calcule la fecha 50 días posterior
C. Método que devuelva el "epochTime" calculado hasta la fecha que ingrese el
usuario *Agrega en tu reporte una descripción de qué es el "epochTime"

Observaciones:
“El tiempo Epoch es la hora actual medida en número de segundos desde el Epoch Unix.
Epoch 0 es enero 1 1970 00:00:00 GMT (ISO 8601: 1970-01-01T00:00:00Z). No se usan
segundos bisiestos en el tiempo Unix”. (Misja, 28)

Para resolver este problema se modelo, una clase que contiene los 3 métodos , 2
constructores que consiste en que se puede crear un objeto Fecha pasando como
parámetro una cadena como se muestra en la ilustración 10 donde se creean 2 objetos ,
pasando como parámetro la fecha inscrita en texto.

9
Para la creación de los objetos, mee tome la libertada de cambiar el formato de creación de
fechas. El formato indicado era : dd//mm//yy, pero yo lo cambie con el formato dd//mm//yy
por razón de que se quisiera ingresar por ejemplo 2070, epoch mostraría que las diferencia
sería de menos de 1 año cuando no es así. Por lo anterior dicho me tome la libertad de
modificar un poco el escrito.

En la ilustración 3 se muestra en primer lugar la diferencia entre fechas, después la fecha1

si se le sumará 50 días, por ultimo se muestra la fecha en epoch time , todas las operaciones
de este último método están realizados en el return.

El programa no tiene la precisión total , como sería los días con 31 días y el de 28, pero yo
creo que este ejercicio es para que podamos demostrar el uso de conversiones de tipos y
su manejo, y en este caso ya usando una clase, si lo vemos en el sentido más estricto, sería
usar la bibliotecas de Java.

La diferencia entre la ilustración 9 y la ilustración 10, es que en la primera no se había

incluido la función de calcular epoch time.

Una posible modificación futura es la inclusión de excepciones, para el caso de que el que
use el programa no tenga permitido la introducción de fechas negativas, y posiblemente
crear colecciones para tener más precisión entre fechas.

Ilustración 9 Ejecución del programa 4 versión 1

Ilustración 10 Sección de código que muestra la creación de dos objetos Fecha

Ilustración 11 Ejecución del programa 4 versión 2

10
 Conclusión
Ya teniendo más tiempo para realizar la práctica, más descansado las ideas
fluyen sin necesidad de forzar la obtención del resultado “correcto de la práctica”,
sino que es obtener resultados que cumplan los estándares de formación de los
ingenieros (conocimiento).

Tomando la premisa para entender si se cumplió la práctica

satisfactoriamente, es posible decir que se cumplió satisfactoriamente al emplear la
biblioteca de java (clases, métodos, etc.) para realizar las actividades que aquí se
acontece.

Además de utilizar las rutinas ya establecidas en Java fue posible la

realización de creación de clases para modelar los objetos, además de implementar
propios métodos para su correcto funcionamiento.

Por parte de la inclusión de nuevos conceptos como es evidente en el

ejercicio 3, de clases envolventes; El código de prueba fue capaz de recolectar
ejemplos de la aplicación de cada envolvente en los diferentes tipos.

A mi consideración creo que las prácticas deben ser con más código
proporcionado con ejemplos para moverle y jugar con el código, esa idea me parece
más apropiada para el aprendizaje de programación, ya que cuando el código esta
en una hoja y el propósito es copiarlo, pegarlo , verificar si lo escribiste bien, es una
práctica que sólo quita tiempo en copiar código.

Sería una mejor práctica que el código tenga multitud de variantes para ver
lo que es posible hacer en su sección “para confundir a la gente”. O otra práctica
didáctica sería proporcionar código ofuscado que sólo nos hace desarrollar una
mejor lógica, por ejemplo que la hoja de ejercicios diga lo que tiene que hacer el
programa , y el código lo cumpla, pero con errores lógicos o que este ofuscado su
comprensión y nuestro deber es corregirlo. Desarrollas lógica y durante el
transcurso de la misma práctica se notará el dominio del lenguaje.

El hecho es que como dato curiso, la programación ofuscada es un juego de

destreza entre programadores para mejorar su velocidad de comprensión en

11
códigos y para fines didácticos me parece una excelente idea de implementación
en el salón de prácticas.

Para concluir, puedo decir que esta práctica contiene el nivel justo de
dificultad para ir de acuerdo con la teoría y los ejercicios siguen la misma métrica.

Bibliografía
Misja. (2019 de 02 de 28). epochconverter. Obtenido de https://www.epochconverter.com/

12