Bien, continuamos.
Vamos a ejecutar nuestra aplicación paso a paso para ver todos los detalles detrás de escena.
Cómo se van ejecutando los métodos y también poder entrar a estos métodos.
Por ejemplo, generar factura.
Calcular total.
Calcular importe.
En fin, y empezar a ejecutar línea línea dentro de estos métodos con step into bien y así ver cada
detalle.
Pero antes quiero ver algunos cambios, algunas optimizaciones que quedaron pendiente, pero también
algunos campos que son más eficiente para ejecutar a modo de depuración, como por ejemplo el primer
cambio.
Si nos vamos a factura en el método general detalle acá.
Bueno, acá se está agregando el item en el String Builder se fijan, pero el item por detrás de escena
de forma implícita automática, no lo vemos, va a invocar el método String para convertir el objeto
a un string.
Se fijan y si queremos invocar o acceder a este método con Step into, puede entrar este método en la
depuración.
No vamos a poder, ya que es implícito.
Entonces lo tenemos que invocar de forma explícita.
Entonces tu string solamente item punto, tu string y item también por acá invoca al string de producto.
Entonces también, si entramos al string, también vamos a querer entrar al string de producto.
Entonces también acá tu string de forma explícita.
Esos dos cambios son muy importante para depuración, para poder ver el detalle y entrar a estos métodos.
Bien, otro cambio que podríamos realizar en factura, por ejemplo acá el for foreach.
Se fijan el arreglo de dos elementos de capacida 12.
Pero podríamos registrar dos productos o dos item o tres o cinco.
Y hay mucho que son null.
Y se lo va a saltar con continúa entonces en la depuración para no estar con el step over en cada continue.
Cuando el nulo podremos implementar como alternativa.
Bueno, no es obligación, es otra forma y un poco mejor porque así evitamos el continue y iterar todo
el arreglo.
Entonces podríamos implementar un for común y corriente, iterar solamente hasta la cantidad elemento
que tengamos registrado, hasta la cantidad de items factura.
Bueno, y de donde sacamos esta cantidad de items?
Simple, un poco más arriba tenemos el atributo indice item y cada vez que agregamos un nuevo item factura
en el método add item factura, este se incrementa.
Por lo tanto contiene la cantidad de elementos registrados, la cantidad de factura que no son nulos
si no son objetos instancias de una factura.
Entonces, con un for común y corriente podríamos iterar hasta esta cantidad.
Perfecto.
Entonces modificamos el foreach de calcular total y el foreach de generar detalle.
Partamos acá.
Entonces lo primero en calcular total.
Voy a cortar este lo voy a cortar, lo dejamos abajo.
Por ahora igual lo dejamos así y acá int y igual a cero como siempre.
Punto y coma hasta que el contador Eli sea igual o mayor que la cantidad elementos, índice, ítems,
punto y coma y mamÃs incrementamos CT.
Bien, entonces voy a iterar mientras sea menor que la cantidad elementos y acá asignamos el ítem según
la iteración, según el índice o la posición duddits punto items, corchete y listo.
Eso si, diato el cambio se fijan y acá sigue exactamente igual.
En general, detalla.
Entonces vamos a cortar.
Lo pegamos abajo, igual diez puntos, items, corchete y bien.
Y acá, mientras él dice a menor que el índice le cantidad elementos, índice, ítems, incrementamos
el contador, se pegan un for común y corriente y así va a iterar.
Solamente atrae cantidad de ítems o producto que agreguemos, nada más.
Y este if lo quitamos no necesario.
Acá también me faltó quitar el LIF, ya que en realidad no hay ningún elemento nulo, no hay items nulos
solamente de iterar hasta la cantidad de elementos registrados.
Listo, incluso también se podría optimizar un poco más.
Se fijan?
Bueno, ahí está bien, perfecto, pero podríamos cortar esto para que lo vean.
Lo dejamos acá, Geto.
Le quitamos.
Entonces, por cada elemento obtenemos a través de li del contador índice.
Calcular importe.
Llega también lo podríamos cortar, se fijan y lo podríamos dejar acá.
Listo.
Eso sólo cambio, pequeño cambio.
Volvamos ejemplo, factura.
Qué otro cambio?
Bien, acá la descripción la podríamos cortar.
La dejamos acá y así ahorramos una variable.
Listo.
Qué más vamos a iterar en este ejemplo?
Hasta dos.
Para qué sea más corto.
Dos producto y listo.
Y comenzamos.
Vamos a colocar el punto de quiebre acá.
Ingrese una descripción de la factura.
Por acá hacemos un clic.
Punto y quiebre.
Y comenzamos.
Clic derecho de back.
Se posiciona en esta línea de hechos y nos vamos a consola.
No pasa nada.
Y en Debug acá tenemos el cliente o nombre Andrés, el NIF.
Perfecto.
Volvemos a consola y ejecutamos esta línea con Step Over.
Perfecto.
Ahora ingrese una descripción, pero primero tenemos que ejecutar esta línea.
Cuando se crea la instancia, la factura y si queremos entrar al detalle del constructor.
Cuando invocamos el new factura lo podríamos hacer con Step Into acá Step Into para ingresar al detalle.
Entonces hacemos un clic para ingresar al constructor.
Otro clic perfecto y listo.
Acá Next Line nos pide ingresar el nombre o descripción de la factura.
Hacemos un clic por acá.
Lo ingresamos.
Artículos deportivos.
Enter se fijan.
Ahora ingresamos al constructor de factura, descripción y cliente.
Ahí pasamos todos datos.
Entonces ahora este joven para ir paso a paso, línea a línea.
Si se fijan, hacemos un clic en descripción.
Se posiciona, pero todavía no se ejecuta.
Ahora ejecutamos y ya tenemos descripción.
De hecho, podríamos ir a Debugger por acá y tenemos descripción, artículos deportivos, pero el folio,
los items y todo lo demás, incluso el cliente está todo en nulo porque todavía nos asigna.
Ahora, si hago clic en Step Over, se asigna cliente.
Se fijan.
Acá tenemos el cliente en el atributo this nombre y el NIF.
Y estamos dentro de la factura.
Estamos dentro.
Factura bien.
Ahora vamos a ejecutar también step over para items.
Ahora se crea el arreglo con dos elementos con 12 vemos por acá items.
Ahora tiene una referencia, una instancia, pero sin elementos.
Todos los elementos son nulos porque todavía no hemos agregado ningún ítem factura, así que está perfecto.
Continuamos con la fecha step over o F8.
Listo.
Ahí tenemos la fecha.
La vamos a ejecutar.
Todavía está en NULL.
Ahí tenemos la instancia y continuamos.
Ahora volvemos a ejemplo factura perfecto y ejecutamos.
Esté obert.
Nos vamos a prí este obert, nos vamos a Harford.
Comenzamos con el for índice i 0 pertencer.
Creamos la instancia producto, pero en realidad todavía no se crea.
Solamente estamos posicionado en esta línea.
Ahora la vamos a ejecutar.
Pero si quiero entrar al constructor, al igual como lo hicimos en factura, tiene que ser con Step
Into para poder ingresar al detalle.
Hacemos un clic.
Se fijan?
Ahora estamos producto en el constructor.
En esta línea la vamos a ejecutar con Step Over.
Y nos posicionamos para asignar el código o el Aydin, todavía el último código es tan cero.
El código también.
Recuerden que se incrementa el atributo estático último código lo ejecutamos para que se incremente
y asigne el valor 1.
Perfecto 1 porque es un pré incremento.
Nos salimos de producto perfecto, ejecutamos de nuevo.
Ingrese producto todavía no pasa nada, si nos vamos a consola, no pasa nada, pero si lo ejecutamos
una vez más.
Acá se posiciona, pero todavía falta ejecutar esta línea.
Next Line para obtener el nombre, entonces hacemos un clic y acá se deshabilita el menú y nos pide
ingresar el nombre producto.
Por ejemplo, un buzo para hacer deporte, un pantalón de uso entan se posiciona acá ejecutamos.
Ingrese el precio, todavía no pasa nada.
Hacemos otro click en Step Over, ahora se deshabilita, ingresamos el precio, por ejemplo 100 gentes,
lo mismo con la cantidad de step over perfecto.
Y acá para ejecutar esta línea.
Bueno, a cual entramos?
Primero agregar ítem factura o item factura al new.
Porque acá tenemos un constructor.
Podríamos ingresar al detalle el constructor new item factura que ingresa la cantidad y el producto
y después ingresamos al método Agregar factura.
Una vez que hayamos creado esta instancia, entonces por eso hay que ir paso a paso.
Entonces para poder ejecutar esta línea, ingresar al constructor Itan factura tenemos que hacer clic
Step into se fijan esté into acá no pide seleccionar porque podemos entrar acá o acá.
Entonces con el mouse con un clic.
Seleccionamos ítem factura.
Quiero primero ver el detalle de ítem factura.
Perfecto.
Un clic.
Ahora nos pide la cantidad.
Por ejemplo, dos o uno.
Uno solo.
Perfecto.
Se fijan y factura.
Constructor cantidad y producto.
La cantidad uno.
El producto buso que vale 100 y ejecutamos step over.
Ingresamos la cantidad uno perfecto.
Ingresamos el producto buso con precio 100.
Perfecto.
Se fijan.
Ahí tenemos el producto.
Hay Di1 buso precio 100.
La cantidad uno.
Nos salimos y volvemos acá.
Ahora volvemos a ejecutar con Step Into para ingresar al método Add Item factura.
Por qué se ejecutó?
Ya creamos la instancia del item.
Ahora la tenemos que agregar al método.
Entonces Step Into Perfecto ingresamos al método Agregar ítem factura o admite factura.
Pasamos el item pregunta si el índice ítem que todavía 0.
Porque todavía no hemos ingresado ningún producto, ningún ítems.
Entonces como es menor que 12 es true.
Y lo agregamos al arreglo índice ítem por defecto cero.
Por lo tanto, lo guarda en el índice oposición cero del arreglo y luego se incrementa.
Se incrementa en uno para el siguiente producto que queremos agregar o ítems bien ejecutemos step over
step over.
Perfecto.
Ahora, si volvemos a debugger, podríamos empezar a analizar ver factura.
Acá tenemos índice ítem que vale 1.
Antes valía 0.
Y también tenemos 10 ítems.
Un arreglo?
Cero.
Posición cero que contiene un ítem, y este ítem contiene la cantidad uno y un producto.
Qué producto?
Bueno, el buzo con el código uno o el Heidy y el precio 100.
Se fijan, entonces ya empezamos a relacionar los objetos y se empieza a armar todo este cuento por
detrás de escena.
Claro, cuando ejecutamos la aplicación no lo vemos, pero si empezamos a ejecutar paso a paso vamos
viendo los detalles y cómo podemos entrar a cada método, cada constructor y empezar a ejecutar paso
a paso.
Bien, nos salimos de step over el print perfecto step over next line, step over.
Siguiente iteración Vamos a ingresar un segundo producto ahora Heli todavía vale cero.
Hacemos un clic.
Vale uno.
Se incrementa.
Se fija.
Agregamos otro producto.
Vamos a ingresar al constructor step into f7.
Perfecto.
Recuerden que el último código valía uno.
Ahora va a valer 2 y se asigna el 2 en el código de este nuevo producto.
Entonces Step Over lo ejecutamos ahora código vale 2 y último código también.
De hecho, podríamos ver en Debug acá está, dice Código 2.
Es decir, el Heidy del producto y el último código Balaidos también.
Bien.
Continuamos.
Volvemos.
Ingrese un producto o nombre producto.
Lo ejecutamos.
Todavía no pasa nada si nos vamos a consola.
No pregunta todavía.
Ahora si.
Step over pregunta.
Pero sin embargo tenemos que ejecutar esta línea el escáner punto next line para ingresar el nombre.
Entonces Step over.
Ahora si se deshabilita, ingresamos el nuevo nombre.
Por ejemplo boleras enter.
Ingrese el precio.
Ok.
Lo ejecutamos.
Ingrese el precio.
Pero todavía no pasa nada porque tenemos que volver ejecutar para que se invoque este método next float
del escáner y así ingresar el precio.
Entonces ejecutamos, ahora se deshabilita, ingresamos el precio 50 y lo mismo la cantidad la ejecutamos.
Nos posicionamos bien.
Y acá tenemos dos caminos podemos invocar en Factura o Hypnos al detalle del ítem factura del new del
constructor, o bien agregar ítem factura.
Bueno, lo mejor ir en orden.
Primero, crear la instancia, entrar a este detalle y luego entrar a este método.
Y para eso sería igual con Step Into, igual como lo hicimos en delante con el primer producto.
Entonces Step Into seleccionamos acá con un clic importante New Item factura.
Hacemos un clic acá y en factura.
Ingresamos la cantidad, dos entes se fijan, ahora estamos en el constructor de ítem, factura, cantidad
y el producto perfecto.
Ejecutamos este Ober la cantidad, pusimos dos.
Por ahora es cero.
Que sería dicha cantidad?
Vale cero.
Y el parámetro cantidad vale dos.
Ahora se lo asignamos.
Lo ejecutamos este Hoffer cantidad baleados ahora y asignamos producto.
Disputo por ahora en Nul y el producto que estamos pasando por argumento es polera Heidy 2 o código
2 y vale 50.
Lo ejecutamos para asignar.
Perfecto, ya tenemos los dos.
Ya tenemos Elita en factura.
Volvemos a ejecutar, volvemos también y Step Into para ingresar al detalle de it factura de este método
agregar Itan factura.
Esté pinto un clic índice item.
Recuerden que vale 1.
Por qué se había incrementado.
La vez pasada.
Pero sigue siendo menor que 12.
Por supuesto es thru.
Por lo tanto.
Agregamos este nuevo ítem en la posición 1.
Ahora recuerden que primeros asignÃ y después incrementa.
Entonces asignÃ en la posición 1 y luego se incrementa a 2.
Pero este ítem va a estar en el índice 1 del arreglo.
Items bien.
Ejecutamos este over.
Ejecutamos y vamos a debugger.
Por acá ya tenemos 0 y 1 0.
Tenemos el producto, el buzo.
Se fijan código 1 buzo y en la posición 1 tenemos cantidad 2.
Producto polera vale 50.
Ya está.
Ya tenemos todo casi.
Volvemos a ejecutar este over print next line, lo ejecutamos de nuevo step over, volvemos Alford y
acá se incrementa y vale uno, se incrementa dos.
2 es menor que dos, no?
Por lo tanto se sale de vigen.
Ahora imprimimos factura, pero cuando es un system out print line, automáticamente se invoca al toString.
Pero acá sí podemos ingresar al método toString porque se está imprimiendo.
Entonces es importante que acá, en vez de colocar un step over, colocamos un step into muy importante
para entrar al detalle del string.
Hacemos un clic.
Se fijan.
Ingresamos tus string.
Generar detalle.
También lo vamos a invocar.
Hacemos un clic.
Pero Step Into también para ingresar al detalle general, detalla, entramos a este método.
Acá estamos dentro del Stream Builder, está perfecto y acá ejecutamos paso a paso.
Por ejemplo, el step over, agregamos el folio, este hover cliente y vamos concatenado.
Acá tenemos dos Kamino, lo podemos pasar por encima, saltar sin entrar al método get nombre del cliente.
O bien podríamos entrar al método.
Si colocamos TEPT Into va a ingresar el método get nombre.
Veamos Step into se fijan?
Ingresamos a cliente get nombre Andrés.
Perfecto, lo ejecutamos.
Volvemos, ejecutamos de nuevo el NIF, volvemos Step Over y acá también podríamos entrar al detalle
de cliente punto get, nif, step into.
Y acá estamos en el detalle.
Lo ejecutamos step over.
Paso a paso.
Descripción Luego descripción también como son atributos, lo mismo si es este pinto este hover porque
no es un método.
Entonces este hover salto línea, este hover.
Acá también vamos saltando emisión.
Step over este hover y Alford este over.
Comenzamos la iteración y acá es importante porque vamos a ingresar al método string de cada item.
Bien, entonces comenzamos con el I 0 índice 0 con el primer elemento que sería el buso.
Ejecutamos con step over.
Se fijan acá nos posicionamos en esta línea.
Entonces quiero entrar al detalle del string.
Entonces ejecutamos acá el step into llega.
Nos pregunta nos vamos al happen o al toString?
Al happen?
No, porque el string builder no nos interesa.
A mi me interesa ver el string de la clase items factura.
Hacemos un clic acá String.
Perfecto, ingresamos y acá también paso a paso.
Nuevamente este punto para ingresar al string de producto se fijan como se van encadenando la llamada
de métodos.
Acá selecciona tu Streak.
Ahora estamos unproducto en el toString de producto y ejecutamos paso a paso.
Se fijan ahora volvimos al string de items y el tuit string de producto es bueno producto con el Heidy
Buso y el precio y acá le agregamos la cantidad.
Entonces ejecutamos y también le agregamos el importe.
Como es otro método, también podemos entrar al detalle Step Into ingresamos a calcular importe de la
factura.
Entonces acá tenemos 10 cantida atributo propio de clase por precio el producto.
Incluso acá podemos ver el detalle de que el precio del objeto producto.
Entonces este pinto qué precio?
Vale €100 para el producto buso bien ejecutamos.
Ejecutamos nuevamente este over.
Y ejecutamos para salir del toString del Iten factura, se fijan este pocker listo, volvimos ahora
de nuevo este over.
Esté over y de nuevo Alford, la siguiente iteración recuerden que iba cero, ahora se incrementa vale
1, vale 1.
Siguiente producto cual la polera que vale 50 con el código 2.
Bien, ingresamos al detalle con Step Into, igual que en adelante seleccionamos el toString.
Ingresamos.
De nuevo, este pinto seleccionado molto stink, como es una sola línea acá, nos pregunta.
Calcular Importe o toString?
Primero el toString.
Se fijan Código 2 nombre.
La polera.
Y precio 50 se fijan?
Volvemos a ejecutar este over osté pinto para ingresar a calcular importe acá.
Entonces ingresamos nuevamente Stepp Pinto.
Acá estamos, calcula el importe cantidá el precio cantidad 2 en este caso son 2 poleras y el precio
50 nuevamente step into para ingresar al precio del objeto producto.
50.
Ejecutamos, volvemos, volvemos a calcular, importe.
Volvemos y volvemos.
Y Salto Línea.
Nos salimos, vuelve a preguntar evalúa ahora el iba a valer 2 y no se cumple, por lo tanto se sale
de foro, se fijan, se sale.
Ahora vamos a ver el gran total.
Calcular el que era en total este over.
Y acá este pinto.
Calcular total qué comienza?
Paso a paso, línea, línea.
Total, lo ejecutamos.
Parten cero.
Comienza la iteración.
El for y vale cero.
Todavía no pasa nada.
Ahora vamos a ejecutar Step Into porque podríamos ir a calcular importe de items.
Se fijan, ahora se va a este método, podrían ingresar el precio.
Pero bueno, lo vamos a pasar por encima con Step Over.
Sabemos que el precio es 100 para el buzo y la cantidad 1.
Por lo tanto, hacer 100 el total.
Ahora ejecutamos.
Se fijan, total vale 100 para el primer item, para el primer producto, ya que la cantidad es una
sola.
Volvemos a ejecutar acá este over ahora Liva le1 para el siguiente producto el producto polera step
into para ingresar a calcular importe cantidad 2 precio 50.
Por lo tanto, 2pues 50 100.
Lo ejecutamos de Ober, ahora lo ejecutamos y va a ser 100, 100 más 100, 200, porque va a sumar el
100 que tenía más el 100 de ahora, que sería 2 por 50 cantidad por precio.
Step over.
200 vuelve a iterar y pregunta pero Eli vale 2 y tenemos 2.
Por lo tanto sea salir.
Total, doscientos.
Perfecto, ejecutamos tu estric, lo ejecutamos.
Step over.
Y nos salimos de obert y volvemos acá y estamos casi listos.
Podríamos ver el detalle de los objetos en debugger, el cliente, la factura.
Acá tenemos la factura completo con su folio, la descripción, la fecha cliente con el nombre, el
NIF, los items 2 items cantidad 1 producto código 1 Buso Precio 100 el segundo ítem cantidad 2 Producto
Polera Código 2 Precio 50 Índice Ítem 2 porque tenemos 2 items 2 elementos se fijan ahí tenemos todo
detalle y en consola también el detalle completo la factura factura número 1 Cliente 3 Bueno, acá se
imprime todo lo que hemos visto y lo que hemos ejecutado paso a paso.
La emisión de la factura, la tabla con los dos ítems buzo, polera, en fin, precio, cantidad y el
total llega total 200.
Y para finalizar, qué estamos acá?
Hacemos un clic en este poder y finaliza bien.
Quería explicar este tema, creo que importante realizar un debug y ver cómo funciona por detrás de
escena, cómo se van invocando los métodos y vamos ejecutando línea línea.
Bien, por ahora nada más.
Continuamos en la siguiente clase.