Activa JavaScript para disfrutar de los vídeos de la Mediateca.
Clase 12-01-24 - 3 - Contenido educativo
Ajuste de pantallaEl ajuste de pantalla se aprecia al ver el vídeo en pantalla completa. Elige la presentación que más te guste:
Vamos a reproducir lo que hemos dicho, que es, vamos a recorrer mi array de puntos
00:00:00
para hacer una suma acumulativa, entonces que tenemos que hacer una suma
00:00:08
acumulativa de distancias pequeñitas está claro, entonces hacer una suma
00:00:12
acumulativa, ya sabemos hacerla, vale, como las distancias son double, pues mi
00:00:16
suma acumulativa va a ser double, entonces la declaro como double y la
00:00:22
inicializo a cero, vale, entonces este es el resultado de mi método, lo que yo
00:00:28
voy a tener que devolver, este es el resultado, una suma acumulativa de
00:00:32
distancias, ahora cuando hay una suma acumulativa siempre hay un bucle que va
00:00:39
incorporando los sumandos, siempre hay eso, un bucle, vale, en cada iteración del
00:00:45
bucle se incorpora un sumando, bueno, pues ahora este bucle que tiene que ir
00:00:50
recorriendo para ir obteniendo los diferentes sumandos, los sumandos son
00:00:54
estas distancias de aquí, esos son los sumandos, esta distancia y esta, entonces
00:00:58
cada iteración del bucle me irá obteniendo una distancia y cada distancia
00:01:03
se irá incorporando a la suma acumulativa, vale, entonces mi bucle por
00:01:09
donde tiene que ir pasando para ir obteniendo estas distancias de aquí, pues
00:01:14
por los puntos, lo que hemos dicho, pues mi bucle pasará por este punto, me
00:01:18
calculará esta distancia y ya tiene un sumando para la suma acumulativa, ahora
00:01:22
pasará este, me calculará esta distancia y ya tiene el siguiente sumando para la
00:01:26
suma acumulativa, vale, esa es la historia de toda la vida, yo tengo un resultado
00:01:30
que construir incorporando sumandos, pues una vez que lo he identificado, que mi
00:01:36
problema es obtener un resultado incorporando sumandos, ahora ya planteo
00:01:42
ese algoritmo de suma acumulativa y en este caso eso es lo que hemos
00:01:48
identificado, mi resultado final se construye incorporando sumandos, esta
00:01:51
distancia, esta, esta, pues es una suma acumulativa porque es un resultado que
00:01:56
se consigue incorporando, una vez que lo identifico, ahora ya digo, vale, pero
00:02:00
por donde tengo que ir pasando, que bucle tengo que hacer, ese bucle por donde
00:02:04
tiene que ir, pues por mi array de puntos, pues venga, nuestro bucle que vaya
00:02:08
incorporando los sumandos tendrá que ir recorriendo este array, pues un bucle
00:02:15
para recorrer un array, lo hacemos casi siempre así, este bucle así, puesto
00:02:19
hacia palo seco a lo bestia, pues es un bucle que me recorre todos los puntos
00:02:31
desde el primero hasta el último, aquí nosotros sabemos que en cada parada, en
00:02:37
cada punto, vamos a obtener la distancia con el siguiente para obtener el sumando,
00:02:44
entonces en este caso concreto, esta iteración, quiero que se pare en el
00:02:49
penúltimo, quiero que se pare ahí, vale, pues entonces vamos a pararlo en el
00:02:55
penúltimo, vamos a pararlo ahí, bueno, pues ya está mi bucle y ahora ya, a mi
00:03:00
bucle, en mi bucle, en cada iteración incorporo un elemento a la suma
00:03:06
acumulativa y ese elemento ¿cuál será? Pues la distancia entre el punto en el
00:03:11
que estoy, puntos de i, en la primera iteración estoy en puntos de 0, en la
00:03:18
siguiente estoy en puntos de 1, en la siguiente estoy en puntos de 2, pues en
00:03:23
cada iteración estoy en puntos de i y tengo que calcular la distancia entre
00:03:27
puntos de i y puntos de i más 1, ¿cómo calculo la distancia entre puntos de i y
00:03:32
puntos de i más 1? Podría aplicar la fórmula a lo bestia, pero ¿para qué?
00:03:36
ya tengo un método de la clase punto, que dado un punto, me calcula la distancia
00:03:40
de ese punto con otro, pues aprovechemos que tenemos ese método y ya vemos ley,
00:03:45
pues dado un punto, que es puntos de i, puedo yo llamar a un método, calcular
00:03:49
distancia con punto, que me calcula la distancia con el otro que yo le diga,
00:03:58
¿qué otro le quiero decir yo? El siguiente, ¿vale? Entonces, lo de los
00:04:04
modificadores de acceso, ¿por qué me deja acceder? Lo podemos dejar aparcado,
00:04:16
pero ya estaría, este método ya ha acabado, es una suma acumulativa que va
00:04:21
recorriendo todos y cada uno de mis puntos hasta el penúltimo y para cada
00:04:29
objeto punto, llama al método calcular distancia para obtener la distancia con
00:04:34
su siguiente, ¿vale? Y me puedo aprovechar de que tengo este método, que como está
00:04:39
en la clase punto, este método que lo llaman objetos punto, ¿lo tienen que
00:04:46
llamar objetos punto? Claro, pues aquí lo llama un objeto punto, este, este,
00:04:50
que es un objeto punto de la RAI, y este método ¿qué hace? Calcula la distancia
00:04:54
de este punto con el siguiente, con puntos de i más 1, y ya está, ya está este
00:04:59
método hecho, ah no, perdón, un segundo, esta es la distancia, ahora habrá que
00:05:07
multiplicar por el gasto por combustible, claro, me falta, entonces esta es la
00:05:11
distancia, un momento, y habrá que multiplicar la distancia en kilómetros
00:05:15
que he obtenido por esto, porque este es el gasto en esa trayectoria, me falta
00:05:19
multiplicar por esto, ¿vale? Esta es la distancia en kilómetros, y ahora la
00:05:25
distancia en kilómetros por lo que yo gasto en cada kilómetro, y eso es lo que
00:05:30
me devuelve el método. ¿Qué me has preguntado? No, dime, dime.
00:05:34
Vale, bueno pues el haber metido esta funcionalidad en este método, en esta
00:05:40
clase punto, me permite que cuando a mí me dé la gana calcular la distancia
00:05:52
entre un punto y otro, lo pueda hacer fácilmente, sin más que llamar a este
00:05:56
método, y aquí me ha hecho falta hacerlo aquí, me ha hecho falta hacerlo aquí
00:05:59
dentro. Ahora en un main vamos a usarlo de otras maneras, para a lo mejor
00:06:04
entenderlo mejor. Vale, a ver para qué, voy a quitarle un poco de saltos de
00:06:11
línea para que no se quede ahí tan, vale, pues este sería el método, una suma
00:06:19
que voy acumulando a la variable suma, la distancia de mi punto de i con mi
00:06:29
siguiente. A este método como veis le estoy llamando, pasándole un objeto
00:06:34
punto. Vale, ¿hay que hacer más métodos en esta aplicación para vehículo y
00:06:40
punto? No. Ahora lo que me dicen es, bueno, ahora ya hazte un programa
00:06:46
principal, un main que haga cosas, con puntos, con vehículos que haga cosas,
00:06:49
porque las posibilidades ya están, que es, dado un vehículo, dado un vehículo,
00:06:56
si tú quieres, puedes, pasando en una trayectoria, calcular un gasto, puedes
00:07:04
hacer eso si quieres, pero todavía no hay ningún main en el que haya vehículos,
00:07:09
todavía no hay nada. Aquí lo mismo, tenemos la posibilidad, dado un punto,
00:07:12
cuando tú tengas un objeto punto con coordenadas x y y, cuando lo tengas,
00:07:19
podrás calcular la distancia entre ese punto con otro, si tú quieres, pero
00:07:23
aquí todavía no hay ningún punto hecho ni nada, eso todo es un main. Aquí
00:07:28
tenemos cosas que podemos hacer con objetos. Ahora ya tenemos construido el
00:07:32
programa, el programa que se ejecuta, el programa que crea puntos que hace
00:07:39
cosas. Vamos a hacer un main que haga diferentes cosas, diferentes, mezcladas,
00:07:42
probando estos métodos para entender un poco mejor. Pues venga, vamos a hacer
00:07:45
un main dentro de aquí, de ejercicio 5. Vale, esta clase que yo me he hecho,
00:07:51
tiene el método main aquí, tiene el método main, y aquí yo ya hago lo que
00:08:03
a mí me dé la gana, creo los vehículos que quiera, calculo distancias entre
00:08:11
puntos, lo que yo quiera. Venga, pues a ver, vamos a hacer un vehículo cualquiera
00:08:16
con un gasto cualquiera por combustible. Pues venga, vamos a hacer un primer
00:08:23
vehículo V1, por ejemplo, yo qué sé. Lo instanciamos, y bueno, para que la
00:08:27
aplicación no sea tan fea, lo que gasta por combustible vamos a pedirlo por
00:08:35
consola, para que lo meta el usuario y no lo pongamos así a capón directamente.
00:08:40
Vale, pues venga, vamos a decirle al usuario Ala, venga, introduce un gasto
00:08:45
por kilómetro. Y lo vamos a leer, esto va a ser un dabble, pues lo vamos a leer
00:09:08
en una variable dabble cualquiera. Y ahora ya, vamos a crear un vehículo
00:09:25
concreto, uno concreto, cuya propiedad gasto por kilómetro tenga ese valor que
00:09:34
acabamos de leer. Ahora ya si tenemos un coche concreto, que tiene un gasto
00:09:39
concreto, 7, 12, el que hayamos metido, ahí ya tenemos uno. O podríamos tener
00:09:43
otro, como si me da la gana hacer un V2 y un V3, los que yo quiera. Cada uno
00:09:48
tendrá su propio gasto por kilómetro. Vale, pues ahora, vamos a ver lo que ha
00:09:55
gastado este vehículo en una trayectoria concreta. Bueno, pues vamos a construir
00:10:01
la trayectoria y construirla dando puntos. Venga, pues vamos a hacernos una
00:10:05
array de objetos punto, una array de objetos punto que sea una trayectoria
00:10:11
concreta, pues de cuantos, esta no la voy a pedir por teclado, pero luego para
00:10:16
probar y para pedir para punto por teclado estamos dos horas. Pues vamos a
00:10:22
hacerlo una trayectoria así, tal cual. Pues venga, vamos a crear una trayectoria
00:10:26
de cuantos, pues venga, de 7, como vamos a darle los valores aleatoriamente.
00:10:32
Ala, tenemos aquí una trayectoria concreta, o lo que es una array de objetos
00:10:40
punto, de 7 puntos, o sea con espacio para 7 puntos, todavía no hay ningún punto
00:10:44
creado para 7. Ahora voy a rellenar este array con objetos punto a los que le
00:10:50
voy a dar valores aleatorios para coordenar a X e Y, para que no los tenga que meter
00:10:55
por teclado, que son codos. Pues venga, vamos a rellenar este array. Pues para
00:10:59
rellenar un array lo recorremos. Vale, vamos a rellenar este array. A cada
00:11:05
posición del array, a cada posición Y, que hay que darle un objeto punto, un
00:11:22
objeto punto, porque este array mío es de objetos punto. Luego a cada posición
00:11:29
del array hay que darle un objeto punto, entonces tengo que crearlo los objetos,
00:11:34
tengo que crearlos. Claro, pues lo creo. Entonces, vamos a hacer, para usar los
00:11:38
set, voy a crear el punto primero sin parámetros y ahora con los set le voy a
00:11:45
fijar las coordenadas. Podría ponerle aquí las coordenadas que me dieran la
00:11:51
gana, por ejemplo, y con esto he creado un punto de coordenadas 5 y 8 que lo
00:11:55
asigno a trayectoria Y. Hombre, si dejo este bucle tal cual, la trayectoria
00:12:00
sería un montón de puntos unos encima de otros. Una tontería, ¿no? Una tontería.
00:12:05
Entonces la idea es que cada uno de estos tenga un valor distinto, poner ahí
00:12:09
unos aleatorios, cualquiera. Entonces esta sería una opción. Pero en lugar de
00:12:13
hacerlo así, pues para usar el set, voy a instanciar el constructor sin
00:12:18
parámetros, con lo cual creo mi objeto punto con las coordenadas por ahora
00:12:23
sin definir, están sin definir. Y ahora voy a fijárselas con el set. Pues venga,
00:12:27
mi objeto trayectoria de Y es un objeto punto que ya existe. Pues a su coordenada
00:12:32
ahí le voy a dar un valor entre 1 y 100. Vamos a dejar todas las coordenadas.
00:12:39
Y como tiene que ser entero, pues todo esto he hecho casting a entero. Esto
00:12:50
como hemos generado números aleatorios, que los hemos generado, se puede generar
00:12:55
de muchas maneras, esta es muy cómoda, es la que hemos usado siempre.
00:12:58
Ya he fijado la coordenada X del punto este, del punto Y de la trayectoria. Voy
00:13:03
a hacer lo mismo con la coordenada Y. Pues este sería mi bucle para rellenar
00:13:10
el array de puntos. Primero hago espacio para el array, hago espacio, lo que
00:13:20
hemos hecho siempre. Tengo que hacer espacio para el array. Hago espacio
00:13:26
para 7, lo que hemos hecho siempre. Y ahora ya, una vez que he hecho espacio,
00:13:29
me pongo a cada espacio meter lo que sea. ¿Pues qué va en cada posición?
00:13:33
Un objeto. Pues hombre, un objeto hay que crearlo. Un objeto hay que crearlo,
00:13:41
siempre. Principio básico, con el que llevamos ya tiempo. Pues lo creamos.
00:13:45
Y si yo lo creo así, con mi constructor sin nada, mi constructor sin parámetros
00:13:51
es este. Este es mi constructor al que estoy llamando, este no hace nada.
00:13:55
Hombre, pues entonces a ese punto que acabamos de crear, vamos a darle valores.
00:13:59
Porque lo he creado vacío, sin nada. Vamos a darle valores. Pues venga, para
00:14:03
darle valores, voy a usar Excel. A la coordenada X de ese punto que acabo
00:14:08
de crear, le doy una aleatoria. Y a la coordenada Y de ese punto que acabo
00:14:13
de crear, le doy otra aleatoria. Vale, pues ya tenemos una trayectoria.
00:14:17
Ya tenemos un montón de puntitos. Ya está. Ahora, resulta que este objeto
00:14:21
V1, por el hecho de ser un objeto vehículo, puede llamar a este método.
00:14:27
Puede llamarlo, porque este método está dentro de la clase vehículo.
00:14:34
Entonces, cualquier objeto vehículo puede llamar a este método.
00:14:38
Y cuando un objeto vehículo llame a este método, ¿qué va a necesitar?
00:14:42
Que le pasemos una trayectoria. Vale, muy bien, le pasemos una trayectoria.
00:14:46
¿Y qué va a hacer este método? Pues lo que ya hemos probado nosotros que
00:14:50
haga. Calcula la distancia, multiplica por el gasto del vehículo que llama
00:14:53
al método y me lo devuelve. Pues estupendo. Mi main ya lo tiene muy fácil.
00:14:57
¿Que yo quiero mostrar lo que va a gastar el vehículo en esa trayectoria?
00:15:01
Pues facilísimo. El gasto del vehículo que acabo de crear en la trayectoria
00:15:05
que acabo de crear. Y ese valor, ¿cómo lo puedo obtener?
00:15:15
Hombre, pues mira, V1, que es mi objeto vehículo, tiene un método
00:15:26
declarado en su clase que se llama getGastoKilometro, no, getGastoKilometro
00:15:31
no, se llama, punto, obtenerGastoTrayectoria. Y a este método, si tú
00:15:36
le pasas una raíz de objetos, punto, porque eso es lo que él espera,
00:15:44
una raíz de objetos, punto, si tú se lo pasas, te hace todo esto.
00:15:49
Pues vamos a pasárselo. ¿Qué raíz le vamos a pasar? Vamos a pasarle
00:15:53
éste, el que acabamos de declarar, éste. Pues venga, se lo pasamos.
00:15:57
Y ya está. Este método hará todo lo que tiene dentro para, sumando
00:16:02
los puntos de la trayectoria, las distancias patatín, multiplicándolo
00:16:11
por el gasto de este vehículo, hará todo, me lo devolverá cobrador de retorno
00:16:15
y ya lo tengo todo hecho. ¿Vale? Ya está. Entonces, si yo ejecuto esto,
00:16:19
pues me sacará lo que ha gastado este vehículo V1 que acabo de construir
00:16:28
recorriendo la trayectoria que acabo de construir aquí.
00:16:32
Que construyo otra y le paso esa otra que he construido, pues me devolverá
00:16:36
el gasto en esa otra. Me devolverá el gasto en la que yo le pase.
00:16:40
¿Vale? Pues para eso sirven los métodos. Yo cosas que quiero hacer
00:16:44
las meto en la clase. Y ahora ya cuando mi programa principalmente
00:16:49
tenga que hacerlas, se limita a llamarlo. No tiene que hacerme el chorizo
00:16:53
todo el rato. Se limita a llamarlo y listo. Ya lo tiene hecho.
00:16:57
Que ahora tengo otro vehículo V2 y quiero calcular el gasto por trayectoria
00:17:01
de ese otro vehículo V2 en esa misma trayectoria. Tranquilamente.
00:17:05
Ahora tengo yo otro vehículo V2 más. Pues venga. NewVehiculo, que este
00:17:10
resulta que este gasta 6. Pues ¿cuánto habrá gastado este otro vehículo
00:17:16
en esa trayectoria? Pues vamos a hacer que sea este el que llame al método.
00:17:21
Ahora lo está llamando V2. Entonces como ahora lo llama V2, este método
00:17:29
trabaja con las propiedades de V2. Aparte de con la trayectoria,
00:17:35
trabaja con las propiedades de V2. Con lo cual este método estará usando
00:17:39
el gasto por kilómetro del que llama al método cada vez. Aquí estará usando
00:17:45
el de V1 porque es el que llama al método. Pero aquí está usando el de V2
00:17:50
porque es el que llama al método. Así es como funciona esto.
00:17:54
Está la motivación de los métodos que hemos estado estudiando.
00:17:58
Entonces si ejecutamos esto, a ver si el cálculo está bien o mal,
00:18:06
no lo vamos a saber porque como lo ha generado de forma aleatoria,
00:18:10
no sabemos qué trayectoria ha hecho. Pero al menos si algo se nos ha escapado
00:18:14
como para que nos den errores de ejecución, null pointer exception,
00:18:18
si la raíz se sale o algo, eso sí lo vamos a poder comprobar.
00:18:21
El primer vehículo tiene 3. Pues el primero ha gastado en su trayectoria esto.
00:18:27
Y el segundo, al menos tiene pinta de que el programa va bien,
00:18:33
porque el segundo tenía 6 y el primero 3. Y el segundo ha gastado justo el doble
00:18:37
del primero. Entonces 40 al menos parece.
00:18:43
Pues hay que ir cogiendo solturas en eso, ya que es un método,
00:18:57
es un trozo de código que se declara en una clase y ese trozo de código
00:19:01
¿quién lo llama? Objetos de esa clase pero ya en un programa main
00:19:05
que hace cosas. Y cuando ese método sea llamado, se llama para un objeto
00:19:09
concreto, sea v1, sea v2, sea el que sea, se llama para un objeto concreto.
00:19:15
Con lo cual ese método, cuando sea ejecutado, se ejecutará cada vez
00:19:20
con un valor en las propiedades del objeto. Cuando lo llame v1,
00:19:24
se ejecutará con el gasto por kilómetro de v1, el que sea.
00:19:29
Cuando lo llame v2, se ejecutará con el valor de gasto por kilómetro de v2.
00:19:32
Pero cuando yo lo declaro, yo pongo la propiedad y cuando te ejecutes,
00:19:37
ahí ya habrá lo que sea, 30, 20, ahí ya habrá lo que sea cuando te ejecutes.
00:19:42
Yo aquí te estoy declarando sin más, te estoy diciendo lo que vas a hacer.
00:19:46
Y luego lo siguiente, pues seguir manejando los arrays como cualquier
00:19:51
otra variable, porque cuando incorporamos otras colecciones de datos,
00:19:55
listas o conjuntos o pilas, pues va a ser lo mismo, es el mismo concepto.
00:19:59
Es como cualquier otra variable, lo que pasa es que es un conjunto de muchas.
00:20:03
Bueno, pues nada, la recorro y cada una de ellas, como es un punto,
00:20:08
puede llamar a este. Por ejemplo, para ver un poco más sobre el método
00:20:11
de la distancia, en este mismo main, que ya hace cosas en este mismo,
00:20:15
vamos a crear dos puntos cualesquiera y ver la distancia entre ellos.
00:20:19
Pues venga, voy a crear yo aquí un objeto punto, p1.
00:20:24
New punto y voy a usar esta vez el constructor con parámetros.
00:20:29
1, 1, ala, me he creado el punto en el plano 1, 1.
00:20:32
Me he creado este punto.
00:20:36
Si este es mi eje de afisas y ordenadas, pues me he creado el punto 1, 1,
00:20:42
que es este.
00:20:52
Ala, aquí está mi punto 1, 1, es este, porque esta es 1 y este es 1.
00:20:55
Ala, este es mi punto p1 que me acabo de crear, es este.
00:21:05
Mi punto p1 es este con coordenadas x1 e y1.
00:21:12
Es el punto que me acabo de crear.
00:21:17
Voy a crear otro punto, el 2, 2.
00:21:20
Punto p2 igual a new punto, bueno, pues este punto, ¿dónde estará en el plano?
00:21:24
Este punto en el plano, pues estará aquí.
00:21:33
Ahí estará mi punto 2, 2.
00:21:39
Porque esta es la coordenada x que tiene 2 y esta es la coordenada y que tiene 2.
00:21:47
Luego mi punto p2 está ahí.
00:21:55
Este es mi punto p2.
00:22:02
Ahora, yo quiero la distancia entre los dos puntos, es decir, quiero medir esta distancia.
00:22:07
Esta distancia.
00:22:14
Quiero medir esta distancia, la distancia entre p1 y p2.
00:22:16
Bueno, pues en lugar de tener que hacer la fórmula matemática otra vez, no me hace falta.
00:22:19
Porque dentro de la clase punto, resulta que tengo un método que me dice,
00:22:23
oye tú, si tú llamas a este método desde un punto, si lo llamas,
00:22:27
te voy a calcular la distancia con el que me pases por parámetro.
00:22:33
Y aquí es donde mete la fórmula.
00:22:37
Si tú me llamas desde un punto, yo te calculo la distancia con este otro.
00:22:39
Pues yo quiero calcular la distancia entre p1 y p2, pues estupendo.
00:22:44
Pues cojo p1, llamo al método y le paso p2.
00:22:48
Y esto me devolverá como valor de retorno la distancia entre p1 y p2,
00:22:53
me lo devolverá como valor de retorno.
00:22:57
¿Que quiero mostrarla?
00:22:59
Bueno, claro, pues la muestro, vamos a mostrarla.
00:23:01
Voy a ponerlo aquí concatenado con asteriscos para que se vea bien claro
00:23:04
que esto es lo que estamos mostrando.
00:23:08
¿Vale?
00:23:12
¿Que nos va a tener que salir?
00:23:14
Hombre, nos va a tener que salir, ya lo sabemos,
00:23:15
la hipotenusa de un triángulo rectángulo de parámetros 1 y 1,
00:23:17
que es la raíz cuadrada de 2.
00:23:20
La hipotenusa, este triángulo, esto es un triángulo rectángulo que tiene,
00:23:22
que tiene esto como un lado, como un cateto y esto como otro cateto.
00:23:28
Este cateto es uno, este cateto es otro.
00:23:38
La hipotenusa, ¿cuánto vale?
00:23:41
La raíz cuadrada del cuadrado de los catetos.
00:23:42
Pues la raíz cuadrada de 1 más 1, o sea, raíz de 2.
00:23:44
Raíz de 2, ¿cuánto es?
00:23:47
¿1 con 7 puede ser?
00:23:49
No, ¿verdad?
00:23:50
1 con algo.
00:23:51
¿Cuánto es la raíz de 2?
00:23:52
¿Tenéis una calculadora ahí a mano en el móvil?
00:23:54
¿Eh?
00:23:57
Vale, 1 con 41.
00:23:59
No, no la calculo ni nada.
00:24:00
Vale.
00:24:01
Bueno, 1 con 41.
00:24:02
Bueno, pues efectivamente esto, si está bien hecho el método,
00:24:04
si he puesto bien la fórmula,
00:24:07
si he puesto bien la fórmula,
00:24:09
la distancia entre el punto P1 que llama el método
00:24:11
y el punto P2 que le paso como parámetro,
00:24:15
que son los dos puntos con los que trabaja este método,
00:24:18
con el punto que llama el método
00:24:22
y con el punto que le paso como parámetro,
00:24:24
me tendrá que dar 1 con 4,
00:24:26
si es que la fórmula matemática está bien.
00:24:28
Pues vamos a volver a ejecutar esto.
00:24:32
Esto, bueno, la primera parte, 1,
00:24:37
pues sí, efectivamente me da la raíz de 2,
00:24:40
eso es exactamente la raíz de 2.
00:24:42
Pero es bueno, he puesto bien la fórmula.
00:24:44
Aquí.
00:24:46
Pero vamos, más que la fórmula en sí,
00:24:49
lo que nos interesa entender es
00:24:52
qué implica declarar un método.
00:24:54
Una vez que ya lo tengo declarado,
00:24:56
¿quién lo llama?
00:24:57
El objeto que me dé la gana.
00:24:58
Lo llama el que me dé la gana.
00:24:59
Y este método trabaja
00:25:01
con el objeto que lo llama,
00:25:02
sus propiedades, claro,
00:25:04
a través de dis,
00:25:05
a través de dis.
00:25:07
Entonces en este caso,
00:25:08
dis.y es la propiedad y de P1
00:25:10
y dis.x es la propiedad x de P1,
00:25:15
porque P1 es el que lo está llamando.
00:25:21
Y sin embargo,
00:25:23
.y, ¿quién es?
00:25:25
La propiedad y del parámetro.
00:25:27
Y el parámetro en este caso, ¿cuál es?
00:25:29
P2.
00:25:31
Y .x, ¿quién es?
00:25:33
.x es la propiedad del parámetro.
00:25:37
Luego, en este caso,
00:25:42
es P2.y, la propia .x.
00:25:44
Que tengo otro método,
00:25:48
otro punto cualquiera.
00:25:49
.p3 igual a
00:25:52
new punto doce diecisiete.
00:25:56
Ahora quiero calcular la distancia
00:25:59
entre P3 y P2.
00:26:01
Pues ya está, pues,
00:26:03
la tengo aquí ya.
00:26:05
P3 punto,
00:26:06
calcular distancia,
00:26:08
P2, por ejemplo.
00:26:10
Bueno, pues esta es la distancia.
00:26:14
Esta.
00:26:16
Entre el punto P3 con sus coordenadas
00:26:17
y el punto P2 con sus coordenadas.
00:26:20
Y ahora cuando este método se ha llamado,
00:26:22
cuando este método se ha llamado,
00:26:24
el que hace de dis,
00:26:26
el que ejerce el papel de dis,
00:26:27
el que ejerce el papel de dis,
00:26:29
es P3.
00:26:31
Y el que ejerce el papel de punto,
00:26:33
de esta variable punto,
00:26:37
el que lo ejerce es P2.
00:26:39
Cada vez llamo yo al método
00:26:42
pasando lo que me da gana
00:26:43
y lo llama quien lo de la gana.
00:26:44
Y cumplen el papel
00:26:46
de lo que hay en la declaración del método.
00:26:48
Vale, pues esto,
00:26:56
esta idea,
00:26:57
esta idea es la que
00:26:59
tiene que quedar muy, muy, muy clara.
00:27:00
Claro, porque es la base de todo.
00:27:02
Es la base de aparación entre los objetos.
00:27:04
¿Qué es?
00:27:06
Yo tengo mis objetos.
00:27:07
Mis objetos, si yo he diseñado bien las cosas,
00:27:08
perdón, mis clases.
00:27:12
Tengo mis clases.
00:27:13
Si yo he diseñado bien las cosas,
00:27:14
mis clases hacen cosas.
00:27:15
Hay encapsuladas, que yo ni me importa.
00:27:16
Una vez declaradas, ni me importan.
00:27:19
Eso es lo que se llama encapsulación, de hecho.
00:27:21
Tiene un nombre de aparación entre los objetos.
00:27:23
¿Qué es?
00:27:25
Yo las tareas que quiero hacer,
00:27:26
ahí se quedan programadas en la clase.
00:27:27
Y una vez que están programadas,
00:27:29
me olvido de ellas.
00:27:31
Eso es encapsular.
00:27:33
Y ahora yo hago las aplicaciones que me den la gana,
00:27:35
los main que quiera.
00:27:37
Y me limito a llamar al método.
00:27:38
Lo que haga el método por dentro,
00:27:40
me da igual.
00:27:42
Yo hago la llamada y obtengo el resultado.
00:27:43
Ya está.
00:27:45
Que resulta que ahora hemos cambiado de espacio topológico
00:27:49
y estamos en un mundo que se rige
00:27:52
con otras coordenadas físicas
00:27:54
y la distancia entre puntos
00:27:56
ya no se rige por esta fórmula
00:27:58
porque estamos en un universo curvo
00:28:01
o lo que sea,
00:28:03
pues no pasa nada.
00:28:05
El programador correspondiente
00:28:07
cambiará este método
00:28:09
y solo ese
00:28:11
para poner la fórmula de los universos curvos
00:28:13
y no los universos a los que estamos acostumbrados.
00:28:15
Y cambiará eso.
00:28:18
Y la aplicación principal
00:28:19
le da lo mismo.
00:28:21
No tiene que cambiar nada.
00:28:22
La aplicación principal llama al método.
00:28:23
Ya es responsabilidad de la clase punto
00:28:26
decidir lo que programa por dentro.
00:28:29
Que lo ha cambiado.
00:28:31
Lo ha cambiado.
00:28:32
El main no tiene que cambiar nada
00:28:33
porque el main llama al método.
00:28:35
Si ha habido cambios,
00:28:37
vale, pues ha habido cambios.
00:28:38
¿Qué más me da?
00:28:39
Esa es la base de la aplicación de todas las objetos.
00:28:40
Lo que se llama el desacoplamiento.
00:28:43
Separar.
00:28:45
Yo separo las cosas.
00:28:46
Y si tengo que tocar una cosa,
00:28:48
toco la cosa solo ahí.
00:28:50
Y los demás no se enteran.
00:28:52
No se enteran.
00:28:54
Los demás trabajan conmigo, claro.
00:28:55
No tiene que cambiar nada.
00:28:56
No tiene que incorporar nada.
00:28:57
Si yo en cada main que haga
00:28:58
metía la fórmula de la distancia
00:29:00
y cambia el concepto de distancia,
00:29:01
pues tendría que irme a cada main
00:29:03
a cambiar la fórmula.
00:29:05
Sería una locura.
00:29:06
Pero si yo lo tengo recogidito en una clase
00:29:07
con un nombre de método,
00:29:10
el resto de los main
00:29:12
no tengo que cambiar nada.
00:29:13
Llaman al método y ya está.
00:29:14
Pues eso es la...
00:29:16
Por eso se hizo la aparición entre dos objetos.
00:29:18
Y por ninguna otra cosa.
00:29:20
Por eso.
00:29:21
Por desacoplar, por separar tareas
00:29:23
y porque las modificaciones en una
00:29:26
no afecten al resto de los programas.
00:29:28
No afecten a su declaración de código,
00:29:30
a la ejecución, por supuesto.
00:29:32
Si cambia el contenido,
00:29:33
el resultado va a cambiar.
00:29:34
Pero a la hora de programar
00:29:36
no tengo que tocar código.
00:29:38
No tengo que tocar nada.
00:29:39
Esa es la base en realidad.
00:29:42
¿Vale?
00:29:45
A ver, ¿alguien hay algo
00:29:49
que no le ha quedado claro?
00:29:50
¿Alguna pregunta de algo?
00:29:54
¿No?
00:29:56
Bueno.
00:30:00
Pues no voy a empezar con el estático
00:30:01
porque es un poco tarde.
00:30:02
A ver.
00:30:06
Estos de aquí eran enunciados
00:30:13
que estaban pensados para hacer
00:30:15
un repasillo rápido el lunes.
00:30:16
Pero...
00:30:18
Pero no sé si los habéis hecho.
00:30:24
En realidad son dos ejercicios.
00:30:31
Es este solamente para practicar
00:30:34
pues eso, con método y un instancio.
00:30:36
Le paso parámetro, veo que se crea.
00:30:38
Es más sencillo que lo que hemos hecho.
00:30:40
Y esto que en realidad es lo mismo.
00:30:42
O sea, es el mismo ejercicio
00:30:45
al que vamos añadiendo clases
00:30:47
para ir haciendo cosas.
00:30:48
Entonces era un poco para orientar
00:30:50
el repaso.
00:30:51
¿Vale?
00:30:53
Vale, pues entonces.
00:30:55
En la media horita que nos queda.
00:30:57
Si tenéis dudas de lo que habéis visto
00:30:59
me la preguntáis.
00:31:00
Y si no, pues arrancáis a hacer esto.
00:31:02
¿Vale?
00:31:05
Y aprovecháis, me vais preguntando, etc.
00:31:06
Porque el lunes ya
00:31:08
continuamos con otras cosas.
00:31:10
- Subido por:
- Raquel G.
- Licencia:
- Todos los derechos reservados
- Visualizaciones:
- 7
- Fecha:
- 12 de enero de 2024 - 13:58
- Visibilidad:
- Público
- Centro:
- IES ROSA CHACEL
- Relación de aspecto:
- 1.78:1
- Resolución:
- 1280x720 píxeles
- Tamaño:
- 595.66 MBytes
