Saltar navegación

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

Clase 12-01-24 - 1 - 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 12 de enero de 2024 por Raquel G.

8 visualizaciones

Más información Transcripción

Descargar la transcripción

Vamos a calentar un poco con este ejercicio a ver si tenemos claro todas las cosas. 00:00:00
Esto estaba en ejercicios, clases, objetos 1, ejercicio 5. 00:00:10
Luego ya subo este proyecto en el que tengo las resoluciones que hemos hecho aquí en clase. 00:00:19
Luego ya la dejo subida para que estén todos tal y como los hemos resuelto en clase. 00:00:24
Que vosotros podéis haberlo hecho de otra manera a lo mejor. 00:00:29
Los estoy separando en paquetes distintos, cada paquete un ejercicio. 00:00:36
Ahora ya que entendemos exactamente que son los paquetes y las implicaciones que tienen que usarlos. 00:00:47
Ya los usaremos a demanda según necesitemos nos venga bien organizar nuestras aplicaciones con ellos o no. 00:01:12
Esta aplicación por ejemplo en la que yo he decidido meter todos los ejercicios. 00:01:18
Pues aquí viene estupendo meter las clases asociadas a cada ejercicio en un paquete diferente. 00:01:23
Entonces los paquetes se incorporan cuando dentro de una misma aplicación tengo muchas clases 00:01:29
y a efectos organizativos me viene muy bien hacer una agrupación. 00:01:34
Pues aquí me viene fenomenal, esta aplicación mía tiene varios ejercicios, pues estupendo. 00:01:39
Como cada ejercicio tiene varias clases, pues cada uno lo agrupo en un paquete diferente. 00:01:45
Y ya sabemos todas las implicaciones que tiene separar las clases por paquetes. 00:01:50
La implicación fundamental es si desde clases de un paquete quiero usar yo, instanciar clases de otro. 00:01:56
Entonces en ese caso ya sabemos que hay que incluir los modificadores de acceso, 00:02:06
los import si queremos hacer la trampita de usar el nombre corto de las clases. 00:02:11
Bueno ya todos esos matices ya los conocemos del otro día y tenemos que intentar no olvidarlos. 00:02:16
Vale pues entonces hacemos ahora un paquetillo para el ejercicio 5 que era lo que estábamos, 00:02:23
que ya está hecho aquí y hacemos este ejercicio, calentamos y luego continuamos con otra aplicación. 00:02:28
Bueno pues esta aplicación como todas va a necesitar varias clases. 00:02:36
De nuevo repito por enésima vez, en una situación real a ti te plantea unas necesidades 00:02:42
y con esas necesidades tu decides que clases pueden representar esa situación 00:02:49
y ya a partir de ahí programas, es la parte de análisis y diseño. 00:02:56
Nuestros ejercicios ya directamente parten de que te dicen oye hazme estas clases, 00:03:00
estamos obviando esa fase de análisis y diseño, que no la obviéis porque 00:03:05
un proceso de desarrollo completo obviamente está ahí. 00:03:09
En nuestro caso es otro caso más en el cual nos dicen que clases hay que hacer. 00:03:12
Pues vamos a necesitar una clase vehículo, porque nuestra aplicación gestiona cosas relacionadas con vehículos. 00:03:16
En este caso como esta aplicación lo que gestiona es gasto, consumo, 00:03:24
pues la única propiedad que interesa del vehículo es lo que consume por kilómetro. 00:03:28
Si fuera una aplicación que va a gestionar otras cosas de los vehículos, pues sus marcas, 00:03:35
sus dueños pues entonces tendría propiedades relacionadas con eso que va a gestionar. 00:03:40
En este caso como esta aplicación sirve solo para gestionar el consumo que han tenido los vehículos, 00:03:44
que se instancien, pues esta es la única propiedad que el que diseñó esto decidió que le interesaba. 00:03:51
¿Vale? Pues esta clase tendremos que hacerla. 00:03:57
Entonces, sigamos por partes. 00:04:02
Bueno, vale, pues como esta clase en principio es independiente de cualquier otra, 00:04:04
pues una clase vehículo con consumo por kilómetro. 00:04:08
Pues yo la puedo hacer ya directamente porque es independiente de cualquier otra. 00:04:12
Pues venga, me hago mi clase vehículo. 00:04:19
Recordad que el entorno de desarrollo me ofrece siempre el public. 00:04:26
Yo antes lo quitaba porque no me gustaba tener algo ahí que no sabíamos lo que significaba. 00:04:29
Ahora ya sí sabemos lo que significa. 00:04:33
Entonces ahora decido, ¿me molesta que esté el public? 00:04:35
Pues nada, no me molesta que esté el public. 00:04:37
¿Vale? Pues lo dejamos. 00:04:40
Propiedades de vehículo. 00:04:43
Me han dicho lo que consume por kilómetro realizado, ¿no? 00:04:45
El gasto de combustible por kilómetro realizado. 00:04:52
El gasto de combustible. 00:04:55
Aquí la decisión sería, ¿lo hago en DAVE, lo hago en IND? 00:04:57
Venga, vamos a hacerlo en DAVE. 00:05:00
¿Vale? 00:05:08
Por cierto, ¿ha venido alguien a arreglar las mesas, los cables pelados esos de atrás? 00:05:10
Sí, aquí hay otro. 00:05:15
Sí vinieron, ¿no? Es que puse el aviso antes de Navidad y no sabía... 00:05:17
O sea, ¿esa mesa ya no tiene el cable pelado? 00:05:21
Aquí también hay. 00:05:24
¿Y ahí hay otro? 00:05:25
¿Os los coméis? 00:05:27
¿Y acordaros radiadores? 00:05:31
No, eso no. 00:05:33
¿Sigue frío? 00:05:34
Pues habrá que volverlo a decir o igual es que van con todas las frases hasta que lleguen aquí. 00:05:37
Vale, pues entonces. 00:05:47
Nuestra única propiedad es esta. 00:05:49
Nuestro margen de decisión es el tipo de dato. 00:05:53
En principio, bueno, el gasto por kilómetro, pues 3,5 litros, 8,9 litros, mejor un DAVE. 00:05:55
Vale, pues un DAVE. 00:06:03
Vale, ahora ya tenemos más decisiones que tomar que antes. 00:06:05
Vale, esta propiedad, aparte del tipo de dato, que esto ya lo hemos decidido, 00:06:09
ahora ya tenemos otra decisión más que tomar. 00:06:14
¿Qué modificador de acceso le pongo? 00:06:16
¿Le pongo que sea privada? 00:06:19
¿No le pongo nada? 00:06:21
¿O le pongo public? 00:06:23
Que son las tres opciones. 00:06:25
Porque la opción protected, que es la cuarta que mencionamos, 00:06:27
la dejamos aparcada porque esa tiene que ver con si hay clases herederas. 00:06:30
Aquí no hay nada heredero todavía, pero no sabemos. 00:06:35
Bueno, pues ya saben lo que significa cada cosa. 00:06:38
Si yo no pongo nada, significa que a esta propiedad pueden acceder clases del mismo paquete. 00:06:41
Si pongo public, significa que a la propiedad gasto por kilómetro pueden acceder clases 00:06:49
de cualquier otro paquete de la aplicación. 00:06:56
Si pongo esto, significa que a esta propiedad solo se puede acceder desde aquí dentro. 00:07:00
¿Qué decisión solemos tomar? 00:07:07
Ya lo mencionamos el otro día. 00:07:09
Nosotros, efectivamente, las propiedades del vehículo, cuando el vehículo esté instanciado, 00:07:11
necesitaremos acceder a ellas. 00:07:16
Si no podemos acceder al gasto que tiene un vehículo, ¿de qué nos sirve ese vehículo? 00:07:18
Si esa aplicación va a gestionar precisamente los gastos de los vehículos. 00:07:23
Si yo no puedo acceder a ella, ¿de qué me sirve? 00:07:26
Pensaría entonces uno que poner ahí un privado no tiene ningún sentido. 00:07:30
Claro, es que tenemos que acceder a la propiedad, pero la forma de hacerlo no es directamente así. 00:07:35
Si yo tengo por aquí otra clase, imaginaos que estoy aquí en otro paquete. 00:07:42
Estoy aquí en mi main y quiero instanciar un vehículo. 00:07:45
Voy a guardar esto. 00:07:49
Yo quiero instanciar aquí un vehículo. 00:07:53
Estoy fuera del paquete, estoy en otro lado. 00:07:55
Me voy a hacer un vehículo por aquí. 00:07:58
Vale, he puesto el nombre mal porque la clase no se llama vehículo. 00:08:03
Claro que no, ¿la clase cómo se llama? 00:08:07
Esta clase en realidad. 00:08:09
Ejercicio 5. Vehículo. 00:08:12
He puesto el nombre mal, obviamente, por eso el compilador me dice 00:08:14
¿Qué me estás poniendo? 00:08:17
Ah, claro, es que no hay ninguna clase que se llame así. 00:08:19
Hay una clase que se llama así. 00:08:22
Esto sí. 00:08:25
Así sí hay una clase que se llama. 00:08:27
Así sí. 00:08:30
Pero digo, ¡buf! ¡Menudo rollo! 00:08:32
Tener que poner ejercicio de 5 vehículos, ¡qué feo queda todo el rato! 00:08:35
Venga, vamos a poner un import. 00:08:39
Porque somos unos jodidos vagos. 00:08:41
Pues venga, ponemos un import. 00:08:43
¡Hala! Como he puesto un import, ya le puedo quitar esto. 00:08:48
Genero confusión en el caso de que haya otra clase vehículo dentro de este paquete. 00:08:58
Porque si hay otra, entonces vehículo es la del paquete, no esta que estoy importando. 00:09:04
Pero como no es el caso, no hay ninguna otra clase vehículo, no hay problema. 00:09:10
Bueno, pues entonces, efectivamente, si yo esta propiedad la dejo privada, 00:09:14
pues no me sirve para nada. 00:09:19
Porque ahora yo no puedo acceder a ella. 00:09:22
No puedo hacer esto para asignarle valores y gestionar el vehículo. 00:09:24
Se llama así, ¿no? La he puesto bien. 00:09:30
No puedo hacer esto. 00:09:33
Me dice, oye, que no, que no es visible. 00:09:35
Claro que no es visible. 00:09:38
Porque le he puesto este modificador. 00:09:40
Entonces, pues ¿de qué me vale una propiedad privada? 00:09:43
Claro, es que sí hay que dar acceso a esta propiedad. 00:09:47
Pero la forma de hacerlo no es esta. 00:09:50
O sea, no es la forma recomendable, repito. 00:09:53
O la forma que todos hemos acordado en la comunidad Java para utilizar. 00:09:56
Si yo hago esto, claro que lo hago visible, ya está. 00:10:02
¡Hala! Ya se me quitó el rojito. 00:10:05
Le asigno 7, luego la recupero, la multiplico por 12, lo que me dé la gana. 00:10:08
Pero, hombre, esto es muy feo. 00:10:11
La forma de hacerlo es la que dijimos, que era hacerla privada 00:10:15
y ahora habilitar el acceso a esta propiedad mediante ti. 00:10:19
¿Solo estudias tú o es que los demás son muy tímidos? 00:10:25
¿Sois tímidos? Espero que sea eso. 00:10:28
Porque es que la forma asimilada de la comunidad Java 00:10:31
es que las propiedades sean privadas y luego tú habilites unos métodos 00:10:39
para acceder a ellas. 00:10:44
Uno para leer y otro para escribir. 00:10:46
Y así separas los dos accesos, el de lectura y escritura. 00:10:49
Porque si yo pongo aquí el public, estoy de golpe 00:10:54
habilitando acceso para escribir, como aquí, y también para leer. 00:10:59
Con esto estaría leyendo. 00:11:06
Aquí estoy escribiendo la propiedad y aquí estoy leyendo la propiedad 00:11:11
para dársela a un System Output de LN. 00:11:17
Entonces, con el public, yo habilito de golpe acceso tanto a recoger 00:11:19
el valor de la propiedad, como aquí, recogerlo, como a escribirlo. 00:11:24
Pero, sin embargo, si lo hago a través, si yo aquí pongo el privado 00:11:29
y lo hago a través de los get y los set, 00:11:34
que o los escribo a mano, o si tengo un entorno de desarrollo, 00:11:39
pues bueno, venga, que me los genere automáticamente. 00:11:43
Si lo hago a través de los get y los set, ahora ya este método 00:11:46
es el que me habilita la recogida de la propiedad y este método 00:11:51
es el que me habilita la escritura de la propiedad. 00:11:56
Que los dos son públicos, habilito los dos permisos. 00:11:59
Que este lo quiero quitar, he habilitado solo el de escritura. 00:12:03
Que el que quito es este, he habilitado solo el de lectura. 00:12:08
Entonces tengo más margen, tengo mucho más margen de decisión 00:12:13
con los get y los set que con el public de la propiedad. 00:12:19
Por eso es la forma que hemos acordado y que se usa habitualmente 00:12:23
en las entidades, ¿vale? 00:12:27
Entonces ahora yo con estos, aunque la propiedad es privada, 00:12:29
con estos métodos, yo ya el acceso a la propiedad así no puedo. 00:12:31
Pero ¿qué pondría aquí para hacer esto mismo? 00:12:35
Como esto no puedo porque la propiedad es privada, 00:12:39
¿qué sentencia pondríamos para hacer lo mismo? 00:12:42
Para darle 7 a esa propiedad. 00:12:44
Dictadme, v. no es para asignar valor a la propiedad. 00:12:46
Pondríamos esto, ¿vale? 00:12:55
Con esto estaríamos haciendo lo de arriba, pero no a través de la propiedad 00:12:58
porque no puedo, porque es privada. 00:13:02
Lo estaría haciendo a través del set, lo mismo. 00:13:04
Y para hacer esto de aquí, que es la lectura, así no puedo 00:13:06
porque la propiedad es privada. 00:13:10
Lo que haríamos es, ¿qué pondríamos aquí? 00:13:12
Dictadme, ¿eh? 00:13:15
Vale, pero dictadme tal cual, v. get. 00:13:20
Pues lo de arriba y lo de abajo es lo mismo. 00:13:26
Aquí estoy recogiendo la propiedad a través del return del get, 00:13:28
a través del return, y aquí la estoy accediendo directamente. 00:13:33
Pero si la propiedad es privada, esto no puedo. 00:13:41
Entonces lo tengo que hacer a través del get. 00:13:45
Y esta es la forma en la que accederíamos a las propiedades de vehículo, 00:13:47
el get y el set. 00:13:51
Esta es la manera, no esta directamente. 00:13:53
Y para hacerlo así, de hecho, es por lo que se prohíbe el acceso desde aquí 00:13:56
y se hacen estos métodos. 00:14:01
Que esto es obligatorio hacerlo así, no. 00:14:04
No es obligatorio y no puede programar como le dé la gana. 00:14:06
Pero insisto, si tú no te adaptas a los estilos de programación, 00:14:09
no vas a poder interaccionar con los demás. 00:14:13
Las librerías que te descargues para que usen tus entidades 00:14:15
no las van a entender porque ellas van a esperar que haya un get 00:14:18
para recoger la propiedad y cuando llamen a ese get, 00:14:21
tu aplicación va a decir, no existe método get. 00:14:24
Claro, puedes hacer las propiedades, tú puedes programar como quieras 00:14:27
dentro de las posibilidades que te da Java. 00:14:30
Pero si tu aplicación está aislada del mundo, fenomenal. 00:14:32
Pero si no está aislada del mundo, vas a tener problemas. 00:14:35
Bueno, pues aparte de, vale, pues esto venía en cuanto a, 00:14:39
ya habíamos decidido el tipo de dato de la propiedad. 00:14:42
Ahora tenemos algo más que decidir, que es el modificador de acceso. 00:14:45
Pues ya decidimos este porque es una propiedad de una entidad. 00:14:48
Y las propiedades de las entidades se suelen programar así. 00:14:52
Y vale, pues ya está. 00:14:57
¿Y qué más cosas se suelen poner en una clase entidad? 00:14:58
Una clase que representa la realidad de mi aplicación. 00:15:01
Aparte de las propiedades con sus getter y setter. 00:15:03
¿Qué me falta? 00:15:05
Los constructores, ¿no? 00:15:06
Los constructores. 00:15:08
Vale, pues entonces lo normal es que haya siempre un constructor 00:15:09
con parámetros, este de aquí, que el public, ya lo puedo dejar, 00:15:13
ya no me molesta porque sé lo que significa, 00:15:21
y es que permito usar el método constructor desde fuera de la clase. 00:15:23
El super sí que lo quito porque eso sí que seguimos sin saber lo que significa. 00:15:29
Vale, este es mi constructor sin parámetros, perdón, con parámetros. 00:15:33
Como solo tengo una propiedad, pues este constructor solo tiene una. 00:15:38
Claro, ¿qué ha pasado cuando yo he hecho este constructor? 00:15:41
¡Qué paz! 00:15:44
Me apareció el rojo ahí. 00:15:46
¿Os acordáis por qué me ha aparecido este rojo ahí? 00:15:48
Cuando este constructor no estaba, cuando este constructor no estaba, 00:15:51
y yo tenía mi clase sin ningún constructor, sin ninguno, 00:15:56
este main encantó de la vida, instanciando el vehículo. 00:16:00
Cuando este constructor yo lo hago, lo incluyo, 00:16:05
el main ya, ala, se fastidió, ya no me deja instanciar así. 00:16:12
¿Por qué? 00:16:19
Claro, porque cuando no hay constructor, cuando no hay ninguno escrito, 00:16:23
recordad que entonces Java se inventa uno sin parámetros, vacío, 00:16:28
y asume que está ahí, se lo inventa, aunque yo no lo vea. 00:16:34
Pero desde el momento en que hago uno, ese que se inventó desaparece, 00:16:37
ese que se inventó desaparece, porque ya está el que yo he hecho, 00:16:40
y el que yo he hecho necesita un parámetro, y aquí lo estoy llamando mal, 00:16:43
con lo cual no me deja. 00:16:47
Lo habitual es poner en las entidades los dos constructores, 00:16:49
el con parámetros y el sin parámetros también, 00:16:53
para dar la posibilidad de instanciar con parámetros o sin ellos, 00:16:56
porque alguien le puede dar la gana instanciar un vehículo 00:16:59
y luego pasarle las propiedades más tarde, ponerlo set. 00:17:03
Puede ocurrir, ¿no? 00:17:08
Entonces, lo relativamente habitual en las clases entidad 00:17:10
es que tengan este constructor con parámetros 00:17:15
y también tengan uno vacío, que no haga nada, 00:17:18
y tener uno vacío que no hace nada, 00:17:22
lo que permite es ahora ya que la gente pueda hacer esto, 00:17:25
puede instanciar un vehículo sin más, porque puede ser interesante, 00:17:29
yo puedo querer instanciar vehículos, 00:17:34
pero todavía no saber el gasto, ponérselo más tarde, 00:17:36
a lo mejor todavía no lo sé. 00:17:39
Entonces yo habilito las dos maneras de crear vehículos. 00:17:41
Habilito una manera en la cual ya sé lo que vale su propiedad 00:17:45
y lo instancio con ese valor, porque ya lo sé. 00:17:49
Pero habilito también una segunda manera, 00:17:52
por si alguien quiere instanciar un vehículo 00:17:55
y todavía no sabe cuál es el valor de esa propiedad, 00:17:57
pues lo habilito y ya lo fijo más tarde con el set. 00:17:59
Por eso lo habitual en una clase entidad por defecto 00:18:03
es que figuren los dos, 00:18:06
y así das la opción de cada uno que instancie como le dé la gana. 00:18:08
Eso es lo que aparece siempre por defecto 00:18:12
en cualquier clase entidad que veáis por ahí. 00:18:14
Las propiedades privadas, los getter y los setter, 00:18:16
un par para cada uno de ellos y los constructores. 00:18:20
Pero si es lo que explicamos el otro día. 00:18:27
¿Pero lo ha repasado del martes aquí? 00:18:30
Claro, es que no vale entenderlo. 00:18:37
Entenderlo en clase está fenomenal. 00:18:40
Ya, ya lo sé, no está grabado, pero bueno, 00:18:43
porque falló la grabación. 00:18:46
Pero hombre, vosotros ni la responsabilidad de tomar notas. 00:18:48
Entonces entenderlo está muy bien, en lo deseable. 00:18:52
Pero el segundo paso a entenderlo es, 00:18:58
ahora lo miro en casa para consolidarlo. 00:19:00
Porque lo que has entendido, si no lo miras, 00:19:03
lo normal es que se te olvide. 00:19:05
Entonces claro, yo no puedo estar explicando. 00:19:08
Ahora, de hecho todo lo que he hecho en este rato que llevamos de clase, 00:19:10
que llevamos media hora, ha sido todo repaso. 00:19:14
No ha avanzado nada nuevo, ha sido todo repaso. 00:19:18
Pero claro, todavía más repaso, 00:19:21
porque no lo repaséis en casa. 00:19:26
Bueno, pues lo de los Getty lo sé, 00:19:31
lo van madurando, porque hombre, es fácil de decir lo entendiste. 00:19:33
El otro día es muy fácil de entender según lo vas usando, 00:19:36
no vas a tener problema en eso. 00:19:39
Y aparte es que lo acabo de explicar, 00:19:41
acabo de explicarlo tal cual, otra vez. 00:19:43
Vale, pues entonces en las clases entidad lo habitual es esto. 00:19:46
Ya la hemos hecho, nuestra clase vehículo. 00:19:49
Su propiedad, estos dos métodos para permitir 00:19:51
recuperar el valor de la propiedad, 00:19:55
o fijarle un valor, el que a mí me dé la gana, 00:19:57
y los dos constructores, 00:20:00
para permitir instanciar de la manera que yo quiera. 00:20:02
¿La clase vehículo está? 00:20:05
¿La clase vehículo está algo más? 00:20:07
Pues no. 00:20:09
Vale, mi aplicación tiene otra. 00:20:10
¿Cómo está? 00:20:12
Sí. 00:20:13
Como buenas prácticas de programación, 00:20:14
¿los de Getty 7 tienen un orden con respecto a los constructores 00:20:17
o es diferente? 00:20:22
Yo creo que no. 00:20:24
A ver, yo por costumbre pongo propiedades, 00:20:25
constructor y Getty 7, 00:20:27
pero eso sí que yo creo que lo puedes ver de muchas maneras distintas. 00:20:29
Lo he visto de esa manera. 00:20:32
Me imagino que lo habrás visto constructor y Getty 7 después. 00:20:34
Claro, o sea lo que sí que suele ser relativamente habitual, 00:20:37
pero relativamente, 00:20:41
es que propiedades primero y métodos después. 00:20:42
Pero incluso digo relativamente, 00:20:45
porque en las aplicaciones que tienen interfaz gráfica 00:20:47
es relativamente habitual que uno se encuentre 00:20:49
métodos antes y los elementos gráficos después. 00:20:51
Pero bueno, en general eso sí que suele ser, 00:20:54
propiedades y métodos. 00:20:56
Dentro de los métodos, 00:20:58
constructores antes y Getty 7 después, 00:20:59
yo tengo la costumbre de constructores antes 00:21:01
y Getty 7 después. 00:21:03
Ahora lo he hecho después porque es que 00:21:05
como íbamos primero por la propiedad, 00:21:07
pero yo tengo esa costumbre 00:21:10
y seguramente tengo esa costumbre 00:21:11
porque es que es lo que he visto siempre 00:21:13
y lo que he hecho siempre. 00:21:14
De hecho los vamos a colocar delante 00:21:16
porque yo me siento más cómoda 00:21:18
si los veo primero los constructores, 00:21:19
porque es lo que estoy acostumbrada. 00:21:21
¿Vale? 00:21:25
Vale, pues entonces. 00:21:29
Ahora, esta clase está. 00:21:32
Bueno, como esta aplicación 00:21:34
trabaja con el consumo en una distancia, 00:21:35
pues la aplicación ha necesitado 00:21:40
definir una entidad 00:21:42
en la cual se puedan medir distancias. 00:21:44
Entonces, como la aplicación 00:21:47
después de analizarla, 00:21:50
uno ha visto que los recorridos del coche 00:21:52
son trayectorias que pueden ir así, 00:21:55
de cualquier manera. 00:21:57
¿Vale? 00:22:02
O sea, el que le planteó esta aplicación 00:22:03
a alguien le dijo, 00:22:04
oye, los coches pueden hacer trayectorias 00:22:05
de este tipo. 00:22:08
Así, todas como segmentos en línea recta, 00:22:13
así, patapam, patapam. 00:22:15
¿Vale? 00:22:18
Entonces, a ver, esto tiene sentido 00:22:19
porque una trayectoria cualquiera 00:22:21
que uno haga incluso en círculo, 00:22:22
así por papá, 00:22:23
pues siempre tiene una aproximación 00:22:25
bastante fiable, ¿verdad? 00:22:27
Siempre la tiene mediante segmentos rectos pequeñitos. 00:22:28
¿Verdad? 00:22:31
Esto es la segmentación de las trayectorias. 00:22:33
Me gustan tanto las matemáticas. 00:22:39
Entonces, tiene sentido 00:22:42
cuando en una aplicación 00:22:43
tienes que emular trayectorias, 00:22:45
pues que esas trayectorias 00:22:49
sean sucesiones de segmentos rectos 00:22:50
porque las sucesiones de segmentos rectos 00:22:54
te permiten aproximar 00:22:56
cualquier trayectoria circular 00:22:59
con bastante fiabilidad. 00:23:02
Claro, cuanto más pequeñitos 00:23:06
sean los segmentos más, obviamente. 00:23:07
Si los segmentos son muy pequeñitos, 00:23:09
la aproximarás muy bien. 00:23:10
Si los segmentos rectos son muy grandes, 00:23:12
la aproximarás fatal. 00:23:14
Pero bueno, la forma de aproximar 00:23:15
cualquier trayectoria 00:23:18
siempre es mediante una sucesión 00:23:20
de segmentos rectos. 00:23:21
Todo esto es lo que pensó el que 00:23:23
diseñó esta aplicación, mini aplicación, 00:23:25
que a nosotros ya nos da diseñada, claro. 00:23:29
Pero bueno, el que la pensó dijo, 00:23:32
vale, pues entonces yo la tengo que recoger 00:23:33
de alguna manera en mi aplicación 00:23:35
el concepto trayectoria 00:23:37
porque tengo dos conceptos. 00:23:39
El concepto vehículo, ya está recogido, 00:23:41
y el concepto trayectoria. 00:23:43
Jolín, ¿cómo recojo eso? 00:23:45
Vale, pues si uno piensa que una trayectoria 00:23:47
es una sucesión de segmentos rectos, 00:23:49
una idea posible, de las muchas posibles, 00:23:51
es, ah bueno, pues una trayectoria 00:23:53
se puede definir por la sucesión 00:23:55
de los puntos, ya está, puntos en un plano. 00:23:57
Es la forma más sencilla 00:24:00
de definir una trayectoria, 00:24:02
que es un conjunto de puntos en el plano 00:24:04
porque así necesito solo una clase, 00:24:07
la clase punto, 00:24:09
y el conjunto de puntos, 00:24:11
que eso ya es una colección de datos, 00:24:13
sea una raíz, sea la que sea, 00:24:14
es la trayectoria. 00:24:16
Es una idea muy natural 00:24:18
que se le puede ocurrir a alguien 00:24:20
para recoger en una aplicación 00:24:21
esta realidad, la realidad trayectoria. 00:24:24
Pues un conjunto de puntitos. 00:24:28
Dado que los segmentos rectos 00:24:32
pueden simular cualquier trayectoria, 00:24:34
bueno, esto forma de nuevo 00:24:36
parte de la fase de análisis y diseño. 00:24:37
A nosotros ya nos la han hecha 00:24:40
y nos dicen, 00:24:42
la clase que tú necesitas 00:24:43
es la clase punto 00:24:45
y cuando tengas muchos puntos 00:24:47
tendrás una trayectoria. 00:24:49
Perfecto, estupendo. 00:24:51
Vale, pues ahora llegaríamos 00:24:52
a la siguiente parte. 00:24:53
Muy bien, y la clase punto 00:24:54
¿por qué se caracteriza? 00:24:55
Hombre, pues los puntos en un plano 00:24:56
sabemos cómo se caracterizan, 00:24:59
los puntos en un plano 00:25:01
¿cómo se caracterizan? 00:25:02
Pues sus dos coordenadas, 00:25:05
la x y la y, ¿no? 00:25:06
Con dos coordenadas, 00:25:07
la coordenada x y la coordenada y 00:25:08
ya tenemos el punto en el plano. 00:25:10
Un plano siempre tiene un eje de referencia, 00:25:12
un eje de referencia 00:25:14
que es su eje de abscisas 00:25:15
o su eje de ordenadas. 00:25:16
Pues un par de coordenadas 00:25:18
define completamente 00:25:21
una posición en el plano. 00:25:22
Igual que un trío de coordenadas 00:25:24
define completamente 00:25:26
una posición en el espacio. 00:25:28
Pero aquí estamos hablando 00:25:29
de trayectorias en el plano, 00:25:30
en el suelo, 00:25:32
que es por donde va el coche. 00:25:33
Si habláramos de trayectorias en el espacio 00:25:34
porque es esto mismo, 00:25:36
pero con aviones, 00:25:37
pues lo único que cambiaría 00:25:39
es que el punto se caracteriza 00:25:40
por tres coordenadas 00:25:42
porque en el espacio 00:25:43
se caracterizan las posiciones 00:25:44
por tres coordenadas. 00:25:46
Pero aquí hablamos de trayectorias 00:25:47
de un coche que va en plano. 00:25:49
Luego, con puntos de dos coordenadas, 00:25:50
suficiente. 00:25:52
Bueno, pues todo eso 00:25:53
es a lo que llega la conclusión, 00:25:54
el que está analizando esta aplicación 00:25:56
y ya dice, pues ya está, 00:25:57
necesito una clase punto 00:25:59
y esa clase punto tiene dos propiedades. 00:26:01
X e Y. 00:26:04
Y se acabó. 00:26:05
Y ahora ya, 00:26:06
cuando ya tenemos las únicas dos entidades 00:26:07
que necesitamos, 00:26:10
vehículo y punto del plano, 00:26:11
ya uno aborda los requisitos de la aplicación. 00:26:13
Pues dado un conjunto de puntos, 00:26:15
lo que el coche ha consumido en la trayectoria. 00:26:17
Pues cuál es la mayor trayectoria posible 00:26:19
que puede hacer un coche 00:26:21
que no quiere consumir 00:26:22
más de tres kilómetros. 00:26:23
Por los requisitos que toquen. 00:26:24
Habrá muchos requisitos. 00:26:26
Y todos ellos se construirán, 00:26:27
se solucionarán, 00:26:29
pues ahora ya creando puntos, 00:26:31
creando coches, 00:26:33
haciendo cuentas para allá, 00:26:34
para acá, etc. 00:26:35
Pero con punto y vehículo 00:26:36
tenemos todas las entidades que necesitamos. 00:26:38
Pues ahora vamos a hacer entonces 00:26:41
la clase punto. 00:26:43
Vale. 00:26:47
Ejercicio 5. 00:26:49
Sí, ejercicio 5 estoy. 00:26:53
Clase punto. 00:26:55
Clase punto, 00:26:57
le damos el nombre lo más explicativo posible, 00:26:58
como siempre. 00:27:00
Propiedades. 00:27:01
Pues ya que estamos, 00:27:03
vamos a hacerlo ya 00:27:04
con la forma general, 00:27:07
la forma habitual, 00:27:09
con propiedades privadas. 00:27:11
Coordenada X, 00:27:13
coordenada Y, 00:27:14
a ver, para no escribir tanto 00:27:15
vamos a llamarlas X, Y. 00:27:16
Y ya está. 00:27:17
X, Y. 00:27:19
Ahora vamos a, 00:27:21
bueno, si le pongo el tipo de dato mejor. 00:27:22
Las coordenadas, 00:27:25
pues podemos definirlas 00:27:26
decimales, enteras, 00:27:27
para no complicarnos ahora la vida, 00:27:28
las coordenadas X, Y son enteras. 00:27:30
Pues el punto 3, 7, 00:27:32
el punto 2, 9, 00:27:33
el punto menos 1, 4, 00:27:34
coordenadas enteras. 00:27:36
Y ahora ya hago los constructores, 00:27:39
el sin parámetros 00:27:42
y el con parámetros 00:27:44
y los getter y setter. 00:27:45
Eso lo hago siempre ya por defecto. 00:27:46
Pues un constructor que use 00:27:53
las coordenadas X, Y 00:27:55
para crear el punto. 00:27:57
Otro constructor sin parámetros. 00:28:00
Este. 00:28:07
Le quito el super 00:28:08
porque no sé lo que significa. 00:28:09
Y ahora ya los getter y setter 00:28:11
para las dos propiedades. 00:28:13
Vale. 00:28:24
Vale, como veis los getter y setter 00:28:28
siempre siguen el mismo convenio. 00:28:31
Es get o set 00:28:33
y luego el nombre de la propiedad 00:28:35
empezando por mayúscula. 00:28:37
En este caso, 00:28:39
como la propiedad 00:28:40
tiene solo un carácter, 00:28:41
pues es directamente 00:28:42
ese único carácter en mayúscula. 00:28:44
Ese es el convenio 00:28:47
para nombrar a los getter y los setter. 00:28:48
Y hay que seguirlo 00:28:50
porque si no, 00:28:51
otras clases que quieran 00:28:52
trabajar con nosotros 00:28:53
no nos van a acceder, 00:28:54
no van a poder. 00:28:56
Hay que seguir. 00:28:58
Vale, ya tenemos vehículo y punto. 00:28:59
Y ahora ya se trata 00:29:01
de hacer la aplicación 00:29:02
que satisfaga los requisitos 00:29:03
que me han pedido. 00:29:04
Pues de cálculo, 00:29:05
de trayectorias, 00:29:06
de consumos, 00:29:07
de lo que sea. 00:29:08
Lo que me pida el cliente. 00:29:09
Pues yo quiero una aplicación 00:29:10
que cuando tú le metas 00:29:11
una trayectoria y un vehículo 00:29:14
me digas cuánto voy a gastar, 00:29:16
por ejemplo. 00:29:17
¿El sin parámetros? 00:29:21
Pues igual, 00:29:23
pero en source, 00:29:24
generar constructor, 00:29:27
using fields también, 00:29:29
pero luego los he deseleccionado. 00:29:30
Para que no use ninguno. 00:29:34
Y entonces te lo creas sin nada. 00:29:35
Y sí, puedes aquí quitar el... 00:29:41
¿Dónde? 00:29:45
Esto. 00:29:47
Que no llame al constructor 00:29:48
de object super 00:29:49
y ya está. 00:29:50
Si quieres, vale. 00:29:51
No lo tienes que... 00:29:53
De todas formas, 00:29:56
el super no molesta nada 00:29:57
porque está llamando ahora 00:29:59
a una clase que no hace nada. 00:30:01
Ahora. 00:30:03
Entonces no es buena práctica 00:30:04
quitarlo porque en otras situaciones. 00:30:06
Entonces no es bueno 00:30:08
que marquéis eso por defecto. 00:30:09
Lo que pasa es que yo 00:30:11
lo estoy quitando 00:30:12
pues porque no aparezcan 00:30:14
nuestros programas 00:30:15
a lo que no sabemos lo que es. 00:30:16
Pero hombre, si está mejor. 00:30:17
En este caso, 00:30:19
va a dar lo mismo 00:30:20
efectos prácticos. 00:30:21
Que esté o no esté. 00:30:22
Pero en general, 00:30:23
en otras situaciones, 00:30:24
si está va a ser siempre mejor. 00:30:25
Pero bueno, yo lo quito 00:30:26
solo para que no aparezca 00:30:27
algo que no hemos visto. 00:30:28
Hay un par 00:30:36
por cada propiedad. 00:30:37
GetX, GetX, GetY, GetY. 00:30:38
Bueno, pues ya tenemos 00:30:46
las dos entidades. 00:30:47
Ahora ya, 00:30:49
¿qué me están pidiendo 00:30:50
a mí hacer? 00:30:51
¿Qué aplicación 00:30:52
se va a ejecutar? 00:30:53
Es decir, 00:30:54
¿qué main 00:30:55
tengo que hacer? 00:30:56
Ahora ya sí. 00:30:57
Con esto he descrito 00:30:58
una realidad. 00:30:59
Y esa realidad 00:31:00
está descrita. 00:31:01
Es como decir, 00:31:02
vale, 00:31:03
yo tengo alumnos, 00:31:04
tengo asignaturas, 00:31:05
tengo profesores 00:31:07
y eso es lo que tengo. 00:31:08
Y así nos quedamos 00:31:09
parados y cruzados 00:31:10
del tanto. 00:31:11
Eso es lo que hemos hecho. 00:31:12
Y ahí viene la siguiente fase 00:31:13
que es, 00:31:14
¿ahora qué tengo 00:31:15
que hacerle con esto? 00:31:16
Tienes alumnos 00:31:17
con profesores. 00:31:18
Tienes que dar 00:31:19
de baja alumnos. 00:31:20
Ese ya es el main. 00:31:21
Es decir, 00:31:22
¿y ahora qué tengo 00:31:23
que hacer con esto? 00:31:24
Ese ya es el main. 00:31:25
Bueno, pues lo que me pidan, 00:31:26
lo que el cliente me diga, 00:31:27
oye, yo es que necesito 00:31:28
que me hagas esto. 00:31:29
Pues vamos a ver 00:31:30
qué es lo que necesitas hacer. 00:31:31
Bueno, 00:31:32
pues... 00:31:33
Ah, 00:31:36
seguimos con la clase punto 00:31:37
porque aquí ya nos han pedido 00:31:38
que le metamos métodos. 00:31:39
Vale. 00:31:41
Declaramos la clase punto, 00:31:43
hemos hecho hasta aquí. 00:31:44
Vale. 00:31:45
A ver, 00:31:46
oye tú, 00:31:47
el que diseñó esto, 00:31:48
que lo diseñó 00:31:49
desde la aplicación, 00:31:50
pues decidió 00:31:51
que le va a venir muy bien 00:31:52
que en la clase punto 00:31:53
haya un método, 00:31:54
un método, 00:31:55
porque ahora mismo 00:31:56
solamente están 00:31:57
las propiedades 00:31:58
constructores y etcétera, 00:31:59
etcétera. 00:32:00
Vale. 00:32:01
No hemos puesto 00:32:02
métodos específicos 00:32:03
para la clase. 00:32:04
Dice, 00:32:05
pues a ver, 00:32:06
va a venir muy bien 00:32:07
a las necesidades 00:32:08
de mi cliente, 00:32:09
le va a venir muy bien 00:32:10
que yo pueda calcular 00:32:11
la distancia 00:32:12
entre dos puntos. 00:32:13
Ahora viene estupendo. 00:32:14
Hombre, 00:32:15
la he de prever 00:32:16
que le vaya a venir estupendo, 00:32:17
porque 00:32:18
la longitud 00:32:19
en kilómetros 00:32:20
de una trayectoria 00:32:21
va a ser una suma 00:32:23
de distancias. 00:32:24
La suma de esta distancia 00:32:25
entre estos dos, 00:32:26
más la suma 00:32:27
de esta distancia 00:32:28
entre estos dos, 00:32:29
más la suma 00:32:30
de esta distancia. 00:32:31
Entonces, 00:32:32
el que está analizando 00:32:33
la aplicación 00:32:34
ha dicho, 00:32:35
a ver, 00:32:36
yo voy a necesitar 00:32:37
poder calcular 00:32:38
dado un punto 00:32:39
la distancia 00:32:40
que tiene respecto a otro. 00:32:41
Lo voy a necesitar, 00:32:42
porque si no, 00:32:43
me va a venir muy bien 00:32:44
la trayectoria. 00:32:45
Tengo que calcular 00:32:46
una suma de distancias, 00:32:47
esta, más esta, 00:32:48
más esta. 00:32:49
Entonces, 00:32:50
el que está analizando 00:32:51
la aplicación 00:32:52
dice, 00:32:53
ah, 00:32:54
me viene muy bien 00:32:55
a mí en el método punto, 00:32:56
el método punto 00:32:57
que es el implicado 00:32:58
en calcular la distancia 00:32:59
de un punto con otro 00:33:00
de la clase, 00:33:01
perdón, 00:33:02
en la clase punto, 00:33:03
me viene muy bien 00:33:04
un método 00:33:05
al que yo le pase 00:33:06
otro punto 00:33:07
y me dé la distancia. 00:33:08
Me va a venir estupendo. 00:33:09
Cuando tenga yo 00:33:10
luego que calcular trayectorias, 00:33:11
hago sumas 00:33:12
te dice, 00:33:13
oye, 00:33:14
por favor, 00:33:15
programa en la clase punto 00:33:16
un método 00:33:17
al que le pasas 00:33:18
como parámetro 00:33:19
otro objeto punto 00:33:20
y te devuelve la distancia 00:33:21
entre ambos, 00:33:22
porque nos va a venir muy bien. 00:33:23
Pues venga, 00:33:24
vamos a meter 00:33:25
ese método 00:33:26
en la clase punto. 00:33:27
Vale, 00:33:28
pues nos vamos 00:33:29
a la clase punto 00:33:30
y ahora vamos a meter 00:33:31
un método. 00:33:32
Este método 00:33:33
obtiene la distancia 00:33:34
entre dos puntos, 00:33:35
¿no? 00:33:36
Pues venga, 00:33:37
vamos a llamarle, 00:33:38
yo qué sé, 00:33:39
calcular distancia 00:33:41
puntos, 00:33:42
empezando con minúscula 00:33:43
los nombres 00:33:44
de los métodos 00:33:45
preferiblemente siempre, 00:33:46
recordad, 00:33:47
calcular distancia. 00:33:48
¿Cómo es de este punto 00:33:49
con otro? 00:33:50
Pues venga, 00:33:51
no es que sea muy bonito 00:33:52
el nombre, 00:33:53
pero vamos a llamarlo 00:33:54
de este punto 00:33:55
con otro, 00:33:56
¿no? 00:33:57
Pues venga, 00:33:58
vamos a llamarlo 00:33:59
de este punto 00:34:00
con otro, 00:34:01
¿no? 00:34:02
Pues venga, 00:34:03
vamos a llamarlo 00:34:04
de este punto 00:34:05
con otro, 00:34:06
¿no? 00:34:07
Pues venga, 00:34:08
no es que sea muy bonito 00:34:09
el nombre, 00:34:10
pero bueno, 00:34:11
calcular distancia 00:34:12
con punto. 00:34:13
Entonces, 00:34:14
este método 00:34:15
está en la clase punto, 00:34:16
luego este método 00:34:17
lo va a llamar un punto, 00:34:18
lo llama un punto, 00:34:19
eso lo tenemos claro. 00:34:20
Vale, 00:34:21
pues entonces, 00:34:22
como parámetro 00:34:23
se pasa otro 00:34:24
desde fuera, 00:34:25
se pasa otro. 00:34:26
Bueno, 00:34:27
pues el parámetro 00:34:28
que pasamos, 00:34:29
¿qué es? 00:34:30
Una variable, 00:34:31
pero que es de tipo punto, 00:34:32
o sea, 00:34:33
es una variable objeto, 00:34:34
una variable objeto 00:34:35
que es de tipo punto, 00:34:36
igual que le podría pasar yo 00:34:37
un int si lo necesitara, 00:34:38
un string 00:34:39
si lo necesitara, 00:34:40
pues es que no necesito esto, 00:34:41
lo que yo necesito 00:34:42
no es esto, 00:34:43
lo que yo necesito 00:34:44
es una variable 00:34:45
objeto 00:34:46
de tipo punto, 00:34:47
esto es lo que yo necesito, 00:34:48
¿vale? 00:34:49
Pues se lo paso, 00:34:50
ya está, 00:34:51
es una variable más, 00:34:52
me da igual que la variable 00:34:53
sea tipo punto, 00:34:54
tipo string, 00:34:55
tipo int, 00:34:56
es una variable, 00:34:57
es una variable tipo objeto, 00:34:58
pero es una variable. 00:34:59
Vale, 00:35:00
pues esta es la variable 00:35:01
de tipo punto, 00:35:02
¿vale? 00:35:03
Entonces, 00:35:04
vamos a hacer 00:35:05
Vale, 00:35:07
pues esta es la variable 00:35:08
que yo le tengo que pasar 00:35:09
desde fuera 00:35:10
para que el método 00:35:11
calcule la distancia 00:35:12
entre este punto 00:35:13
y el que llama al método. 00:35:14
Aquí habrá que calcular 00:35:15
esa distancia. 00:35:16
Antes de seguir 00:35:18
nos planteamos, 00:35:19
vale, 00:35:20
este método queda 00:35:21
doble el cobrador de retorno, 00:35:22
una distancia entre puntos. 00:35:23
Esa distancia, 00:35:24
una distancia, 00:35:25
pues la forma 00:35:26
de recogerla 00:35:27
más genérica 00:35:28
es un número real, 00:35:29
¿no? 00:35:30
Un número decimal. 00:35:31
Pues venga, 00:35:32
que me devuelva un valor. 00:35:33
¡Hala! 00:35:34
Y ahora ya, 00:35:37
llegados aquí 00:35:38
dentro de, 00:35:39
aquí dentro de este método, 00:35:40
ahora ya tenemos aquí 00:35:42
dos objetos puntos 00:35:43
involucrados, 00:35:44
involucrados. 00:35:45
Lo voy a poner aquí. 00:35:50
El método este, 00:35:56
¿qué tiene que hacer? 00:35:57
Tiene que calcular 00:35:58
la distancia. 00:35:59
Entre el objeto punto 00:36:04
que llama al método, 00:36:07
el objeto punto 00:36:18
que llama al método, 00:36:20
y el objeto punto 00:36:25
pasado como parámetro. 00:36:29
El objeto punto 00:36:35
pasado como parámetro, 00:36:40
ya sabemos cuál es. 00:36:41
Es este. 00:36:42
Este es el objeto punto 00:36:43
pasado como parámetro. 00:36:44
Lo pongo aquí dentro. 00:36:45
Este es la referencia. 00:36:46
Esta es la referencia 00:36:48
del objeto punto 00:36:49
pasado como parámetro. 00:36:50
Pero el objeto punto 00:36:52
que llama al método, 00:36:53
¿ese quién es? 00:36:54
¿Quién es ese? 00:36:57
¿Eh? 00:36:58
El objeto entero, 00:37:01
¿quién es? 00:37:02
No, no, no. 00:37:05
El objeto punto 00:37:06
que llama al método. 00:37:07
X, Y son sus propiedades, 00:37:08
pero el objeto entero en sí, 00:37:10
¿cómo puedo acceder yo 00:37:11
al objeto en el que estoy? 00:37:12
Sí, pero aquí estoy en la... 00:37:19
aquí todavía no hay 00:37:21
ningún objeto creado. 00:37:22
Aquí estoy declarando 00:37:23
un método en general 00:37:24
y quiero decir, 00:37:25
el objeto que llame 00:37:26
a este método, 00:37:27
cuando teníamos que 00:37:28
referirnos a S en general, 00:37:29
el objeto que llama 00:37:30
a este método, 00:37:31
¿qué término usábamos? 00:37:32
Dis. 00:37:33
¿Vale? 00:37:35
Ahí la importancia del dis. 00:37:36
Yo tengo que poder 00:37:37
desde un método 00:37:38
referirme el objeto 00:37:39
que llame a este método, 00:37:40
que no sé quién será, 00:37:41
cuando yo tenga un main, 00:37:42
ya veré cuál es, 00:37:43
si es P1, si es P2, 00:37:44
si es P7, 00:37:45
ya veré. 00:37:46
Ahora mismo 00:37:47
lo único que tengo 00:37:48
es un método que me dice, 00:37:49
cuando un objeto 00:37:50
llame a este método, 00:37:51
hará eso. 00:37:52
¿Y cómo puedo yo 00:37:53
referirme desde aquí 00:37:54
al objeto que llame 00:37:55
a este método? 00:37:56
Pues efectivamente, 00:37:57
dis, 00:37:58
para esto servía. 00:37:59
Para referirme 00:38:00
al objeto 00:38:01
que llama 00:38:02
a este método, 00:38:03
y el objeto 00:38:04
que llama 00:38:05
a este método, 00:38:06
tendrá sus propiedades 00:38:07
dis.x 00:38:08
y dis.y. 00:38:09
Y el objeto 00:38:10
punto pasado 00:38:11
como parámetro 00:38:12
tiene punto, 00:38:13
punto, 00:38:14
punto x 00:38:15
y punto y. 00:38:16
Son dos objetos distintos. 00:38:17
Tengo 00:38:18
el objeto 00:38:19
que llama al método, 00:38:20
que es este, 00:38:21
y el objeto 00:38:22
pasado como parámetro, 00:38:23
que es este otro, 00:38:24
y ambos son 00:38:25
objetos de tipo punto. 00:38:26
Y ahora 00:38:27
lo que tengo que hacer 00:38:28
es calcular 00:38:29
la distancia 00:38:30
entre ellos. 00:38:31
¿Vale? 00:38:32
Claro, 00:38:33
ahora entonces 00:38:34
tendría que irme 00:38:35
a las matemáticas 00:38:36
y decir, 00:38:37
si yo tengo 00:38:38
un punto de coordenadas 00:38:39
x e y, 00:38:40
otro punto de coordenadas 00:38:41
x e y, 00:38:42
¿cómo calculo 00:38:43
la distancia? 00:38:44
Bueno, 00:38:45
pues eso 00:38:46
en topología 00:38:47
ya está resuelto. 00:38:48
Y es 00:38:49
esta formulita. 00:38:50
Si estas son 00:38:51
las coordenadas 00:38:52
del primer punto 00:38:53
y estas son 00:38:54
las del segundo punto, 00:38:55
la distancia 00:38:56
la raíz 00:38:58
de esto. 00:38:59
¿Vale? 00:39:00
Pues entonces 00:39:01
aquí 00:39:02
¿cuáles son 00:39:03
las coordenadas 00:39:04
involucradas? 00:39:05
Las coordenadas 00:39:06
del primer punto, 00:39:07
es decir, 00:39:08
del punto 00:39:09
que llama 00:39:10
al método, 00:39:11
¿cuáles serán? 00:39:12
Serán 00:39:13
dis.x 00:39:14
dis.y. 00:39:16
Esas son 00:39:17
las coordenadas 00:39:18
del punto 00:39:19
que llama 00:39:20
al método. 00:39:21
¿Y cuáles son 00:39:22
las coordenadas 00:39:23
del parámetro? 00:39:24
Coordinadas 00:39:25
del parámetro 00:39:26
son 00:39:27
las coordenadas 00:39:28
del parámetro 00:39:29
punto. 00:39:30
El parámetro 00:39:31
pasado. 00:39:32
Las coordenadas 00:39:33
de este parámetro 00:39:34
pasado, 00:39:35
punto, 00:39:36
son 00:39:37
punto.x 00:39:38
punto.y. 00:39:40
Serían 00:39:41
esas. 00:39:42
Para que lo 00:39:43
entendamos, 00:39:44
¿no? 00:39:45
Y ahora 00:39:46
tengo que meter 00:39:47
eso en la 00:39:48
fórmula. 00:39:49
Hasta 00:39:50
aquí 00:39:51
está claro. 00:39:52
Pues tengo 00:39:53
dos puntos 00:39:54
involucrados. 00:39:55
El punto dis, 00:39:56
que es el que 00:39:57
yo paso como 00:39:58
parámetro. 00:39:59
Pero luego 00:40:00
en el main 00:40:01
ya veremos 00:40:02
cuál es. 00:40:03
Ahora estamos 00:40:04
en el main. 00:40:05
Y el punto 00:40:06
que yo paso 00:40:07
como parámetro, 00:40:08
ese. 00:40:09
Vale, 00:40:10
pues si 00:40:11
yo hago 00:40:12
la fórmula 00:40:13
de esto 00:40:14
de aquí, 00:40:15
voy a poner 00:40:16
formulita 00:40:18
que sería 00:40:19
dis.x 00:40:20
menos 00:40:21
punto.x 00:40:22
y esto 00:40:23
al cuadrado 00:40:24
y elevar 00:40:25
al cuadrado 00:40:26
dos veces. 00:40:27
Esto sería 00:40:28
el x1 00:40:29
menos 00:40:30
y1, 00:40:31
perdón, 00:40:32
el x1 00:40:33
menos 00:40:34
al cuadrado 00:40:36
sería esto 00:40:37
primero. 00:40:38
Y el 00:40:39
menos 00:40:41
al cuadrado 00:40:43
sería 00:40:44
más 00:40:45
esto 00:40:46
pero con la 00:40:47
Vale. 00:40:49
Y ahora sería 00:40:51
la raíz 00:40:52
de todo esto. 00:40:53
Con esto he hecho 00:40:54
el x1 00:40:55
menos x2 00:40:56
al cuadrado 00:40:57
más 00:40:58
menos y2 00:41:00
al cuadrado. 00:41:01
Pero tengo que hacer 00:41:02
la raíz cuadrada 00:41:03
de esto. 00:41:04
La raíz cuadrada 00:41:05
en Java, 00:41:06
¿cómo la hacemos? 00:41:07
¿Tenemos que programar 00:41:08
algoritmos 00:41:09
en la raíz cuadrada? 00:41:10
Pues no. 00:41:11
Afortunadamente 00:41:12
tenemos un 00:41:13
algoritmo 00:41:14
que se llama 00:41:15
menos x2 00:41:17
al cuadrado 00:41:18
pero afortunadamente 00:41:19
tenemos un método 00:41:20
que nos lo ha hecho. 00:41:21
¿Os acordáis 00:41:22
cuando queríamos crear 00:41:23
un numeratorio 00:41:24
que usábamos 00:41:25
el math.random? 00:41:26
Pues aparte 00:41:27
del math.random 00:41:28
tenemos math. 00:41:29
Un montón de cosas 00:41:30
para hacer cosas 00:41:31
matemáticas. 00:41:32
Entre ellas 00:41:33
la raíz cuadrada. 00:41:34
Entonces si yo 00:41:35
paso todo esto 00:41:36
a esto de aquí 00:41:37
math.sqrt 00:41:38
y le paso 00:41:39
como parámetro 00:41:40
todo esto 00:41:41
que he hecho 00:41:42
ahí 00:41:43
y ahí 00:41:44
y aquí 00:41:45
y aquí 00:41:46
y aquí 00:41:47
y ahí 00:41:48
Pues esto 00:41:51
ya sería 00:41:52
Espera que aquí 00:41:55
estoy poniendo 00:41:56
this as a repository 00:41:57
vale 00:41:58
double 00:42:01
result 00:42:03
igual a esto 00:42:08
result 00:42:10
y ahora 00:42:12
esta sería 00:42:13
esta fórmula matemática 00:42:14
esta fórmula 00:42:15
siendo x1 00:42:17
la coordenada x 00:42:18
de this 00:42:19
y siendo x2 00:42:20
la coordenada x 00:42:21
de punto 00:42:22
y esto sería 00:42:23
la coordenada y 00:42:24
de this 00:42:25
y esto sería 00:42:26
la coordenada y 00:42:27
de punto del otro 00:42:28
Pues esta misma fórmula 00:42:29
esta misma fórmula 00:42:30
es esto que yo 00:42:31
he escrito aquí 00:42:32
la raíz cuadrada 00:42:33
de esto al cuadrado 00:42:34
más esto al cuadrado 00:42:35
vale 00:42:38
y ahora ya 00:42:39
el método 00:42:40
tiene que devolver 00:42:41
esto como valor 00:42:42
de retorno 00:42:43
porque el método 00:42:44
ya está en la referencia 00:42:45
método 00:42:50
result 00:42:51
ala 00:42:52
el método ya estaría 00:42:55
vale 00:43:00
pues aquí 00:43:01
lo importante 00:43:02
de hacer de este método 00:43:03
cuál era mi objetivo 00:43:04
pues que 00:43:06
doble 00:43:08
primero 00:43:10
que veáis 00:43:11
que quede claro 00:43:12
que las variables 00:43:13
objetos 00:43:14
son como cualquier 00:43:15
otra variable 00:43:16
e igual que puedo 00:43:18
pasar por parámetro 00:43:19
números enteros 00:43:20
números double 00:43:21
claro que puedo pasar 00:43:22
por parámetro 00:43:23
cosas que sean objetos 00:43:24
porque son variables 00:43:25
como otras cualquiera 00:43:26
lo que pasa 00:43:27
es que una variable 00:43:28
objeto 00:43:29
sus datos 00:43:30
están a su vez 00:43:31
en propiedades 00:43:32
porque la variable 00:43:33
objeto en si 00:43:34
es una dirección 00:43:35
de memoria 00:43:36
no lo olvidéis nunca 00:43:37
que punto 00:43:38
en realidad 00:43:39
punto a secas 00:43:40
punto a palo seco 00:43:41
es una dirección 00:43:42
si yo hago un system 00:43:43
println punto 00:43:44
me sale una cosa rara 00:43:45
que no entiendo 00:43:46
claro 00:43:47
es que una variable 00:43:48
objeto 00:43:49
su información 00:43:50
está guardada 00:43:51
en propiedades 00:43:52
está guardada 00:43:53
en casillitas 00:43:54
y cada casillita 00:43:55
tiene su nombre 00:43:56
en este caso 00:43:57
pues claro 00:43:58
punto tiene 00:43:59
su casillita 00:44:00
y punto 00:44:02
tiene 00:44:03
su casillita 00:44:04
yo no accedo 00:44:06
a punto tal cual 00:44:07
porque punto 00:44:08
es un objeto 00:44:09
sino accedo 00:44:10
a sus propiedades 00:44:11
entonces 00:44:12
es su primer objetivo 00:44:13
que empecéis a ver 00:44:14
las variables 00:44:15
objeto 00:44:16
como cualquier 00:44:17
otra variable 00:44:18
que puedo pasar 00:44:19
por parámetro 00:44:20
que puedo devolver 00:44:21
como valor de retorno 00:44:22
en un método 00:44:23
lo que sea 00:44:24
pero claro 00:44:25
su peculiaridad 00:44:26
es esa 00:44:27
que en realidad 00:44:28
accedemos 00:44:29
a las propiedades 00:44:30
de esas variables 00:44:31
no a la variable 00:44:32
sin más 00:44:33
no como cuando 00:44:34
declaramos 00:44:35
int n 00:44:36
accedemos a n 00:44:37
tal cual 00:44:38
n igual a 7 00:44:39
cuando declaramos 00:44:40
p punto x 00:44:41
p punto y 00:44:42
¿vale? 00:44:43
Esa es la primera cosa 00:44:44
que quería dejar clara 00:44:45
con este método 00:44:46
y segunda 00:44:47
segunda 00:44:48
pues que 00:44:49
reviséis 00:44:50
el concepto 00:44:51
de this 00:44:52
el significado 00:44:53
de this 00:44:54
que es fundamental 00:44:55
claro 00:44:56
ya lo hemos usado 00:44:57
cuando teníamos 00:44:58
que distinguir 00:44:59
nombres de variables 00:45:00
this 00:45:01
en una clase 00:45:02
se refiere siempre 00:45:03
al objeto 00:45:04
que está llamando 00:45:05
a este método 00:45:06
que es 00:45:07
el objeto 00:45:08
que está llamando 00:45:09
a este método 00:45:10
el objeto 00:45:11
en el que estoy 00:45:12
se refiere 00:45:13
al objeto 00:45:14
que se lo está llamando 00:45:15
y yo aquí 00:45:16
lo necesitaba 00:45:17
lo necesito 00:45:18
porque quiero 00:45:19
calcular la distancia 00:45:20
entre 00:45:21
el punto 00:45:22
que llama 00:45:23
al método 00:45:24
y el que llama 00:45:25
al método 00:45:26
es el objeto 00:45:27
en el que estoy 00:45:28
que es this 00:45:29
y este 00:45:30
¿vale? 00:45:31
Ahora hay otra cosa 00:45:32
y con esto paramos 00:45:33
es que recordéis 00:45:34
que el this 00:45:35
cuando no hay ambigüedad 00:45:36
era opcional 00:45:37
acordaos 00:45:38
que lo hemos 00:45:39
ya lo hemos dicho 00:45:40
varias veces 00:45:41
entonces 00:45:42
cuando 00:45:43
si yo quito el this 00:45:44
y dejo x 00:45:45
a palo seco 00:45:46
aquí no va a pasar nada 00:45:47
porque x 00:45:49
solo tiene 00:45:51
solo tiene 00:45:53
una declaración 00:45:54
que es esta 00:45:56
la propiedad x de aquí 00:45:57
solo tiene esa 00:45:58
solo tiene esa 00:45:59
no tiene otra 00:46:00
entonces yo podría quitar el this 00:46:01
y sería lo mismo 00:46:03
me seguiría refiriendo 00:46:04
a la propiedad x 00:46:05
del objeto este 00:46:06
en el que estoy 00:46:07
me seguiría refiriendo 00:46:08
pero como aquí 00:46:10
se me ocurriera a mí 00:46:11
por 00:46:12
yo que sé 00:46:13
de repente 00:46:14
entro una variable y 00:46:15
me da la gana 00:46:16
llamarla x 00:46:17
porque quiero hacer 00:46:18
cualquier chorrada 00:46:19
ahí ya la confusión 00:46:20
apareció 00:46:21
y con este x 00:46:22
ahora ya diría 00:46:23
oye 00:46:24
este x 00:46:25
¿cuál es? 00:46:26
¿esta variable 00:46:27
que te has declarado aquí? 00:46:28
o este x 00:46:29
es la propiedad 00:46:30
del objeto 00:46:31
que llama al método 00:46:32
o lo que viene 00:46:33
de arriba 00:46:34
aquí de nuevo 00:46:35
aparece la ambigüedad famosa 00:46:36
en una situación como esta 00:46:37
en la que yo aquí 00:46:38
me invento esta variable 00:46:39
porque me da la gana 00:46:40
aquí sí que tendría 00:46:41
que poner el this 00:46:42
igual 00:46:43
no, ojo 00:46:44
que este x 00:46:45
es la coordenada x 00:46:46
del objeto 00:46:47
que llama al método 00:46:48
no esta variable 00:46:49
que me acabo inventando 00:46:50
pero en este método mío 00:46:51
que yo no tengo 00:46:52
ninguna otra cosa 00:46:53
que se llama x 00:46:54
ninguna otra 00:46:55
pues el this 00:46:56
lo podríais quitar 00:46:57
lo podríais quitar 00:46:58
del x 00:46:59
del y 00:47:00
de todas partes 00:47:01
lo podríais quitar 00:47:02
porque no hay duda 00:47:03
de a quién se está refiriendo 00:47:04
pero si es importante 00:47:05
que cuando no aparezca 00:47:06
sepáis que esa x 00:47:07
es la x 00:47:08
del objeto this 00:47:09
del que está llamando 00:47:10
al método 00:47:11
vale 00:47:12
bueno 00:47:13
esto se entiende mejor 00:47:14
de nuevo 00:47:15
ahora ya haciendo el main 00:47:16
que crea ya los puntos 00:47:17
llama 00:47:18
a los métodos 00:47:19
para puntos concretos 00:47:20
etc 00:47:21
pero eso 00:47:22
lo hacemos ahora después 00:47:23
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
8
Fecha:
12 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:
903.48 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid