Saltar navegación

Activa JavaScript para disfrutar de los vídeos de la Mediateca.

Clase 15-01-24 - 3 - Contenido educativo

Ajuste de pantalla

El ajuste de pantalla se aprecia al ver el vídeo en pantalla completa. Elige la presentación que más te guste:

Subido el 16 de enero de 2024 por Raquel G.

6 visualizaciones

Más información Transcripción

Descargar la transcripción

Bueno, pues este método es bastante interesante porque nos permite a un pedido que ya existe 00:00:00
No comas, Andrés, joder, de verdad, ¿eh? 00:00:07
Ay, Dios mío 00:00:12
Bueno, a ver, entonces este método nos lo pedía el cuerpo 00:00:25
porque obviamente a un pedido que ya existe tiene sentido que se le añadan ítems, nos lo pedía el cuerpo 00:00:30
Bueno, y una vez que ya está hecho, de nuevo, lo bueno que tiene es que una vez hecho este código 00:00:36
ya este código uno ya se olvida de él, ya me da igual, yo ya lo hice en su momento y me olvido de él 00:00:42
Cada vez que tenga que añadir un ítem, llamo al método y lo añado 00:00:47
Como esté hecho el método por dentro es que ya no me preocupa nada, ¿vale? 00:00:51
Esa es la famosa encapsulación que mencionábamos el otro día cuando hacía el método de objetos 00:00:55
Yo hago un código dentro de un método, en el momento de hacerlo, pues obviamente he tenido que pensar y hacerlo 00:00:59
Una vez que ya está hecho, todo esto ya se queda encapsulado con su nombrecito 00:01:04
y yo ya lo llamo las doscientas mil veces que necesite 00:01:09
que como esté hecho por dentro ya me da igual, me limito a llamar, ¿vale? 00:01:13
Esa es la encapsulación, la ventaja de la aplicación de estos objetos 00:01:17
Vale 00:01:20
Bueno, pues venga, entonces, este método tiene su interés, ¿vale? 00:01:27
¿Qué otras cosas son interesantes realizar con los pedidos? 00:01:31
Se supone que uno ha hablado con el cliente y el cliente le ha explicado las cosas que va a necesitar 00:01:36
y entonces él las recoge y las mete aquí dentro 00:01:42
Hombre, pues si estamos hablando de precios y de pedidos 00:01:45
de hecho, el ítem, cada ítem, el boy, la goma, lo que fuera, cada ítem tiene un precio como propiedad 00:01:49
Bueno, pues tiene sentido que el cliente necesite calcular el coste de un pedido entero, ¿no? 00:01:57
Tiene sentido, seguramente sea una funcionalidad que el cliente me haya dicho 00:02:03
Oye, cuando digo cliente, o sea no lo confundáis con el cliente de la aplicación clientes pedidos 00:02:07
digo el que me está pidiendo el software, ¿vale? 00:02:13
El que me está pidiendo el software lo más probable es que me haya dicho 00:02:15
Oye, me voy a necesitar cuando yo tengo un pedido en mi aplicación ya hecho 00:02:19
Voy a editar, dándole a un botoncito, paz, calcular lo que cuesta, voy a necesitarlo 00:02:25
Ah, vale, muy bien 00:02:30
Pues en ese caso, automáticamente ya pensamos en un método para hacer eso 00:02:32
Pensamos en un método para calcular lo que me ha costado un pedido 00:02:38
Ese método donde lo metemos 00:02:43
Hombre, pues habrá que pensar con qué está relacionado esta funcionalidad 00:02:46
La funcionalidad de calcular lo que me cuesta un pedido 00:02:50
Pues el propio denunciado me lo dice, está relacionado con un pedido 00:02:54
Está relacionado con un pedido, pues el sitio para meter ese método es el pedido 00:02:57
Es el sitio para meterlo, ¿vale? 00:03:02
Bueno, pues entonces en la clase pedido tiene por tanto todo el sentido del mundo 00:03:05
que añadamos otro método más 00:03:10
Un método para devolver el precio del pedido, ¿vale? 00:03:13
Entonces, vamos a hacerlo 00:03:19
Lo de siempre, un nombre, el nombre más explicativo posible 00:03:24
Venga, pues devolver precio total, por ejemplo, devolver precio total 00:03:29
Y ahora nos hacemos las preguntas de siempre 00:03:36
¿Vale? 00:03:41
¿Vale? 00:03:46
Devolver precio total 00:03:48
¿Vale? 00:03:50
Ya hemos tomado una decisión de diseño importantísima 00:03:51
Que es donde ubico este método dentro de todas las clases que tengo 00:03:54
Pues donde lo ubicamos, repito, como es un método que trabaja con cosas del pedido 00:03:59
Pues lo ubico en la clase pedido 00:04:05
¿Vale? 00:04:08
Todo eso son decisiones de diseño que son tan importantes como hacer un código puro y duro 00:04:09
No lo perdáis de vista 00:04:14
Bueno, pues en la clase pedido habrá un método de volver pedido 00:04:16
para calcular el precio de ese pedido que llama al método 00:04:19
El nombre ya lo hemos seleccionado 00:04:23
Nos hacemos el resto de preguntas 00:04:25
¿Para calcular el precio del pedido que llame a este método 00:04:28
necesito alguna información desde fuera 00:04:32
O con lo que tengo aquí ya en las propiedades voy a poder calcularlo 00:04:35
¿Y el precio de cada ida dónde está? 00:04:43
Claro, está aquí 00:04:50
Con lo cual, ¿necesito alguna información desde fuera 00:04:52
para que este método pueda calcular el precio total? 00:04:57
No, porque el objeto pedido tiene ya su array de ítems 00:05:02
Y cada ítem tiene su precio dentro, al que yo puedo acceder 00:05:06
Entonces no necesito ninguna información desde fuera 00:05:10
para calcular el precio total de todos los ítems, la suma 00:05:13
Para calcular la suma de los precios no lo necesito 00:05:17
Está aquí toda la información en una propiedad 00:05:20
Entonces, esto, fuera, me da parámetros 00:05:23
Vale, tipo de dato de salida 00:05:29
¿Me va a devolver algo este método? 00:05:31
¿Sí o no? 00:05:35
¿El precio? ¿Es un método para devolverme el precio? 00:05:40
Pues me tendrá que devolver el precio 00:05:43
O sea, este método, su efecto no es modificar una propiedad 00:05:45
Su efecto no es modificar el código 00:05:50
ni modificar la descripción 00:05:52
ni modificar los ítems, no 00:05:54
Su precio es calcular una suma 00:05:56
de precios individuales de ítem 00:05:58
y me la tendrá que entregar, para que pueda trabajar con ella 00:06:00
me la tendrá que entregar 00:06:03
Si no, yo la pierdo, me la tendrá que entregar 00:06:04
Bueno, pues entonces este método 00:06:07
me va a devolver un dabble con valor de retorno 00:06:10
que es el precio 00:06:13
A ver, otro diseño posible 00:06:19
podría ser, podría ser 00:06:21
A ver, tenéis que seguirme, no vale que os perdáis 00:06:25
Otro diseño posible podría ser 00:06:28
Oye, ¿y por qué no haces además una propiedad aquí en pedido? 00:06:30
Ya que estás 00:06:34
Hazme una propiedad que sea el precio del pedido 00:06:36
Hazme una propiedad 00:06:38
Bueno, vale, venga, vamos a hacer una propiedad que sea el precio del pedido 00:06:40
Por ejemplo así 00:06:43
Imaginaos que yo haga una propiedad que sea el precio del pedido 00:06:45
Joder, no quería poder traer 00:06:48
Vale, bueno 00:06:54
Vale, imaginaos, la voy a quitar ahora 00:06:57
Pero imaginaos que me dijeréis 00:06:59
Oye, ¿por qué no haces una propiedad que sea el precio del pedido? 00:07:01
Venga, ya que estamos diseñando 00:07:04
Todavía la estáis, estamos diseñando 00:07:06
Pues yo puedo diseñar donde la gana 00:07:08
Pues venga, voy a hacer que una propiedad del pedido sea su precio 00:07:10
Pues ya está, la pongo 00:07:13
Si yo pongo ahí esa propiedad 00:07:15
Pues hombre, este método 00:07:17
En lugar de devolverlo 00:07:19
Podría hacer que devolviera a Void 00:07:21
Y ahora ya lo que, este método 00:07:23
Haría lo que tuviera que hacer 00:07:25
Y a esa propiedad precio ya le asignaría lo que fuera 00:07:27
Después de yo haberlo calculado, ¿verdad? 00:07:30
Ya le asignaría lo que fuera 00:07:32
Entonces en este caso 00:07:34
No hace falta que haga un return y devuelva nada 00:07:36
Porque ese precio que calcula 00:07:39
Lo guardaría en esta propiedad 00:07:42
Lo guardaría en esta propiedad 00:07:45
¿Entendéis? Esto es para que os quede claro 00:07:47
El concepto de valor de retorno de un método 00:07:50
El valor de retorno de un método 00:07:53
Es algo que entregamos hacia afuera 00:07:56
Porque alguien de fuera lo necesita 00:07:58
¿Vale? 00:08:01
Pero puede ser que el método 00:08:03
Sus efectos 00:08:05
Sean simplemente actualizar propiedades 00:08:07
Entonces si ha actualizado propiedades 00:08:10
El efecto ya está ahí en la propiedad del objeto 00:08:12
Ya está ahí y el de fuera puede acceder a esa propiedad 00:08:14
Para ver cómo ha quedado ya modificada 00:08:16
Puede acceder desde fuera 00:08:18
Entonces no es necesario que lo devuelva 00:08:20
¿Vale? 00:08:22
Entonces hombre, si uno cambia el diseño y lo pone así 00:08:24
¿Vale? 00:08:26
Lo que pasa es que este diseño 00:08:28
Se presta a que luego la aplicación pueda tener un montón de errores 00:08:30
¿Por qué? 00:08:32
Porque oye, cuidado que tiene que haber una correspondencia siempre 00:08:34
Entre el precio del pedido 00:08:36
Y la suma de los precios que hay aquí 00:08:38
Entonces si yo añado un ítem 00:08:40
Tengo que acordarme automáticamente 00:08:42
De llamar otra vez a devolver precio 00:08:44
Para que actualice el precio 00:08:46
No sé si me explico 00:08:48
Si añado un ítem, el precio del pedido cambia 00:08:50
Entonces voy a tener que estar muy hábil 00:08:52
Para cada vez que añado un ítem 00:08:54
Asegurarme de actualizar esta propiedad 00:08:56
Asegurarme de actualizarla 00:09:00
Para sumarle el precio del nuevo ítem 00:09:02
Que he metido 00:09:04
Pues hombre, vaya complicación 00:09:06
Con eso estoy comprando todas las papeletas 00:09:08
Para que la aplicación funcione mal 00:09:10
Porque a lo mejor le añado un ítem 00:09:12
De que entonces el precio se ha quedado anticuado 00:09:14
Y no me acuerdo 00:09:16
Entonces empiezo a comprar papeletas 00:09:20
De que esto no funcione mal 00:09:22
Mejor diseño, oye 00:09:24
El precio ya está metido en los ítems, el de cada uno 00:09:26
Cuando lo quieras 00:09:28
Llama al método que te dé el actualizado 00:09:30
Y olvídate de esta variable 00:09:32
Que te vas a tener que actualizarla a tu mano 00:09:34
Cada dos por tres 00:09:36
Olvídate porque se presta a que la cagues seguro 00:09:38
¿Vale? 00:09:40
Pero, repito 00:09:44
Si estuviera ahí esa variable, este método entonces 00:09:46
No necesitaría devolver nada 00:09:48
Porque su efecto se quedaría aquí guardadito 00:09:50
Y ya el de fuera, el main 00:09:52
Que acceda a esa propiedad si quiere 00:09:54
Si no, no 00:09:56
Pero repito, como que si está aquí esta propiedad 00:09:58
Nos complica la vida, por esto que os digo 00:10:00
Nos la complica 00:10:02
Pues la quitamos 00:10:04
Y si la quitamos, entonces ahora ya este método 00:10:06
Lo devuelve con ahorro de retorno 00:10:08
Para que el de fuera 00:10:10
Obtenga ese precio y haga lo que le de la gana 00:10:12
¿Vale? 00:10:14
Entonces, como veis 00:10:16
Nuestra tarea de programar 00:10:18
Empieza a ganar cada vez más recorrido 00:10:20
En temas de 00:10:22
Diseño, de hacer diseños 00:10:24
Que creen aplicaciones 00:10:26
No solo que funcionen 00:10:28
Porque cualquier aplicación puede funcionar 00:10:30
Sino que genere 00:10:32
El mínimo conjunto 00:10:34
De errores posible 00:10:36
El mínimo conjunto de situaciones 00:10:38
Que puedan ser problemáticas 00:10:40
Sobre todo que tú la puedas ampliar 00:10:42
Que la puedas entender 00:10:44
Sin mayores complicaciones 00:10:46
Bueno, pues entonces 00:10:48
Devolver precio total, lo tenemos claro 00:10:50
No necesita que le pasemos nada 00:10:52
Porque será la suma 00:10:54
De los precios de los ítems independientes 00:10:56
Con lo cual necesita que le pasemos nada 00:10:58
Eso está claro 00:11:00
Y que devuelve el precio total 00:11:02
Bueno, pues nada, devuelve el precio total 00:11:04
Ahora ya esto será hacer una suma cumulativa de toda la vida 00:11:06
Ahora ya, nosotros en cada método 00:11:08
Ya integramos lo que sabemos 00:11:10
De programar 00:11:12
El precio total cual va a ser 00:11:14
Pues de cada ítem de este 00:11:16
Cada ítem de este Array 00:11:18
Tiene un precio 00:11:20
Entonces tendremos que hacer una suma acumulativa 00:11:22
Que vaya sumando esos precios 00:11:24
Y nada más, recorrer un Array 00:11:26
Y en una suma acumulativa ir sumándolo 00:11:28
Pues ahora ya vamos aplicando donde corresponde 00:11:30
Todas esas cosas que sabemos hacer 00:11:32
Las aplicamos donde toque 00:11:34
Toca ahora hacer una suma acumulativa 00:11:36
De precios del Array 00:11:38
Pues venga, una suma acumulativa 00:11:42
Empieza valiendo cero 00:11:44
Y ahora los sumando 00:11:46
Van viniendo de recorrer el Array de ítems 00:11:48
Vamos a recorrer el Array de ítems 00:11:50
Por comodidad 00:11:52
Como solamente vamos a leer 00:11:54
Usamos un for each 00:11:56
Que si solamente recorremos 00:11:58
Para leer es muy cómodo 00:12:00
Y ahora 00:12:06
Suma más igual 00:12:08
¿Qué pongo ahí? 00:12:10
Dictadmelo 00:12:12
Estoy con un for each 00:12:16
No con i 00:12:18
¿Qué pongo ahí? ¿Que alguien me lo dicte? 00:12:22
Quiero poner el precio del 00:12:24
Ítem i 00:12:26
¿Qué pongo? 00:12:28
¿Eh? 00:12:36
Eso, muy bien 00:12:38
Precio, eso es lo que pongo 00:12:40
Voy sumando 00:12:46
En la suma acumulativa 00:12:48
Los precios 00:12:50
De cada ítem 00:12:52
Cada ítem tiene un precio 00:12:54
Bueno, claro 00:12:56
Aquí esto ha quedado un poco 00:12:58
Porque 00:13:00
Ahora tendremos que preguntarnos 00:13:02
Oye, cuidado, ¿este precio es el precio 00:13:04
Por unidad? 00:13:06
¿O el precio total? 00:13:08
Tiene sentido que sea el precio 00:13:10
Por unidad 00:13:12
¿Verdad? 00:13:14
Pero si es el precio total 00:13:16
Estamos en la misma de antes 00:13:18
Si yo a un ítem concreto le cambio la cantidad 00:13:20
Tengo que acordarme de actualizar el precio 00:13:22
Que me acuerde siempre 00:13:24
No es muy confiable 00:13:26
Entonces tiene sentido que este sea el precio 00:13:28
Por unidad 00:13:30
Y así 00:13:32
Aprendemos un poco de refactorización 00:13:34
¿Vale? 00:13:36
Refactorización es 00:13:38
Algo que veréis en entornos de desarrollo 00:13:40
Si no habéis visto ya 00:13:42
Pero vamos, es una chorrada 00:13:44
Cuando uno tiene un código ya hecho 00:13:46
Que funciona 00:13:48
Pues refactorizar 00:13:50
Es simplemente cambiar 00:13:52
Nombres, cambiar 00:13:54
Donde están las cosas colocadas 00:13:56
Para que el código sea más bonito y se entienda mejor 00:13:58
Pero su funcionamiento no cambia nada 00:14:00
No cambia nada 00:14:02
Es cambiar solamente nombres y colocaciones 00:14:04
Eso es refactorizar 00:14:06
No altera nada el funcionamiento 00:14:08
Porque si altera el funcionamiento estás cambiando el código 00:14:10
Es otra cosa 00:14:12
Entonces el término refactorizar es ese 00:14:14
Voy a reescribir mi código para que quede más bonito 00:14:16
Pues entonces 00:14:18
Lo que yo he dicho de cambiar esta variable 00:14:20
De precio a precio por unidad 00:14:22
Para que quede más bonito 00:14:24
Eso es 00:14:26
Tarea de refactorización 00:14:28
Porque estoy cambiando el código para que quede más bonito 00:14:30
Vale, refactorizar 00:14:32
Uno lo puede hacer a mano 00:14:34
Que yo tendría que escribir aquí a mano 00:14:36
Y ahora irme a cada vez que aparece precio 00:14:38
Irme uno por uno, irlo cambiando 00:14:40
Y estaría refactorizando 00:14:42
A mano 00:14:44
Pero hombre es un rollo 00:14:46
Entonces los entornos de desarrollo 00:14:48
Te permiten hacer tareas de refactorización automáticamente 00:14:50
Entonces si yo me coloco 00:14:52
Aquí en precio 00:14:54
Botón derecho 00:14:56
Veis que se abre un refactor 00:14:58
En algún sitio, verdad 00:15:00
Le dais a la variable 00:15:02
Botón derecho, se abre un refactor 00:15:04
Y aquí te vienen todas las tareas de refactorización 00:15:06
Que puedes hacer 00:15:08
La que yo quiero hacer es cambiarle el nombre 00:15:10
The name 00:15:12
Pues le doy a rename 00:15:14
Y que hace, me cambia el nombre de esa y de todas 00:15:16
Las apariciones en el resto del código 00:15:18
Con lo cual me evita hacerlo a mano 00:15:20
Es lo único que hace el Eclipse 00:15:22
Refacto, rename 00:15:24
Y me dice, vale, que nombre le quieres poner 00:15:26
Pues unidad 00:15:28
Enter 00:15:30
Y ala, veis, magia, me la cambio en todas partes 00:15:32
Veis, precio unidad 00:15:34
Precio unidad 00:15:36
Esto es simplemente que yo he querido cambiar el nombre 00:15:44
Para que sea más claro 00:15:46
Y repito, cambiar el código 00:15:48
Para que sea más bonito, pero sin cambiar su funcionamiento 00:15:50
A eso se le llama 00:15:52
Refactorizar 00:15:54
Los entornos de desarrollo 00:15:58
Te permiten refactorizar de forma 00:16:00
Cómoda para no tener tu que ir cambiando 00:16:02
A mano 00:16:04
Vale 00:16:06
Pero 00:16:10
Que os he dicho yo siempre 00:16:12
Que los entornos de desarrollo son tontos 00:16:14
Y que si os fiáis de ellos 00:16:16
La vais a cagar 00:16:18
Así tan ancho con la refactorización del rename 00:16:20
La cagaos 00:16:22
Porque el get y el set a esos no los ha cambiado de nombre 00:16:24
No los ha cambiado 00:16:26
Porque el no lo sabe 00:16:28
Con lo cual si lo dejamos así 00:16:30
Nuestra aplicación 00:16:32
Dejo de funcionar 00:16:34
Dejo de funcionar 00:16:36
Porque el get no se llama 00:16:40
GetPrecio ahora, se tiene que llamar 00:16:42
GetPrecioUnidad 00:16:44
Porque la propiedad ha cambiado 00:16:46
A GetPrecioUnidad 00:16:48
Y el set igual 00:16:56
Vale 00:17:02
Entonces no olvidéis 00:17:04
Porque uno cuando genera los get y los set 00:17:06
Como los genera automáticamente 00:17:08
Hay veces que los mira 00:17:10
Pero hombre, hay que asegurarse de que los get y los set 00:17:12
Tienen los nombres que tienen que tener 00:17:14
Que son get o set 00:17:16
Lo que toque 00:17:18
Y luego el nombre de la propiedad 00:17:20
Pero cambiado a mayúscula la primera letra 00:17:22
Cambiado a mayúscula 00:17:24
Ese es el nombre que tienen que tener 00:17:26
Porque si no tienen ese nombre 00:17:28
Cuando otras clases 00:17:30
Busquen nuestras propiedades 00:17:32
No las van a encontrar 00:17:34
Porque las van a buscar con ese convenio de nombres 00:17:36
Si les hemos dado otro 00:17:38
GetPepito, pues es imposible que encuentre 00:17:40
El precio con un GetPepito 00:17:42
Con un GetPrecio 00:17:44
Vale 00:17:46
Bueno, pues tenéis que mantener un control 00:17:48
De todo 00:17:50
Cuidado con las cosas que se generan, con las cosas que se hacen 00:17:52
Dime 00:17:54
AddItem que está aquí 00:17:58
Vale 00:18:00
Este 00:18:02
¿Hay algo mal? 00:18:06
Vale 00:18:14
Vale, pues entonces 00:18:18
Ahora ya 00:18:20
Este es el precio por unidad 00:18:22
Entonces cada item 00:18:24
Habrá que sumar 00:18:26
A la suma acumulativa el precio por unidad 00:18:28
Por la cantidad que tenga, ¿verdad? 00:18:30
Entonces en mi suma acumulativa 00:18:32
GetPrecio 00:18:34
Por 00:18:36
i.getCantidad 00:18:38
¿Vale? GetPrecio unidad 00:18:40
La geta ha cambiado 00:18:42
Vale, entonces 00:18:44
Mi suma acumulativa es una suma 00:18:46
Que va sumando 00:18:48
Va incorporando 00:18:50
¿Qué sumando va incorporando a la suma? 00:18:52
Pues para cada item i 00:18:54
El precio unitario 00:18:56
Por la cantidad 00:18:58
Que tiene de eso 00:19:00
¿Vale? 00:19:02
Recordad que el operador por 00:19:04
Recordad cuando vimos que había operadores al principio de curso 00:19:06
Que el operador multiplicación 00:19:08
Y división 00:19:10
Son prioritarios respecto a sumas y restas 00:19:12
Con lo cual no hace falta 00:19:14
Que ponga yo aquí paréntesis 00:19:16
Porque esto se va a hacer siempre antes 00:19:18
Porque está con el operador por que tiene una prioridad 00:19:20
Pero si uno lo ve más claro 00:19:22
Y le queda más claro 00:19:24
Los paréntesis nunca molestan 00:19:26
Si son para aclarar código 00:19:28
Nunca molestan, entonces a lo mejor así lo vemos más claro 00:19:30
A la suma acumulativa 00:19:32
Le tenemos que sumar 00:19:34
El resultado de precio unitario por cantidad 00:19:36
Está claro, ¿no? 00:19:38
Y cuando ya he terminado yo mi 00:19:40
For 00:19:42
Ya puedo devolver 00:19:44
El precio del pedido 00:19:46
De esta manera 00:19:48
Vale, ya tengo ese otro 00:19:50
Método 00:19:52
Que dado un pedido me devuelve lo que ha 00:19:54
Costado, sumando para ello 00:19:56
Lo que aporta cada item 00:19:58
A ese precio total 00:20:00
¿Vale? 00:20:02
Ya tengo esa funcionalidad, bueno pues 00:20:04
Fenomenal 00:20:06
Y así uno puede incorporar a cada clase 00:20:08
Todas las utilidades 00:20:10
Que necesite hacer con los objetos de esa clase 00:20:12
En este caso hemos identificado dos 00:20:16
Utilidades, añadir un item 00:20:18
Nuevo 00:20:20
Y devolver el precio de ese pedido 00:20:22
Hemos identificado esas dos 00:20:24
Pero el cliente me puede decir, oye con los pedidos 00:20:26
También tienes que poder hacer esto, hacerlo otro 00:20:28
Por ejemplo 00:20:30
Podría haber una funcionalidad 00:20:32
Que vamos a dejarla 00:20:34
Abierta para que la completéis en casa 00:20:36
Tampoco aporta mucho 00:20:38
Que fuera, oye, también tienes que poder 00:20:40
Eliminar ítems de un pedido 00:20:42
Por favor, eliminar ítems 00:20:44
Quiero que elimines, no, los bolis no los quiero 00:20:46
Las carpetas o no se que, elimina 00:20:48
Vale, pues entonces eso de nuevo 00:20:50
Sería un método que habría que meter en la clase pedido 00:20:52
Porque es un método que trabaja con el pedido 00:20:54
Para quitarle ítems 00:20:56
Pues lo tendría que meter aquí 00:20:58
Vale, pues el proceso de siempre 00:21:00
Nombrecito 00:21:06
Que le tengo que pasar 00:21:08
Y que tiene que devolver 00:21:12
Pongo ya el public siempre 00:21:14
Porque estos métodos los tendrán que llamar 00:21:16
Desde fuera del paquete entidades 00:21:18
Vale, aquí ya empieza mi trabajo, pues de pensar 00:21:22
Vamos a ver 00:21:24
Para realizar la acción 00:21:26
De eliminar un ítem 00:21:28
De el array de ítems 00:21:30
Necesito que me digan 00:21:32
Algo desde fuera 00:21:34
Que pedido 00:21:36
Que ítem quieres eliminar 00:21:38
Que ítem, si me dices 00:21:40
Elimina el ítem de tu array 00:21:42
Ya, pero cual 00:21:44
Vale, pues ahora viene de nuevo una pregunta 00:21:46
A ver, pero que caracteriza 00:21:48
A mi ítem, para distinguir unos de otros 00:21:50
Si nos vamos al ítem, vale 00:21:52
Pues lo más natural 00:21:54
Es que me den 00:21:56
Elimina el ítem de descripción 00:21:58
Tal, elimina por 00:22:00
Bolis, gomas, carpetas, es normal 00:22:02
Que me digan elimina esto 00:22:04
Vale, porque 00:22:06
Esta propiedad es la que identifica 00:22:08
Univocamente a cada ítem 00:22:10
¿Habéis visto 00:22:12
Ya las claves primarias en bases de datos? 00:22:14
Vale 00:22:18
Una clave primaria, tenéis que hacer 00:22:20
Mucho paralelismo entre esto y bases de datos 00:22:22
Porque el desarrollo es desarrollar 00:22:24
Para modelos de datos relacionales 00:22:26
Hasta hoy en día 00:22:28
Porque modelos de datos orientados a objetos 00:22:30
Se abandonó 00:22:32
Arrancó en el 2000 00:22:34
Cuando empezó la aplicación 00:22:36
Orientada a objetos, como ya se hizo con todo 00:22:38
Pues obviamente 00:22:40
La comunidad desarrolladora 00:22:42
Dijo, hombre, pues vamos a hacer 00:22:44
Bases de datos orientadas a objetos 00:22:46
Y así tenemos 00:22:48
El absoluto paralelismo entre 00:22:50
Las bases de datos y el desarrollo 00:22:52
Vale, se hizo un grupo 00:22:54
A los 10 años 00:22:56
Se abandonó porque no hubo manera 00:22:58
¿Por qué? Porque las bases de datos relacionales 00:23:00
Estaban tan implantadas, llevan tantos años 00:23:02
En el mercado que era imposible 00:23:04
Sacarlas de ahí 00:23:06
Entonces por eso 00:23:08
La forma de almacenar datos sigue siendo 00:23:10
Mayoritariamente en bases 00:23:12
De datos relacionales 00:23:14
Y nosotros tenemos que hacer 00:23:16
Paralelismos entre nuestras clases 00:23:18
Y las tablas de las bases de datos relacionales 00:23:20
¿Vale? 00:23:22
Cuando alguna tecnología está muy implantada 00:23:24
Es muy complicado echarla 00:23:26
Es como los lenguajes de programación 00:23:28
Java cuando arrancó 00:23:30
Ostras, es muy lento 00:23:32
Claro que es lento, porque tiene una máquina virtual 00:23:34
Que interprete 00:23:36
¿Qué ha pasado con Java? 00:23:38
Que se ha implantado y no hay forma de sacarlo 00:23:40
De las aplicaciones de las empresas, no hay manera 00:23:42
Python, parecía que lo iba a echar 00:23:44
Nada, Python ya está 00:23:46
Está pasando así, cuando algo se ha implantado 00:23:48
¿Funciona bien o no funciona bien? 00:23:50
Sacarlo del mercado es prácticamente imposible 00:23:52
Java es un ejemplo 00:23:54
Bases de datos relacionales es otro 00:23:56
Bueno, pues entonces 00:23:58
A cuento de que venía este rollo 00:24:00
Que habéis visto ya las claves primarias 00:24:02
En bases de datos relacionales 00:24:04
Y sabéis que una clave primaria 00:24:06
Es el campo que identifica 00:24:08
De forma única a cada registro 00:24:10
¿No? O sea, no puede haber dos registros 00:24:12
Con la misma clave primaria 00:24:14
Y si uno hace un buen modelo de datos 00:24:16
Tiene que haber decidido 00:24:18
¿Cuál es la clave primaria? 00:24:20
Porque tener registros 00:24:22
Que no se pueden distinguir 00:24:24
No tiene ningún sentido, la idea es que cada registro se pueda distinguir 00:24:26
Para que se pueda distinguir 00:24:28
Tiene que haber una clave primaria que los distinga 00:24:30
Pues eso mismo 00:24:32
Ocurre aquí también 00:24:34
Cuando uno hace un diseño de clases y hace un diseño de campos 00:24:36
Uno de los campos 00:24:38
Debería funcionar 00:24:40
Como clave primaria, entre comillas 00:24:42
Es decir, como campo 00:24:44
Que distinga de forma unívoca a cada objeto 00:24:46
Porque si no 00:24:48
Estás haciendo un diseño muy irregular 00:24:50
Entonces, aquí 00:24:52
De estos campos 00:24:54
¿Cuál es el que podría servirnos 00:24:56
Para distinguir de forma unívoca el ítem? 00:24:58
Hombre, pues la descripción 00:25:00
La cantidad no, porque puede haber diferentes ítems 00:25:02
Con la misma cantidad 00:25:04
Y puede haber diferentes ítems con el mismo precio por unidad 00:25:06
Pero hombre, la descripción debería ser distinta en cada uno 00:25:08
Que aún así 00:25:10
Yo analizando el problema 00:25:12
Oye, no, pues tengo 00:25:14
A lo mejor ítem que se puede llamar igual 00:25:16
Pues me invento un campo adicional 00:25:18
Que se llame código, por ejemplo, me lo invento 00:25:20
Y ese ya sí que esfuerzo a que sea distinto en todos 00:25:22
Luego es muy parecido 00:25:24
El diseño de bases de datos y el diseño de clases 00:25:26
Las mismas cosas que tienen en cuenta unos 00:25:28
Tienen en cuenta otros 00:25:30
La diferencia es que en las bases de datos 00:25:32
Hay restricciones que son obligatorias 00:25:34
Y que si no las satisfaces 00:25:36
Luego las consultas en SQL te petan 00:25:38
Aquí nadie te obliga 00:25:40
A hacer algo que sea una clave primaria 00:25:42
Pero hombre, es recomendable 00:25:44
Bueno, pues en nuestro caso 00:25:46
Suponemos que la descripción 00:25:48
Va a ser diferente 00:25:50
Para todos los objetos ítem 00:25:52
Suponemos 00:25:54
Repito, porque si no lo es 00:25:56
Entonces voy a inventarme un campo código 00:25:58
Un ID como que ya asegure 00:26:00
Que me permite distinguir unos de otros 00:26:02
Pero no vamos a inventar ese campo adicional 00:26:04
Bueno, pues entonces 00:26:06
Si la descripción es lo que distingue 00:26:08
Unívocamente a un ítem de otro 00:26:10
Es lo que lo distingue, es como su clave primaria 00:26:12
Pues este método 00:26:14
De eliminar ítem 00:26:16
Tiene sentido 00:26:18
Que lo que me pasen 00:26:20
Desde fuera para decir 00:26:22
Cual tengo que eliminar 00:26:24
Sea precisamente ese campo de descripción 00:26:26
Y esto será 00:26:28
Oye, elimíname 00:26:30
De este array 00:26:32
Elimíname de este array 00:26:34
El ítem 00:26:36
Que tenga 00:26:38
Que se llame así 00:26:40
Que se llame descripción 00:26:42
Elimíname ese, no tiene sentido 00:26:44
Que sea esa la información que venga desde fuera 00:26:46
Vale, elimíname este 00:26:48
Bueno, pues 00:26:50
El parámetro ya lo tenemos resuelto 00:26:52
Ahora, me tiene que devolver algo 00:26:54
Este método 00:26:56
No, porque el efecto es dejar el array modificado 00:26:58
Dejar el array con un ítem menos 00:27:00
Dejarlo con un ítem menos 00:27:02
El efecto del método 00:27:04
Ya se queda aquí recogido 00:27:06
Porque este array se quedará con un elemento menos 00:27:08
Entonces, como el efecto del array 00:27:10
Ya se queda ahí recogido 00:27:12
Pues, le devuelvo aquí un gol 00:27:16
Y ahora ya, este método 00:27:18
Eliminará 00:27:22
Elimina, lo que tiene que hacer 00:27:24
Es eliminar del array 00:27:26
Del array 00:27:30
Ítems pedido 00:27:32
Ítem 00:27:40
Cuya 00:27:42
Descripción 00:27:44
Se corresponda 00:27:48
Con la pasada como parámetro 00:27:50
Vale, vamos a dejar 00:27:58
Pues este método ya 00:28:00
Trabajará con el array eliminando 00:28:02
Aquí en blanco, para que lo hagáis 00:28:04
En casa, como ejercicio 00:28:06
Vale, cuando este método esté 00:28:08
Pues ya se llamará eliminar pedido 00:28:10
Pasándole eliminar bolis 00:28:12
Y ya está, desaparecerán los bolis 00:28:14
De los ítems del pedido que llame a ese método 00:28:16
Bueno 00:28:18
Vale, y así uno sigue 00:28:20
Metiendo los métodos que le interesan 00:28:22
Vale, pues ahora 00:28:24
A través de otra cuestión que vamos a plantear 00:28:28
De otra necesidad 00:28:30
Es decir 00:28:32
Un concepto nuevo que necesitamos 00:28:34
De programación de entrada de objetos 00:28:38
Vale, pues vamos a plantear 00:28:40
La siguiente situación 00:28:42
Resulta que 00:28:44
Esta aplicación 00:28:46
El cliente me dice 00:28:48
Oye, que también quiero trabajar con IVA 00:28:50
Por ejemplo 00:28:52
Quiero poder calcular precios con IVA 00:28:54
Y sin él 00:28:56
Porque aquí el precio que me has dado 00:28:58
Con los ítems 00:29:00
Pero yo quiero también tener la opción de devolver el precio 00:29:02
Incluyendo un IVA 00:29:04
Vale, entonces, bueno, esta aplicación 00:29:06
Entonces le falta algo 00:29:08
Le falta algo porque este método 00:29:10
Devuelve la suma de precios 00:29:12
De los ítems 00:29:14
Pero no está teniendo en cuenta de ninguna manera 00:29:16
Algo como IVA 00:29:18
Bueno, entonces el usuario me dice esto 00:29:20
El cliente, perdón 00:29:22
Y yo ya empiezo a analizarlo 00:29:24
Y empiezo a pensar 00:29:26
Empiezo a analizarlo 00:29:28
Y empiezo a pensar 00:29:30
Digo, vale 00:29:32
Primera pregunta 00:29:34
¿El IVA va a ser igual 00:29:36
Para todos los pedidos de tu aplicación? 00:29:38
¿Va a ser el mismo? 00:29:40
¿Para todos los productos de tu empresa 00:29:42
Todos reciben el mismo IVA? 00:29:44
Vamos a suponer 00:29:48
Que el cliente me ha dicho que sí 00:29:50
Que me ha dicho que sí 00:29:52
Me dice, sí, sí, sí 00:29:54
Todos mis productos son de tipo tal 00:29:56
Y todos reciben el mismo IVA 00:29:58
Todos el mismo 00:30:00
Otra cosa es que el IVA pueda cambiar 00:30:02
En función, pues, del año 00:30:04
La legislación, que el IVA pueda cambiar 00:30:06
Pero todos reciben el mismo IVA 00:30:08
Bueno, pues entonces 00:30:10
¿En qué situación estamos? 00:30:12
Estamos en la situación de que IVA 00:30:14
Llamémosle IVA sin más 00:30:16
Esto 00:30:18
Que es una variable 00:30:20
Es una variable porque me ha dicho 00:30:22
Oye, yo no quiero asumir 00:30:24
De partida que el IVA es 16 o 20 00:30:26
No, puede ser que cambie 00:30:28
Puede ser que cambie de un mes para otro 00:30:30
Puede ser, entonces 00:30:32
Primera cosa que nosotros ya concluimos 00:30:34
Como diseñadores de la aplicación 00:30:36
Esto es una variable 00:30:38
En algún día tiene que estar 00:30:40
Pero es una variable porque no tiene valor fijo 00:30:42
¿Va a cambiar? 00:30:44
Vale, es una variable 00:30:46
Primera cosa la que hemos concluido 00:30:50
Primera cosa que concluimos 00:30:52
O que intentamos concluir 00:30:54
¿Es una variable? ¿Dónde la coloco? 00:30:56
¿Dónde la coloco? 00:30:58
Bueno, pues lo primero que tengo que pensar 00:31:00
Para ver dónde coloco yo una variable o un método 00:31:02
Es con qué está relacionado 00:31:04
Dentro de las entidades de mi aplicación 00:31:06
¿Con qué está relacionado el IVA? 00:31:08
Bueno, el IVA está relacionado con los precios de los pedidos 00:31:10
Luego está relacionado con pedidos 00:31:12
O sea, el IVA no está relacionado con 00:31:14
Imaginaos que esta aplicación además tiene 00:31:16
Clientes registrados 00:31:18
Que son los que hacen pedidos 00:31:20
El IVA no está relacionado con los clientes 00:31:22
El IVA está relacionado 00:31:24
Con los pedidos 00:31:26
Luego es una variable 00:31:28
Relacionada con los pedidos 00:31:30
Porque afecta a los precios de los pedidos 00:31:32
¿Está relacionada con? 00:31:34
Significa a quién afectas 00:31:36
¿A quién afectas tú? ¿A quién afecta el IVA? 00:31:38
El IVA afecta a los pedidos 00:31:40
Vale, pues entonces su sitio 00:31:42
Sería la clase pedido 00:31:44
Entonces, con eso que yo he dicho 00:31:46
Se plantaría aquí, diría 00:31:48
IVA, vamos a suponer que lo queremos entero siempre 00:31:54
Ay, perdón, perdón, perdón 00:31:58
Que estoy en la clase que no era 00:32:00
Perdón, en pedido 00:32:02
Porque está relacionado con los pedidos 00:32:04
Vale 00:32:06
Venga, pues entonces 00:32:08
Vamos a suponer 00:32:10
Que es entero 00:32:12
Y le vamos a dar un nombre 00:32:14
Un nombre mismo 00:32:16
Vale 00:32:18
Entonces 00:32:20
Esto cumple lo de que es una variable 00:32:22
Y que yo le puedo cambiar cuando me dé la gana 00:32:24
Vale 00:32:26
Me faltaría añadir el get y el set 00:32:28
Poner el constructor 00:32:30
Todo eso me faltaría 00:32:32
Pero lo voy a incorporar todavía 00:32:34
Porque vamos a 00:32:36
A seguir viendo cosas 00:32:38
Vale, entonces es una variable 00:32:40
Puede cambiar de valor 00:32:42
Y está relacionada con pedidos 00:32:44
Luego va aquí 00:32:46
Bueno, vale 00:32:48
Vale, pero es que entonces yo ahora miro esto y digo 00:32:50
A ver, pero el 00:32:52
Que me ha pedido el software, el cliente me ha dicho 00:32:54
Que todos los pedidos 00:32:56
Van a tener el mismo 00:32:58
Todos los pedidos van a tener el mismo IVA 00:33:00
Tal y como está aquí colocado 00:33:02
Esto es una propiedad 00:33:04
Diferente para cada 00:33:06
O puede ser una propiedad diferente para cada objeto, verdad 00:33:08
Es decir, si yo tengo 00:33:10
Un pedido 1, desde un main cualquiera 00:33:12
Este de aquí 00:33:14
Que por ahora vamos a dejar aquí vacío 00:33:16
Un main que tengo aquí 00:33:18
Lo vamos a dejar vacío 00:33:20
Este main 00:33:22
O sea, si yo tengo un pedido aquí, ahora ya en mi main 00:33:24
Pedido P1, por ejemplo 00:33:28
New pedido 00:33:32
Pues este pedido tendrá 00:33:34
Su propio valor 00:33:36
En la variable IVA, verdad, su propio valor 00:33:38
Como está sin inicializar, pues cero 00:33:40
Pero yo se lo podría cambiar luego a través del set 00:33:42
Como fuera 00:33:44
Que tengo aquí otro pedido P2 en mi main 00:33:46
New pedido 00:33:50
Pues este pedido P2 es otro objeto que tendrá 00:33:52
Su otra copia de IVA 00:33:54
Que tengo en mi aplicación 00:33:56
27.000 pedidos que podría tener 00:33:58
Mi aplicación metiendo pedidos 00:34:00
En un conjunto de pedidos 00:34:02
Pues cada pedido tiene su propia copia 00:34:04
De la variable IVA 00:34:06
27.000 copias 00:34:08
De esta variable 00:34:10
27.000 copias de esta 00:34:12
Tiene sentido 00:34:14
Tiene sentido tener 27.000 copias de código 00:34:16
Porque cada pedido tiene su código, obviamente 00:34:18
Y tiene sentido tener 27.000 copias 00:34:20
De descripción, porque cada pedido tiene su descripción 00:34:22
Y tiene sentido tener 00:34:24
27.000 copias de este array 00:34:26
Porque cada pedido tiene su array 00:34:28
Pero tiene sentido tener 27.000 copias de IVA 00:34:30
Cuando el cliente me ha dicho que todos los pedidos 00:34:32
Tienen el mismo 00:34:34
Si es 16 lo es para todos 00:34:36
Y si es 20 lo es para todos 00:34:38
¿Tiene sentido? 00:34:40
Bueno, tiene sentido 00:34:42
Bueno, pues por situaciones como esta 00:34:44
Se incorpora el concepto 00:34:46
De variable estática, que se llama 00:34:48
Que es una variable 00:34:50
Que está en una clase 00:34:52
Cuyo valor es compartido 00:34:54
Por todos los objetos de la clase 00:34:56
Es decir 00:34:58
La idea es esta 00:35:00
La idea es esta 00:35:02
Tu tienes una clase 00:35:04
Pedido como esta 00:35:06
Y vamos a instanciar objetos 00:35:08
Pues si tu instancias el objeto 00:35:10
Pues este objeto tiene 00:35:12
Sus propiedades 00:35:14
Pues tiene su propiedad código 00:35:16
Vale 00:35:18
Tiene su propiedad descripción 00:35:20
Vale, vamos a olvidarnos de la propiedad array 00:35:22
Para no escribir tanto 00:35:24
Y con lo que yo he escrito ahí 00:35:26
Tendría su propiedad IVA 00:35:28
Vale, este sería mi pedido 00:35:30
P1, ala, ahí 00:35:32
La propiedad array además que no he escrito 00:35:34
Ahora, me hago mi pedido 00:35:36
P2, en mi main 00:35:38
Pues ala, aquí tengo mi otro pedido 00:35:40
P2, este 00:35:42
Y este de nuevo 00:35:44
Tendrá 00:35:46
Sus tres propiedades 00:35:48
Más el array 00:35:50
Que estaría por ahí, que no la pongo 00:35:52
Para no escribir tanto 00:35:54
Su propiedad código 00:35:56
Su propiedad 00:35:58
Descripción 00:36:02
Y su propiedad 00:36:04
IVA 00:36:06
Con el modelo que yo he hecho 00:36:08
Así están las cosas 00:36:10
Cada uno tiene su código 00:36:12
Descripción e IVA 00:36:14
Vale, que tengo treinta mil 00:36:16
Como este, pues ala 00:36:18
Cada uno tiene su código, descripción e IVA 00:36:20
Repito 00:36:22
Para el código y descripción 00:36:24
Es que tiene que ser así 00:36:26
Cada uno tiene el suyo propio 00:36:28
Vale, cada uno tiene el suyo propio 00:36:30
Tiene que ser así 00:36:32
Pero en esta situación concreta 00:36:34
Que me han planteado y me han dicho 00:36:36
Oye, perdona, que el valor del IVA 00:36:38
Sea el que sea, que irá cambiando 00:36:40
13, 12, va a ser el mismo para todos 00:36:42
Va a ser el mismo 00:36:44
Entonces que sentido tiene tener esto 00:36:46
Veinte mil copias de esa variable 00:36:48
Ninguno 00:36:50
Las puedo tener, pero vaya pérdida de tiempo 00:36:52
Bueno, pues para eso surge este concepto 00:36:54
Que decimos, y es 00:36:56
Pues vamos a cambiar esta propiedad, IVA 00:36:58
Y le vamos a poner un modificador 00:37:00
Aquí, estupendo, un modificador 00:37:02
Que 00:37:04
Se llama así 00:37:06
Static 00:37:08
Ala, le planto este modificador 00:37:10
Delante del tipo de dato 00:37:12
Vale, le planto ese modificador 00:37:14
Bueno, pues 00:37:16
Plantándole ese modificador 00:37:18
A una variable cualquiera de la clase 00:37:20
Que consigo 00:37:22
Que esa variable, automáticamente 00:37:24
Se convierte en una única variable 00:37:26
Como si fuera el concepto 00:37:28
De variable global, que no lo es 00:37:30
Ahora aclaremos porque no lo es 00:37:32
Compartida por todos los objetos 00:37:34
Todos acceden al mismo espacio 00:37:36
Compartido, que solo hay uno, único 00:37:38
Al ponerle el modificador 00:37:40
Static, la he convertido en una variable 00:37:42
De ese tipo, variable estática 00:37:44
Que implica esto que he dicho 00:37:46
Al ponerle el modificador 00:37:48
Static, esta variable mía de aquí 00:37:50
Ahora ya automáticamente 00:37:52
Desaparece de ahí 00:37:54
Desaparece 00:37:56
De ahí 00:37:58
Vale 00:38:00
Y ahora ya, hay 00:38:02
Una única variable 00:38:04
Aquí fuera, fuera de todo objeto 00:38:06
Fuera de todo objeto 00:38:08
Una única variable que se llama IVA 00:38:10
Se llama con ese nombre, esta 00:38:12
Y ahora 00:38:14
Todos los objetos 00:38:16
Su propiedad IVA 00:38:18
Esta estática, es como si 00:38:20
Apunta al mismo sitio, apunta aquí 00:38:22
Todos apuntan a la misma 00:38:24
Todos 00:38:26
Que yo tengo aquí otro objeto 00:38:28
P3 o los 200.000 00:38:30
Que a mí me den la gana 00:38:32
Que tengo otro objeto aquí 00:38:34
Vale, pues tendrá 00:38:40
Su propio código 00:38:42
Eso sí 00:38:44
Porque son variables normales 00:38:46
Propiedades normales 00:38:48
Su propia descripción 00:38:50
Pero su tercera propiedad 00:38:52
Esta de aquí 00:38:54
Su propio array, claro 00:38:56
Pero su propiedad IVA 00:38:58
No hay una nueva para él 00:39:00
Su propiedad IVA 00:39:02
Apunta automáticamente 00:39:04
A esta también 00:39:06
Luego 00:39:08
Me ahorro 00:39:10
De lo mismo 00:39:12
Y esto luego que implica 00:39:14
En términos de ejecución del programa 00:39:16
Que si yo la cambio 00:39:18
Esta propiedad a través del objeto P1 00:39:20
La cambio para todos 00:39:22
Porque es un espacio compartido 00:39:24
La cambio para todos 00:39:26
Vamos a verlo ahora en el main 00:39:28
Yo he cambiado aquí 00:39:30
Mi propiedad static y la he llamado 00:39:32
Así 00:39:34
Le he cambiado el modificador 00:39:36
Y le he puesto static 00:39:38
Pues como es privada 00:39:40
Para poder acceder a ella desde fuera 00:39:42
Sin el get 00:39:44
Le voy a poner public 00:39:46
¿Por qué? 00:39:48
Porque las propiedades estáticas 00:39:50
Las propiedades estáticas 00:39:52
No se les pone en get y set 00:39:56
Se les podría poner 00:39:58
Pero no se les pone en get y set 00:40:00
Como su concepto es distinto 00:40:02
Es como si fueran variables globales 00:40:04
Y directamente para quitar las cosas 00:40:06
Se las hace públicas 00:40:08
Y se accede a ellas tal cual 00:40:10
Se podría haber decidido usarlas de otra manera 00:40:12
Pero no, se sigue de nuevo 00:40:14
Como convenio de programación 00:40:16
Que las variables estáticas 00:40:18
No se accede a ellas a través de get y set 00:40:20
Sino directamente a la variable 00:40:22
Entonces por eso lo voy a hacer así 00:40:24
Le voy a cambiar el modificador 00:40:26
Y le pongo public 00:40:28
Y no pongo ni get ni set 00:40:30
Vale, entonces 00:40:32
Ahora, tengo mi variable estática 00:40:34
Pues voy a mi main 00:40:36
Voy a ponerle 00:40:38
Uy, ya tengo mis dos pedidos 00:40:42
Por ahora con las variables inicializar 00:40:44
Pues venga, voy a poner 00:40:46
A ver, un momento 00:41:02
¿Por qué no me deja acceder? 00:41:04
Ahora 00:41:08
Vale, pues entonces 00:41:10
Estoy accediendo a la propiedad ciba 00:41:12
A través del objeto P1 00:41:14
Puedo, no hay ningún problema 00:41:16
Porque la propiedad ciba 00:41:18
Está dentro de pedido 00:41:20
Entonces yo accedo a través de los objetos 00:41:22
Y como es public, puedo acceder a través del punto 00:41:24
Directamente a través del punto 00:41:26
No hace falta el get y el set, de hecho no los he hecho 00:41:28
Vale, entonces ¿qué estoy haciendo aquí? 00:41:30
Pues estoy poniendo un 4 aquí 00:41:32
Estoy poniendo un 4 en la zona compartida 00:41:34
Porque P1.iva es esto 00:41:38
P1.código es esto 00:41:40
Pero P1.iva es esto 00:41:42
Entonces ahora 00:41:44
Si yo accedo a través de cualquier otro objeto como P2 00:41:46
Voy a ver que tiene ese valor 00:41:48
Es decir, si yo ahora hago 00:41:50
Pues veré como me muestra el 4 00:41:58
Se ha accedido a través de P1 00:42:00
Pero he cambiado el valor para todos 00:42:02
Porque es compartida por todos 00:42:04
Es compartida 00:42:06
Esta propiedad ciba de aquí 00:42:08
No funciona como las otras 00:42:12
Si yo cambio el código de P1 00:42:14
Cambio solo el código de P1 00:42:16
Y el de P2 sigue siendo el suyo 00:42:18
Si cambio la descripción de P1 00:42:20
Cambio solo la de P1 00:42:22
La de P2 y P3 sigue siendo la suya 00:42:24
Pero si cambio el IVA de P1, cambio el IVA de todos 00:42:26
Porque al ser una propiedad estática 00:42:28
Es un espacio compartido común para todos 00:42:30
Vamos a comprobarlo aquí como yo le he dado 4 00:42:34
Y accediendo a través de P2 00:42:36
Me aparece el 4 00:42:38
Efectivamente 00:42:42
Y si yo ahora a través de P2 lo vuelvo a cambiar 00:42:44
Oye 00:42:46
P2.iva 00:42:48
Vamos a darle ahora 8 00:42:50
Y ahora lo voy a mostrar 00:42:52
Pero a través de P1 00:42:54
Pues efectivamente 00:42:58
Me va a salir 8 00:43:00
Primero el 4 anterior 00:43:02
Y luego el 8 00:43:04
Yo lo he cambiado a través de P2 00:43:08
Pero a través de P1 00:43:10
Se ha cambiado igual 00:43:12
Se ha cambiado igual 00:43:14
Se ha cambiado igual 00:43:16
Porque es un espacio compartido 00:43:18
Entonces las variables estáticas 00:43:20
Son variables compartidas 00:43:22
Por todos los objetos de una clase 00:43:24
A ver 00:43:26
No son variables globales 00:43:28
En términos de lo que se llama variables globales 00:43:30
En los lenguajes de pronunciación antiguos 00:43:32
En los lenguajes de pronunciación antiguos 00:43:34
Una variable global es una variable compartida 00:43:36
Por toda la aplicación 00:43:38
Las variables estáticas son solo compartidas 00:43:40
Por los objetos de una clase 00:43:42
De la clase en la que está 00:43:44
Si IVA está en pedido 00:43:46
Es una variable accesible 00:43:48
Y compartida por todos los objetos 00:43:50
De la clase pedido 00:43:52
Pero solo por los objetos de la clase pedido 00:43:54
Solo por eso 00:43:56
En ese sentido no es global 00:43:58
Es global pero para los objetos pedidos 00:44:00
Entonces está claro 00:44:04
Que si ponéis el modificador static 00:44:06
La variable sale 00:44:08
Del campo de propiedades 00:44:10
De cada objeto 00:44:12
Para ser una propiedad 00:44:14
Común para todos 00:44:16
Entonces yo accedo a ella 00:44:18
Para leer con cualquiera de los objetos 00:44:20
Porque yo llego al mismo lado 00:44:22
Bueno pues en este caso 00:44:26
Con lo recrito que me ha dado el cliente 00:44:28
El IVA tiene sentido que es una propiedad estática 00:44:30
Porque me han dicho 00:44:32
No sé cual va a ser 00:44:34
A veces es 16 a veces 12 00:44:36
Pero lo que sí que te puedo decir 00:44:38
Es que va a ser el mismo para todos 00:44:40
Bueno pues entonces hagamos la estática 00:44:42
Para que voy a tener yo una copia 00:44:44
En todos ellos 00:44:46
Si sé que es el mismo para todos 00:44:48
No es que me facilito el diseño 00:44:50
Sino que evito errores 00:44:52
Porque si el IVA cambia a 18 00:44:54
Con el modelo anterior yo tendría que irme en todos 00:44:56
Uno por uno a ponerlo a 18 00:44:58
Diseñado de esta manera 00:45:00
Poniendo 18 aquí 00:45:02
Ya lo he puesto en todos 00:45:04
¿Vale? 00:45:06
Luego esta es 00:45:08
La motivación 00:45:10
De la existencia de variables estáticas 00:45:12
Que luego esto nos abre 00:45:14
Un mundo ahí de posibilidades para hacer cosas 00:45:16
¿Vale? 00:45:18
Bueno pues en esta aplicación en la que estamos 00:45:22
Aquí por tanto 00:45:24
Que el IVA sea estático nos viene estupendo 00:45:26
Porque refleja exactamente lo que queremos 00:45:28
Nos viene estupendo que sea estático 00:45:30
¿Vale? 00:45:32
Entonces las variables estáticas 00:45:34
Como hemos comprobado 00:45:36
Como da exactamente igual 00:45:38
El objeto que los llame 00:45:40
Me da igual que lo llame p1.y 00:45:42
Como da exactamente igual 00:45:44
Las variables estáticas si uno quiere 00:45:46
Se las puede llamar directamente 00:45:48
Con el nombre de la clase 00:45:50
Ni siquiera ningún objeto en concreto 00:45:52
Ni siquiera ninguno 00:45:54
Si no con el nombre de la clase 00:45:56
Es decir si me vuelvo a mi main 00:45:58
Que está aquí 00:46:00
Me da igual hacer 00:46:02
p1.iva 00:46:04
p1.iva 00:46:08
Igual a 12 00:46:10
Que hacer 00:46:12
Es el nombre de la clase 00:46:14
p1.iva 00:46:16
Igual a 12 00:46:18
Es lo mismo 00:46:20
El resto de variables 00:46:22
Que no son estáticas 00:46:24
Nunca se las puede llamar con el nombre de la clase 00:46:26
Nunca 00:46:28
Hay que llamarlas con un objeto en concreto 00:46:30
Para decir oye de que objeto me estás hablando 00:46:32
Es decir el código 00:46:34
Yo nunca podría poner 00:46:36
Pedido 00:46:38
Punto código 00:46:40
Esta propiedad código está de aquí 00:46:42
Esta propiedad código 00:46:44
Pedido.código 00:46:46
Igual a lo que sea 00:46:48
El compilador me diría 00:46:50
El código de quien 00:46:52
De p1, de p2, de p3 00:46:54
Porque tengo muchos códigos 00:46:56
Tengo este, tengo este 00:46:58
Nunca me dejaría a una propiedad 00:47:00
Que no sea estática 00:47:02
Llamarla así con el nombre de la clase 00:47:04
Pero una propiedad que sea estática 00:47:06
Sí 00:47:08
Me da igual de quien sea iva 00:47:10
Me da igual que sea de p1, de p2 00:47:12
De p3, me da lo mismo 00:47:14
Porque es que es esta la única 00:47:16
Que hay, me da igual 00:47:18
Con lo cual el compilador nos deja llamarla 00:47:20
Con el nombre de la clase directamente 00:47:22
Y con esto decimos 00:47:24
Oye esta es la variable estática 00:47:26
Iva de la clase pedido 00:47:28
Pero la variable estática code de la clase pedido 00:47:32
No existe 00:47:34
Pero la variable estática iva sí 00:47:36
¿Vale? 00:47:40
Entonces 00:47:42
No sólo se puede 00:47:44
Acceder así sino que es lo recomendable 00:47:46
¿Vale? 00:47:48
Lo recomendable es 00:47:50
Acceder a 00:47:52
De hecho 00:47:54
El compilador ya te lo dice 00:47:56
Te dice 00:47:58
Mirad lo que dice 00:48:02
Cuando yo he accedido a la variable iva 00:48:04
A través del objeto p1 00:48:06
Me está diciendo 00:48:08
Me está diciendo 00:48:16
El campo estático iva 00:48:20
No sé si 00:48:24
Debería ser accedido 00:48:26
Debería para que lo hagas más bonito 00:48:28
Y no seas tan cutre 00:48:30
Debería ser accedido 00:48:32
De la manera estática 00:48:34
Pues la static way 00:48:36
Es esta de abajo con el nombre de la clase 00:48:38
A esto se refiere 00:48:40
Entonces lo único que está diciendo es 00:48:42
Oye que feo esto 00:48:44
Que accedas a una propiedad estática con un objeto 00:48:46
Accede con el nombre de la clase 00:48:48
Pero como da igual que accedas con este objeto 00:48:50
Con este, con este, con este 00:48:52
Pues accede con el nombre de la clase 00:48:54
Te avisa de eso 00:48:56
Ya que te pone accede bien 00:48:58
¿Vale? 00:49:00
De hecho 00:49:02
¿Me estáis siguiendo, no? 00:49:06
De hecho 00:49:10
Hay veces que ni siquiera 00:49:12
Se puede acceder con el nombre de un objeto 00:49:14
Porque no existen 00:49:16
Voy a borrar todo lo que hay en el main 00:49:18
Todo fuera 00:49:20
Vale 00:49:22
Vale, mi main está vacío 00:49:24
No hay nada 00:49:26
¿Qué variables tengo ahora? 00:49:28
¿Qué variables tengo? 00:49:30
Ninguna 00:49:32
Mi main está vacío, no tengo ninguna 00:49:34
Vale 00:49:36
Pues de repente voy a hacer esto 00:49:38
Pedido.iva 00:49:42
Igual a 12 00:49:44
¿Y esto? 00:49:48
Mirad que es mi única sentencia 00:49:50
Del programa 00:49:52
Y puedo hacerla 00:49:54
¿Qué significa esto? 00:49:56
La variable iva 00:49:58
Compartida por todos los objetos pedidos 00:50:00
Por todos 00:50:02
Ponla 12 00:50:04
Eso significa, con lo que yo he dicho 00:50:06
La variable iva compartida por todos los objetos pedidos 00:50:08
Ponla 12 00:50:10
Claro, entonces ahora me diríais 00:50:12
Pero si es que no hay ningún objeto pedido 00:50:14
¿Cuál es la variable compartida por todos los objetos pedidos? 00:50:16
Si es que no hay ninguno 00:50:18
Claro, es que las variables estáticas de una clase 00:50:20
Pueden existir incluso 00:50:22
Aunque no haya objetos de esa clase 00:50:24
Aunque no haya objetos 00:50:26
Es decir, esta variable 00:50:28
Puede existir 00:50:30
Aunque no exista ninguno de estos 00:50:32
Aunque yo los borre todos 00:50:36
Y los mande todos a la basura 00:50:38
Fuera 00:50:40
Esta variable de aquí 00:50:42
Sigue pudiendo existir 00:50:44
Y la pregunta natural sería 00:50:46
Oye, pero cuando aparece, cuando nace 00:50:48
Cuando nace esa variable 00:50:50
La primera vez que la uso 00:50:52
Es decir, aquí en este punto 00:50:54
Aquí todavía no hay nada 00:50:56
No hay nada en la memoria 00:50:58
Yo accedo por primera vez 00:51:00
A esta variable estática 00:51:02
En el modo estático 00:51:04
Claro, no tengo otro porque no hay ningún objeto pedido 00:51:06
Pues la primera vez que accedo a ella 00:51:08
Plaz, nace, apareció 00:51:10
Apareció en memoria 00:51:12
Esta variable 00:51:14
Iva 00:51:16
Asociada a los objetos pedidos 00:51:18
Cuando los haya, que todavía no hay ninguno 00:51:20
Apareció y ya está ahí 00:51:22
Ya sé que hay para siempre 00:51:24
Y ya está 00:51:26
Esto es lo que se llama hacer nacer el contexto estático 00:51:28
De una clase 00:51:30
O sea, el contexto estático de una clase 00:51:32
Y todas las variables estáticas que tiene 00:51:34
Pues las variables estáticas 00:51:36
De una clase aparecen 00:51:38
La primera vez que yo las uso 00:51:40
Por ejemplo aquí, ala, apareció 00:51:42
Y ya está esa variable 00:51:44
Y no hay ningún objeto 00:51:46
Que ahora yo creo un objeto 00:51:48
No pasa nada 00:51:50
Ahora creo un objeto pedido p 00:51:52
Venga, igual a new pedido 00:51:54
Bueno, pues este 00:51:56
Objeto que yo acabo de crear 00:51:58
Su propiedad iva 00:52:00
Es esta, la estática que ya existe 00:52:02
De antes, la compartida por todos 00:52:04
Y según vayan apareciendo 00:52:06
Objetos nuevos 00:52:08
Su propiedad iva será esa estática 00:52:10
Compartida por todos 00:52:12
De hecho, si yo quisiera hacer ahora 00:52:14
p.iva 00:52:16
La propiedad iva a través de p 00:52:18
Veré que me va a dar 12 00:52:20
Y el objeto no existía todavía 00:52:22
Cuando yo le di valor, no existía 00:52:24
¿Veis? 00:52:30
Es 12, o sea, este objeto pedido p 00:52:32
Que ha aparecido 00:52:34
Su propiedad iva es esta estática 00:52:36
La compartida por todos 00:52:38
¿Vale? Pero esa propiedad estática 00:52:40
Puede nacer incluso antes 00:52:42
De que aparezcan los objetos, no pasa nada 00:52:44
Y nacerá la primera vez 00:52:46
Que yo la invoque así 00:52:48
De esta manera, así nacerá 00:52:50
¿Vale? 00:52:52
Bueno, pues muy importante 00:53:00
Entender esto bien 00:53:02
¿Vale? Muy importante entender 00:53:06
Que una clase puede tener una o 00:53:08
Muchas variables estáticas 00:53:10
Una o muchas, todas las que hagan falta 00:53:12
Y esas variables son 00:53:14
Variables 00:53:16
Comunes, compartidas 00:53:18
Por todos los objetos de la clase 00:53:20
Cuando esos objetos existan 00:53:22
¿Vale? 00:53:26
Y luego para acceder a esas variables, por tanto 00:53:28
No hace falta acceder con un objeto concreto 00:53:30
No hace falta, pero como es compartido 00:53:32
Por todas, no hace falta, puedo acceder 00:53:34
Con el nombre de la clase y ya está 00:53:36
¿Vale? Y también importante entender 00:53:40
Que esas variables pueden existir 00:53:42
Aunque no existan objetos 00:53:44
No hace falta que existan objetos 00:53:46
Tienen existencia propia 00:53:48
¿Vale? Pero todos los objetos 00:53:50
Que aparezcan después estarán asociados 00:53:52
A esa 00:53:54
¿Vale? 00:53:58
Vale, vamos a parar aquí un momentito 00:54:02
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
6
Fecha:
16 de enero de 2024 - 12:47
Visibilidad:
Público
Centro:
IES ROSA CHACEL
Relación de aspecto:
1.78:1
Resolución:
1280x720 píxeles
Tamaño:
1.00

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid