Saltar navegación

20251216 AppClientesPedidos_6 - 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 diciembre de 2025 por Raquel G.

3 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, pues ¿qué habréis hecho? 00:00:00
Dato de entrada, el código del pedido, vale, código del pedido he leído. 00:00:04
Entonces, dime, ¿qué le pasa al código? 00:00:10
Se está generando, no lo estamos generando automáticamente, lo estamos generando automáticamente cuando instanciamos un pedido. 00:00:17
En agregar pedido, ¿dónde está? En agregar pedido, ¿qué llamamos agregar pedido? ¿Desde dónde llamamos agregar pedido? 00:00:25
Desde aquí 00:00:49
¿Vale? ¿Ves? 00:00:51
El código lo estamos generando 00:00:53
Automáticamente en la aplicación 00:00:55
Generamos uno e incrementamos para el siguiente 00:00:57
O sea, los códigos van a ir siendo 00:01:00
0, 1, 2, 3 00:01:01
Que van a estar ahí intercalados 00:01:03
¿Vale? Pues a ver 00:01:04
Entonces 00:01:07
Dato de entrada 00:01:09
Dato de entrada 00:01:10
Pedimos el código del pedido 00:01:13
Silencio 00:01:14
Hasta ahí bien 00:01:17
Ahora de nuevo esta parte es una parte para decir lo puedo haber encontrado y lo muestro o puedo no haberlo encontrado, entonces un Boolean sobre si lo he encontrado o no que menos, un Boolean para ver si lo he encontrado o no para en el caso de no haberlo encontrado avisar, porque si no la aplicación se va a quedar callada, hay que intentar que la aplicación sea también lo más amigable posible. 00:01:18
Entonces, como esta opción se trata de encontrar algo o no encontrarlo, 00:01:40
pues al menos a través de un Boolean distinguir si lo he encontrado o no. 00:01:45
Pues venga, este va a ser mi Boolean para ver si he encontrado ese pedido o no. 00:01:49
De tal forma que si después del for de búsqueda no lo he encontrado, 00:01:54
me dirá no existe. 00:01:57
Vale. 00:01:58
Y ahora, ¿dónde tenemos que buscar el pedido? 00:02:00
Ese pedido hay que buscarlo en mi array de clientes. 00:02:02
Cuidado que aquí he puesto un punto length 00:02:06
Lógicamente que este estaría mal 00:02:08
Esto tendría que ser 00:02:10
Así 00:02:11
Vale, entonces mi pedido lo voy a buscar 00:02:13
En mi array de clientes 00:02:16
Vale 00:02:18
Entonces lo que ocurre es que aquí 00:02:19
Buscar el pedido 00:02:22
En mi array de clientes 00:02:24
Pues implica 00:02:26
Meterme en 00:02:28
Clientes de i 00:02:29
Sacar sus pedidos 00:02:31
Iterar con otro for 00:02:33
para ver si alguno de esos pedidos 00:02:35
su código es igual que me han dado 00:02:38
vale, no pasa nada, puedo empezar a engordar 00:02:39
a partir de aquí, pero desde el momento 00:02:42
en que ya empiezo a anidar for 00:02:44
ya el código se queda muy feo 00:02:45
muy poco vistoso, pues de nuevo 00:02:47
ojalá 00:02:50
tuviéramos un método 00:02:51
que para el cliente 00:02:53
clientes 00:02:56
de i 00:02:58
pues yo le digo 00:02:58
localiza pedido, pasado el código 00:03:01
y me devuelve ese pedido 00:03:03
qué suerte, ojalá si yo tuviera 00:03:05
un método 00:03:09
que dado un objeto cliente 00:03:11
si yo le paso un código 00:03:14
me devuelve el pedido con ese código 00:03:16
null si no está, por tanto 00:03:20
entonces si yo este método lo tuviera 00:03:22
magnífico, porque lo llamo 00:03:25
y obtengo el pedido con ese código 00:03:27
si p es igual a 00:03:31
Null, es que no está, pero si p es distinto de null, lo acabo de encontrar. 00:03:35
Entonces ya aviso de que lo he encontrado. 00:03:42
Para que ya el bucle no vuelva a entrar. 00:03:46
Encontrado igual a true. 00:03:50
Aquí ya como los códigos son únicos, ese pedido solo lo habrá hecho una persona. 00:03:52
Y ahora ya, ¿qué es lo único que me falta? 00:03:58
Pues mostrar, mostrar los datos de ese cliente que tiene ese pedido. 00:04:00
Pues aquí lo que quiera yo mostrar. 00:04:03
el cliente que lo ha pedido 00:04:05
pues es este, clientes de ahí 00:04:08
vale, pues mi main se queda 00:04:10
ahora ya un poquito más cómodo y más corto 00:04:14
a falta de hacer 00:04:17
este método 00:04:19
vale 00:04:19
repito, pedimos el dato de entrada 00:04:21
como se trata 00:04:25
de encontrar o no encontrar, pues hombre 00:04:26
vamos a hacer la aplicación mínimamente amigable 00:04:28
distinguiendo si lo he encontrado 00:04:31
o no, para poder avisar 00:04:33
vale, pues de partida 00:04:34
no lo he encontrado 00:04:37
Ahora recorro todos mis clientes 00:04:37
Y ahora para cada cliente 00:04:40
Para cada cliente voy a ver 00:04:42
Si su pedido existe o no existe 00:04:44
A la hora de crearlo 00:04:45
Pero esta funcionalidad 00:04:53
Que es buscar por código 00:04:54
Sí, porque esta es otra funcionalidad distinta 00:04:56
Hombre, pero si lo puedes saber 00:04:58
Imagínate la situación real 00:05:05
A ti, tú estás en la tienda 00:05:06
Y te viene uno 00:05:08
Y te hace un pedido de bolis 00:05:10
y él solo lo único que te dice es quiero 00:05:11
bolis, entonces tú metes bolis precio 00:05:14
y el código se genera 00:05:16
pues ya está, tú tienes ahí tu albarán 00:05:18
el que tú le das al proveedor con el código 00:05:20
y entonces ahora ya pues de repente 00:05:21
ese proveedor te dice, oye me has dado un pedido 00:05:24
con código tal, que ese dato ya es tuyo 00:05:26
lo has generado y lo siento 00:05:28
no lo tengo, entonces tú te has encontrado 00:05:30
con un pedido de código 7 00:05:32
y tienes que localizar al cliente 00:05:33
para decirle, perdona es que no está 00:05:36
claro, no, no, esta funcionalidad 00:05:38
hace es para el que gestiona 00:05:43
la aplicación. O sea, 00:05:45
no es para el cliente. 00:05:47
Este registra al cliente, 00:05:49
le hace pedidos, el que 00:05:52
está, digamos, en el mostrador. 00:05:53
¿Vale? 00:05:55
Vale, pues entonces, si tuviéramos este método 00:05:56
localiza pedido, que le 00:05:59
pasamos un código y 00:06:01
para ese cliente me devuelve el 00:06:03
pedido con ese código. Si no existe, nul. 00:06:05
Me devuelve nul. Porque 00:06:07
lo había creado de antes. Lo normal es que 00:06:10
me diera error. ¿Vale? Pero lo he creado ahora 00:06:12
mientras estabais ahí entretenidos 00:06:14
vale, pues este método 00:06:16
tendría que ir en clientes 00:06:18
y sería este 00:06:20
de aquí abajo, sería este 00:06:22
recibe un entero, que es el código 00:06:27
devuelve un objeto pedido 00:06:29
y ahora ya 00:06:32
pues claro, este es el pedido 00:06:34
que voy a devolver 00:06:37
el pedido que voy a devolver en mi return 00:06:38
el que voy a devolver 00:06:41
inicialmente null, vale 00:06:43
Ahora, si pedidos fuera igual a null 00:06:45
No tengo nada que hacer 00:06:49
Si el cliente no tiene pedidos 00:06:51
Es imposible que tenga ese pedido 00:06:52
Retorno al null directamente 00:06:54
Pero en el caso de que pedido sea diferente de null 00:06:56
Y solo en el caso de que pedido sea diferente de null 00:07:00
Ahora sí, recorro los pedidos del cliente 00:07:03
Y si encuentro alguno con ese código 00:07:06
¡Hala! Ya tengo la variable resultado 00:07:09
¿Vale? 00:07:12
Pues este método es un método que hace esa cosa muy concreta. Dado un código, recorre la raíz de pedidos de ese cliente. En cuanto encuentra uno con ese código, ya actualiza el resultado. Y cuando él fuera terminado, devuelve el return. 00:07:13
entonces return 00:07:29
o bien será null 00:07:31
que puede ser null 00:07:32
¿en qué situación? 00:07:35
porque pedidos fuera null 00:07:36
con lo cual no entra en el if 00:07:37
luego el resultado se queda null 00:07:39
o puede ser null porque pedido siendo 00:07:41
diferente de null, este for nunca 00:07:44
entró aquí, porque no encontró el pedido 00:07:46
nunca entró aquí, pues result seguirá siendo null 00:07:48
¿cuándo no va a ser null? 00:07:50
cuando la array es 00:07:53
diferente de null y además 00:07:54
existe un pedido con ese código 00:07:56
Solo en ese caso me va a devolver 00:07:58
Ese objeto pedido 00:08:01
Vale 00:08:02
Pues ya está 00:08:04
Tengo este método que me hace esa cosa muy concreta 00:08:06
Y ahora ya lo uso siempre que quiera 00:08:09
Siempre que quiera 00:08:10
Recuperar por código 00:08:12
El pedido de un cliente con todos sus datos 00:08:15
¿Vale? Es un método que puede ser útil 00:08:17
Para muchas cosas 00:08:21
El cliente me hace una consulta 00:08:22
O lo que sea, cualquier cosa 00:08:25
Y quiero yo, a ver, este pedido 00:08:26
¿Pero cuánto costaba este pedido? 00:08:28
Pues, llamo para este cliente a su método localice apellido con 00:08:30
un código y me da los datos de ese pedido. 00:08:34
Entonces, puede ser útil para muchas cosas. 00:08:36
En particular, nos ha venido bien para no anidar tanto for aquí 00:08:38
dentro. 00:08:43
Porque si no, tendría que yo hacer aquí dentro el for otra 00:08:46
vez. 00:08:51
Tendría que hacer a que podría, ¿vale? 00:08:52
No pasa nada, pero es que ya me empieza a quedar un mail un 00:08:53
poco insoportable. 00:08:55
¿Vale? 00:08:58
Y la idea de la programación de todos los objetos, precisamente, 00:08:59
es no hacer programas enormes 00:09:01
sino 00:09:04
modularlos, modulables 00:09:05
separarlos en partes 00:09:07
¿vale? pues ya está 00:09:08
navegamos por todos 00:09:11
los clientes, para cada 00:09:13
cliente localizamos pedido con este 00:09:15
código, si no es 00:09:17
null, lo acabamos de encontrar 00:09:19
lo marcamos y ya 00:09:21
mostramos 00:09:23
¿vale? entonces 00:09:24
habréis hecho lo mismo 00:09:29
pero a lo mejor en lugar de con un método auxiliar 00:09:31
habréis metido aquí otro for 00:09:34
que recorre los pedidos de clientes de ahí. 00:09:36
Otro for ahí dentro. 00:09:39
Yo en lugar de meter ese for ahí dentro 00:09:41
pues lo he sacado a ese método 00:09:43
y así ya se queda un método útil 00:09:45
para ambas cosas. 00:09:48
¿Vale? 00:09:56
Lo que he hecho yo o lo que habéis hecho vosotros. 00:09:56
¿Está claro? 00:10:00
El método localiza pedido. 00:10:05
Este, por ejemplo. 00:10:08
este es el 00:10:16
esto va después del for 00:10:20
puedo poner la llave por si se queda más claro 00:10:21
¿qué te dice? 00:10:24
porque te falta el return 00:10:38
hay alguna rama que no está contemplada 00:10:39
vale, pues entonces 00:10:42
para completar con una 00:10:47
con los métodos static ahora ya sabemos 00:10:49
lo que son las variables static 00:10:51
ya sabemos lo que significan 00:10:53
Pues que existan propiedades static 00:10:54
Automáticamente implica 00:10:58
Que pueden existir 00:11:00
Métodos static 00:11:02
Que nos abre, eso ya sí que sí nos abre 00:11:03
Un mundo de posibilidades 00:11:06
Para nuestros programas 00:11:08
Maravilloso, mucho más cómodo 00:11:10
Pues venga 00:11:12
Vamos a añadir aquí una funcionalidad 00:11:14
Muy facilita de hacer 00:11:15
Que es 00:11:17
Vamos a añadir una 00:11:19
Que es 7 00:11:23
Bueno, esta 8 que es súper retorcida 00:11:27
Esta 8 que es súper retorcida 00:11:30
Se queda pendiente 00:11:36
Vamos a añadir una 9 00:11:37
La 8 está sin hacer 00:11:40
Voy a añadir aquí una funcionalidad 9 00:11:42
Que es pues cambiar el IVA 00:11:46
Porque resulta que el IVA ha cambiado 00:11:49
Y yo tengo que poder cambiarlo desde mi aplicación 00:11:50
Sin tener que meterme en el código 00:11:56
Recompilarlo 00:11:57
cambiar el IVA, pues venga, vamos a hacer esta funcionalidad 00:11:58
caso 1, caso 2, 3, 4, 5 00:12:03
6, 7, el 8 se ha quedado sin hacer 00:12:08
vale, el 8 no hace nada 00:12:13
por ahora, y vamos al 9 00:12:19
vale, pues aquí habría que pedir el nuevo valor 00:12:22
nuevo valor del IVA 00:12:34
Pues venga, aquí nos lo ponen, como hemos dicho que es un double. 00:12:40
Entonces aquí, con hacer esto, ya lo tendríamos, ¿verdad? 00:12:57
Con hacer esto ya está, esta es la variable estática que tiene esa información 00:13:13
a la que accedo a través del nombre de la clase donde está declarada. 00:13:17
Vale, pero vamos a suponer que actualizar el IVA, es decir, esta sentencia de aquí, 00:13:28
aunque es metido un poco así forzado 00:13:36
vamos a suponer que actualizar el IVA 00:13:39
implicará hacer más cosas 00:13:42
pues como conectarse con no sé qué 00:13:43
para validar algo 00:13:46
o mostrar aunque fuera un mensaje 00:13:47
voy a hacer mostrar un mensaje 00:13:49
para que hubiera que hacer más cosas 00:13:50
entonces vamos a hacerlo a través de un método 00:13:53
es decir, esto que en lugar de hacerlo así 00:13:55
vamos a hacerlo a través de un método 00:13:57
¿vale? 00:14:00
entonces el método que modifica esta propiedad IVA 00:14:02
el método que la modifica 00:14:05
tendrá que estar en pedido 00:14:07
porque en pedido es donde está esta propiedad 00:14:08
vale 00:14:11
pues entonces voy a hacer aquí en pedido 00:14:12
un método que modifica esta propiedad 00:14:14
como si fuera un set 00:14:17
igual que si fuera un set 00:14:18
y que además hace más cosas 00:14:20
vale, pues venga, me voy a hacer aquí el método 00:14:22
que modifica el IVA 00:14:25
entonces, este método 00:14:26
pues public 00:14:28
no devuelve nada 00:14:31
porque su efecto ya está en el IVA 00:14:33
modifica 00:14:35
iba 00:14:38
nuevo valor, hay que pasárselo por parámetro 00:14:39
claro 00:14:42
y ahora, este método haría 00:14:42
iba igual 00:14:46
a iba 00:14:48
uy, perdón, vale 00:14:49
haría esto 00:14:54
y además, para que sea un método 00:14:55
comunicando 00:14:58
cambios o cualquier 00:15:01
cosa, vale 00:15:02
bueno, pues aquí tengo un método 00:15:08
normal y corriente, no hace nada 00:15:11
distinto a lo que ya conocemos 00:15:13
recibe un parámetro de fuera 00:15:14
con ese parámetro actualiza una variable 00:15:16
de la clase, esta en particular 00:15:19
actualiza una variable 00:15:21
y hace más cosas, vale 00:15:23
pero este método, aunque así está bien hecho 00:15:24
y no hay ningún problema 00:15:27
nos damos cuenta de que tiene algo especial 00:15:28
¿qué tiene de especial? 00:15:33
que las únicas propiedades 00:15:37
que toca de la clase 00:15:39
en la que está 00:15:41
son estáticas. 00:15:41
Es decir, vamos a ponerlo aquí. 00:15:44
El siguiente método, este de aquí abajo, 00:15:49
solo utiliza propiedades estáticas de la clase. 00:15:52
¿Verdad? 00:16:02
Primera cosa de la que nos damos cuenta. 00:16:06
No utiliza ni descripción, ni código, ni precio. 00:16:08
La clase pedido tiene descripción, código y precio, 00:16:13
e iba y esta 00:16:16
solo utiliza la estática, la común 00:16:18
solo utiliza la información común, no utiliza 00:16:21
ni código, ni precio, ni descripción 00:16:22
¿qué significa que el método 00:16:24
sea estático? 00:16:26
perdón, que solo use una propiedad estática 00:16:28
significa que este 00:16:31
método da igual el objeto 00:16:33
que lo llame, me da igual que lo llame 00:16:35
C1, que lo llame C2, que lo llame C3 00:16:37
porque este método 00:16:39
lo único que 00:16:41
toca es una propiedad que es común para todos 00:16:43
Entonces, vale, vale, imaginaos que tenemos, pues eso, tres objetos, el pedido 1, pedido 2 y pedido 3, con sus tres propiedades, código de inscripción y precio, luego además tenemos la IVA esta, que es común para todos, común, esto es lo que tenemos, vale 00:16:45
entonces resulta que este método 00:17:13
de la clase pedido 00:17:15
solo toca esta propiedad 00:17:16
es la única que toca 00:17:18
no toca ninguna de estas 00:17:20
ni código, ni descripción 00:17:22
ni precio, no toca ninguna de estas 00:17:23
luego, eso lo convierte 00:17:26
en un método especial 00:17:29
¿en qué sentido? 00:17:30
en que me da igual que a este método 00:17:32
lo llame P1 00:17:34
P1.modificaIVA 00:17:36
o me da igual que lo llame P2 00:17:39
o me da igual que lo llame P3 00:17:41
me da lo mismo 00:17:42
porque es que no toca el contenido 00:17:43
particular de cada objeto 00:17:46
no lo toca, no depende de él 00:17:48
no depende del contenido particular 00:17:49
lo único que toca y lo único en lo que accede 00:17:51
es al común de todos 00:17:54
luego me da igual 00:17:55
qué objeto llame al método 00:17:58
luego esto lo convierte 00:18:00
en un método que se llama 00:18:02
estático también 00:18:04
un método que sólo toca 00:18:05
propiedades estáticas 00:18:07
luego se convierte en un método estático 00:18:09
si yo identifico que a un método le pasa eso 00:18:11
que solo toca variables estáticas 00:18:15
debería, no es que sea obligatorio 00:18:18
debería 00:18:21
identificarlo poniéndole el static delante 00:18:22
debería identificarlo poniéndole el static delante 00:18:26
y diréis vosotros, bueno entre ponerlo y no ponerlo 00:18:38
¿qué ganas? 00:18:41
bueno, pues si yo pongo el static delante 00:18:43
el compilador me va a permitir 00:18:45
llamarlo con el nombre de la clase 00:18:48
al igual que las propiedades 00:18:51
estáticas, es decir 00:18:53
si yo le pongo el static delante 00:18:55
ahora ya puedo 00:18:56
hacer así, pedido 00:18:59
punto, modifica y va 00:19:01
¿vale? como es un método 00:19:03
estático, da igual 00:19:07
exactamente el objeto que lo llame 00:19:08
da lo mismo, con lo cual lo llamo con el nombre 00:19:10
de la clase, ¿y qué va a hacer este 00:19:12
método? va a coger esta propiedad 00:19:14
perdón, va a coger este valor 00:19:16
y va a modificar la propiedad estática de pedido. 00:19:18
¿Qué ocurre si yo me he olvidado de poner el static delante? 00:19:22
Si yo no me he dado cuenta, no he advertido que este método solo usa propiedades static 00:19:35
y por tanto no he puesto el static delante, bueno, pues aquí no pasa nada. 00:19:42
este método está bien escrito 00:19:48
pero entonces 00:19:50
ahora ya no voy a poder usarlo 00:19:52
con el nombre de la clase 00:19:54
si no he puesto el static delante 00:19:56
necesitaría crear un objeto 00:19:57
aunque fuera un objeto de mentira 00:19:59
solo para llamarlo 00:20:01
tendría que crear un objeto 00:20:02
entonces para poder llamarlo 00:20:04
con el nombre de la clase 00:20:06
que es como se llaman los métodos estáticos 00:20:08
como no dependen del objeto 00:20:10
los llamo con el nombre de la clase 00:20:11
para poder llamarlos con el nombre de la clase 00:20:13
necesito poner el modificador 00:20:16
estático delante 00:20:18
si no 00:20:19
y ahora ya sí que los métodos estáticos 00:20:21
nos dan 00:20:49
muchísima flexibilidad para hacer cosas 00:20:50
porque son 00:20:53
las antiguas funciones de librería 00:20:54
de toda la vida, cuando uno quiere hacer 00:20:57
una utilidad 00:20:59
pues para hacer cosas, pero no asociada 00:20:59
a ningún objeto, si una utilidad 00:21:03
como leer del teclado, lo que sea 00:21:04
pues lo mete en un método estático 00:21:06
porque no va a depender de ninguna 00:21:08
entidad, de ningún objeto de mi 00:21:11
aplicación y se nos abre 00:21:13
una flexibilidad de diseño 00:21:14
enorme con los métodos estáticos. 00:21:16
Serían como utilidades de librería. 00:21:19
¿Vale? ¿Está entendido lo que significan 00:21:32
los métodos estáticos? 00:21:33
Pues, por ejemplo, ella nos permite cosas muy cómodas. 00:21:41
Por ejemplo, en este main, 00:21:44
pues aquí había un método 00:21:48
que era 00:21:49
Bueno, aquí no hay ninguno que se adapte bien 00:21:51
Y sería un poco, entonces 00:22:12
Podemos, por ejemplo 00:22:13
Utilizar el concepto de métodos static 00:22:22
Para ahora ya, sí que sí 00:22:25
Bueno, no, porque todavía nos falta información 00:22:28
Por ejemplo, vamos a abrir el ejercicio 00:22:32
El ejercicio este de las distancias y los puntos 00:22:35
Que era el 13, no 00:22:41
el 14, el de la trayectoria 00:22:47
y todo eso, este de aquí 00:22:51
vale, pues teníamos 00:22:55
este método, si recordáis que era 00:22:58
lo llamaba un punto y calculaba 00:23:04
la distancia a otro punto 00:23:08
vale 00:23:10
pues imaginaos que nos planteamos este diseño de forma distinta 00:23:12
oye, yo, me suena más, me es más familiar 00:23:16
un método al que yo le paso 00:23:19
los dos puntos como parámetro 00:23:22
le paso los dos puntos 00:23:23
¿vale? entonces, por ejemplo 00:23:24
a uno le puede parecer 00:23:28
que queda más claro 00:23:30
hacer este método distancia 00:23:31
así 00:23:33
public double 00:23:34
distancia 00:23:38
le paso 00:23:41
punto p1 00:23:44
y punto 00:23:49
p2, vale 00:23:51
le paso los dos puntos 00:23:52
Ahora hago la distancia, que sería este mismo código, pero cambiando por P1, P2, entonces esto sería P1.getX menos P2.getX, P1.getX, P2.getX, y aquí P1.getY, 00:23:54
p2.get 00:24:22
p1.get 00:24:25
vale, pues ahora hemos hecho este método 00:24:30
otra variante de distancia 00:24:36
tenemos la versión que 00:24:37
habíamos hecho y esta otra 00:24:39
esta recibe los dos 00:24:41
puntos como parámetro 00:24:44
y trabaja con esos dos puntos 00:24:45
para calcular la distancia y me la devuelve 00:24:47
entonces automáticamente 00:24:49
yo veo este método y digo, uy va 00:24:52
este método no usa 00:24:53
para nada 00:24:56
propiedades del objeto que lo llama 00:24:57
para nada, solamente usa 00:25:00
lo que yo le estoy pasando 00:25:02
por aquí, no usa coordenadas 00:25:04
del objeto que lo llama 00:25:06
es decir, da igual el que llame a este método 00:25:08
da exactamente igual quien lo llame 00:25:10
porque lo único con lo que trabaja 00:25:12
es con este y con este, da igual quien llame 00:25:14
a este método, no usa ninguna propiedad 00:25:16
con lo cual 00:25:18
si yo me doy cuenta de eso 00:25:21
automáticamente le pongo el modificador 00:25:22
estático a este método, ¿vale? 00:25:25
A este no podría poner, aquí me falta el pedo, 00:25:29
a este no podría ponérselo. 00:25:31
Si yo calzo aquí un static, 00:25:35
automáticamente me dice, oye, perdona, si eres método estático 00:25:38
no puedes usar la coordenada X 00:25:41
del punto que lo llama o la coordenada Y 00:25:44
del punto que lo llama, porque si eres un método estático 00:25:47
no dependes de propiedades del objeto. 00:25:50
en absoluto, solo dependerías 00:25:53
de propiedades static, si las hay, que son 00:25:56
común, pero en este caso 00:25:58
ni siquiera, con lo cual este método 00:26:00
si yo le pongo aquí el static, me sale aquí 00:26:02
un error, me dice, no puedes depender entonces del 00:26:04
punto que lo llama, no puedes depender del objeto 00:26:06
entonces aquí el static no puedo 00:26:08
pero en esta versión sí 00:26:09
en esta versión puedo 00:26:12
ponerle el static, porque esta versión 00:26:14
solo depende de este parámetro 00:26:16
y de este otro, no depende 00:26:18
para nada del objeto que lo llama 00:26:20
luego tengo otra versión 00:26:22
tengo esta y tengo esta 00:26:24
las dos aunque se llaman igual 00:26:26
se distinguen perfectamente 00:26:29
porque la primera 00:26:31
será la que se ejecuta 00:26:32
cuando le paso solo un punto 00:26:34
y la segunda será la que se ejecuta 00:26:35
cuando le paso dos 00:26:38
luego se distinguen perfectamente 00:26:39
lo que no podrían es tener 00:26:42
los mismos parámetros, claro 00:26:44
pero si tienen parámetros distintos 00:26:45
¿vale? pues ¿cómo usaríamos ahora 00:26:47
este otro método 00:26:50
para nuestro main de este ejercicio 00:26:51
esto de la distancia 00:26:53
lo usábamos, creo que en la clase 00:26:55
aquí 00:26:57
¿vale? 00:27:01
usábamos aquí el método 00:27:04
distancia para calcular 00:27:05
la distancia entre este punto 00:27:07
y este otro 00:27:09
calculábamos la distancia 00:27:10
entre este y este 00:27:13
pues si uso ese otro método 00:27:15
esta misma sentencia 00:27:19
se convertiría en esta 00:27:21
se convertiría en esta de abajo 00:27:22
en lugar de llamarlo con un punto 00:27:28
lo llamo con el nombre de la clase 00:27:32
porque es estática 00:27:34
y ahora le paso los dos puntos 00:27:35
de los que quiero calcular la distancia 00:27:38
que eran get puntos de i 00:27:40
t punto get puntos de i 00:27:50
era uno 00:27:57
y el otro sería t punto 00:27:58
vale 00:28:01
getPuntos 00:28:05
de i 00:28:07
getPuntos 00:28:09
ah, me faltan los paréntesis 00:28:12
ahí, vale 00:28:14
vale, pues con esta versión de arriba 00:28:15
con esta 00:28:19
versión de arriba, estoy 00:28:21
llamando al método distancia 00:28:23
al que lo llama 00:28:25
un punto 00:28:27
y me calcula la distancia con el 00:28:28
otro, aquí estoy llamando 00:28:31
a esta otra versión 00:28:36
que le paso los dos puntos por parámetro 00:28:37
y que he etiquetado 00:28:40
como static porque puedo hacerlo 00:28:42
porque no depende del punto 00:28:44
pues entonces lo llamo con el nombre de la clase 00:28:45
y le paso los dos puntos 00:28:47
¿vale? 00:28:50
nos abre alternativas de diseño 00:28:56
posibilidades de diseño 00:28:58
que ahora ya sí que nos pueden ser un poco más útil 00:29:00
pero bueno, podemos verlo 00:29:04
mañana 00:29:06
si queréis 00:29:08
porque nos alargaríamos un poquito 00:29:09
Pero bueno, os hacéis idea de lo que es un método estático 00:29:11
¿Verdad? 00:29:17
¿Dudas? 00:29:21
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
3
Fecha:
16 de diciembre de 2025 - 14:12
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
29′ 23″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
119.85 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid