Saltar navegación

20241209 POO-Clases-ejer_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 9 de diciembre de 2024 por Raquel G.

16 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, a ver, entonces, aplicación. Una aplicación siempre tiene clases que representan los objetos con los que va a trabajar, ¿vale? Y luego ya una aplicación que hace cosas. Pero primero hay que entender qué clases tenemos. Aquí ya me dicen dos punto pelota, ¿vale? 00:00:00
porque va a ser una aplicación que 00:00:20
va a darnos trayectorias 00:00:22
y para que 00:00:25
nosotros calculemos dándole un botoncito 00:00:27
cuánto me he gastado yo 00:00:29
en esa trayectoria, es una aplicación que vale para eso 00:00:31
yo le meto una trayectoria 00:00:33
le doy al botón y me dice 00:00:35
en esta trayectoria te vas a gastar 00:00:36
10.000 euros, vale 00:00:38
o lo que sea, para eso vale 00:00:41
bueno, pues entonces el que ha 00:00:43
hecho el análisis de la aplicación ha dicho 00:00:44
bueno, pues el diseño que me interesa es 00:00:46
el vehículo, ¿qué dato necesito? 00:00:49
lo que consume mi coche 00:00:52
lo que consume por kilómetro, porque para saber 00:00:54
lo que me voy a gastar en una trayectoria 00:00:56
pues necesito saber lo que consumo 00:00:58
por kilómetro, vale, pues ese dato 00:01:00
lo voy a meter como propiedad 00:01:02
de mi coche 00:01:04
luego habrá una clase vehículo 00:01:05
que se caracterizará 00:01:08
¿por qué? por lo que consume por kilómetro 00:01:10
se podría caracterizar 00:01:12
por más cosas, pues por su color, por su marca 00:01:14
pero a la aplicación todo eso le da igual 00:01:16
A la aplicación esta solo le interesa como propiedad del vehículo lo que consume por kilómetro. 00:01:18
Vale, pues ya tiene una clase bastante caracterizada, que es clase vehículo con una única propiedad. 00:01:25
Una única propiedad que es el gasto por kilómetro. 00:01:41
De los métodos ya hablaremos después. 00:01:48
vale, luego ya 00:01:50
cuando haya una aplicación que arranque 00:01:52
a lo mejor esa aplicación 00:01:54
crea 20 coches 00:01:56
diferentes, uno que gasta 3 00:01:58
otro que gasta 7, otro que 00:02:01
gasta 15, para cada uno de ellos 00:02:02
podrá calcular lo que gasta por 00:02:05
una trayectoria, a ver lo que gasta por una 00:02:06
trayectoria el coche 1, ah pues mira me ha gastado 00:02:08
esto, ahora me voy a crear otro 00:02:10
coche diferente, a ver cuánto 00:02:12
gasta en esa trayectoria, pues ha gastado 1000 00:02:14
vale, en la aplicación ahora ya 00:02:16
uno creará todos los coches que quiera 00:02:18
para calcular lo que gastan 00:02:20
pero clase hay una 00:02:22
ya está, ¿qué significa? 00:02:24
cuando haya coches se caracterizarán por esto 00:02:26
y solo por eso porque no necesitamos 00:02:28
más información para la aplicación 00:02:30
vale 00:02:32
bueno, ¿qué más cosas hace esta aplicación? 00:02:33
pues tiene que registrar 00:02:37
de alguna manera trayectorias 00:02:38
tiene que registrar trayectorias 00:02:40
porque si de lo que se trata 00:02:42
en esta aplicación es de calcular 00:02:45
el gasto en una trayectoria 00:02:46
tiene que existir una trayectoria. Es una trayectoria 00:02:49
esto, ¿verdad? Esto es una trayectoria. 00:02:51
Vale. Entonces yo 00:02:55
puedo querer calcular cuánto va a 00:02:56
gastar mi coche haciendo esto. 00:02:58
Tengo que poner algún método 00:03:01
matemático o algo porque esto es muy complicado 00:03:02
de calcular. Tendría 00:03:04
que medir esto. ¿Cómo mido yo esto? ¿Me pongo aquí 00:03:06
con un metro físico a medirlo? 00:03:08
Hombre, pues puedo hacerlo 00:03:10
y dárselo a la aplicación. Pero entonces, ¿para qué 00:03:12
me sirve la aplicación si voy a tener que venir yo 00:03:14
con un metro a medirlo? Yo lo que quiero 00:03:16
es que la propia aplicación yo le meta 00:03:18
la trayectoria y lo mida. ¿Vale? 00:03:20
Pues entonces, la única 00:03:23
forma que tiene 00:03:24
el ordenador de medirnos 00:03:25
esto, 00:03:28
como él no tiene un metro así para ir haciendo las 00:03:30
curvas, es rectificarla. 00:03:32
Rectificarla. 00:03:36
Es ir marcando puntitos, 00:03:37
¿verdad? 00:03:39
Un puntito aquí, un puntito aquí, 00:03:40
y la línea recta que va de aquí a aquí. 00:03:42
Ahora la rectifico, ahora de aquí a aquí, ahora de aquí a aquí, ahí, por ejemplo, ¿vale? Me voy marcando puntos y la voy rectificando. Vamos a ponerle pocos puntos para no estar aquí mil años, por ejemplo, así y así. 00:03:44
Vale, entonces, si yo a la aplicación le doy estos puntos, 00:04:06
este, este, este, este, la aplicación ya lo tiene muy 00:04:11
fácil porque puede calcular esta distancia con la fórmula que hay 00:04:15
de la distancia, sumarla a esta, sumarla a esta, a esta. 00:04:18
Y tiene una aproximación. 00:04:22
No es la distancia exacta, pero es una aproximación. 00:04:24
Hombre, cuanto más puntitos le dé yo, más aproximada será. 00:04:28
O sea, más real será la medida. 00:04:32
cuanto más puntos le dé 00:04:34
eso ya depende de la pereza 00:04:35
que me dé a mí darle puntos 00:04:38
si le doy 30 puntos 00:04:40
pues va a estar más próxima 00:04:42
a la realidad 00:04:44
si le doy 3 puntos pues va a ser una medida 00:04:45
muy poco próxima 00:04:48
muy mala próxima 00:04:49
¿vale? entonces 00:04:51
el que me hace el análisis me dice, vale, pues entonces 00:04:53
otra clase que necesitas 00:04:56
es la clase que representa 00:04:58
cada uno de estos objetos punto 00:05:00
Porque son elementos imprescindibles 00:05:02
Para calcular la distancia 00:05:04
Son elementos imprescindibles 00:05:05
¿Vale? Pues pensamos 00:05:06
¿Por qué se caracteriza cada punto en un plano? 00:05:08
Exclusivamente 00:05:12
Por la coordenada X y la Y 00:05:12
Ya está 00:05:14
Cada punto en el plano 00:05:15
Vosotros que habéis estudiado matemáticas 00:05:17
Y si no estáis jodidos 00:05:19
Pues cada punto en el plano 00:05:20
Si estas son las coordenadas X e Y 00:05:25
Cada punto en el plano 00:05:27
Sabemos que se caracteriza 00:05:29
por la coordenada Y y la coordenada X. 00:05:30
Este punto se caracteriza por dos coordenadas. 00:05:33
Este punto, ¿por qué se caracteriza? 00:05:35
Por su coordenada Y y su coordenada X. 00:05:37
Eso lo tenemos claro todos, ¿no? 00:05:39
Luego, entonces, ya sabemos 00:05:42
que la clase punto 00:05:43
solo necesita dos propiedades 00:05:46
para caracterizar completamente al punto. 00:05:48
La coordenada X y la Y. 00:05:50
Y ya necesitamos más información. 00:05:52
Pero no habría que meterle en plan 00:05:56
X2, Y2 00:05:57
para marcar el final de la trayectoria o algo así. 00:05:58
Yo ahora estoy caracterizando mis objetos punto. 00:06:03
Luego ya tendré que ver una trayectoria. 00:06:07
Luego ya tendré que ver. 00:06:08
¿Y una trayectoria completa qué es? 00:06:10
A una trayectoria completa es un montón de puntos. 00:06:13
No pasa nada. 00:06:15
¿Qué es un montón de algo? 00:06:16
Una RAI. 00:06:19
Pues ya está. 00:06:19
No nos hace falta más clases. 00:06:20
Nos hace falta la clase vehículo, 00:06:22
que tiene el gasto por kilómetro. 00:06:24
la clase punto 00:06:26
que me permite guardar 00:06:27
cada uno de estos 00:06:29
y ya con esas dos clases yo ya puedo 00:06:30
construir mi aplicación 00:06:33
puedo hacer una raíz de puntos que serán trayectorias 00:06:34
puedo hacer distancias entre puntos 00:06:37
puedo multiplicar eso por 00:06:39
el gasto del vehículo, ya puedo hacer cualquier cosa 00:06:41
pero estoy primero en la parte 00:06:43
de declarar las clases 00:06:45
hemos declarado vehículo 00:06:47
ya hemos visto que a la aplicación no le hace falta 00:06:49
más propiedades, lo que consume por kilómetro 00:06:51
ya vamos a declarar la clase 00:06:53
punto, cuyas propiedades son 00:06:55
dos, coordenada x e y 00:06:58
y ya está 00:07:00
pues entonces 00:07:01
la otra clase que hacemos 00:07:02
la clase punto 00:07:05
que tiene solamente dos coordenadas 00:07:11
coordenada x 00:07:13
y coordenada y 00:07:16
ya está, para ser rápidos 00:07:17
x e y 00:07:19
hasta ahí las propiedades 00:07:20
ahora ya vamos a ver los métodos 00:07:22
que me van a ser útiles a mi 00:07:25
para luego hacer mis cosas 00:07:27
bueno, entonces, para entenderlo mejor 00:07:28
vamos a ir llevando un main en paralelo 00:07:33
vale, este main ya sí que es la aplicación 00:07:35
que se ejecuta 00:07:47
vale, entonces 00:07:49
vamos a hacernos aquí un constructor 00:07:51
un constructor 00:07:53
para poder, a la vez que 00:07:55
creamos un objeto vehículo, darle ya un gasto 00:07:57
por combustible 00:07:59
vamos a hacernos un constructor 00:08:00
este de aquí 00:08:03
donde le quito el public 00:08:05
y el super, porque no entiendo lo que es 00:08:07
¿vale? y me voy a hacer un constructor 00:08:10
en punto también que es más cómodo 00:08:14
para luego crearme el objeto ya dándole 00:08:15
directamente los valores 00:08:17
le quito el public 00:08:19
y esto, vale pues entonces 00:08:28
mi aplicación 00:08:33
main ¿qué va a hacer? pues por ejemplo 00:08:35
vamos a crear un objeto 00:08:37
vamos a decirle primero mi aplicación 00:08:40
main 00:08:43
esto ya si se va a ejecutar, esta es la que 00:08:43
el usuario viene para ejecutar 00:08:47
y para ver cuánto va a gastar en su coche en las diferentes trayectorias. 00:08:49
Vale, pues venga, vamos a decirle que introduzca antes de nada lo que gasta su coche. 00:08:54
¿Cuánto gasta por kilómetro? Porque ese dato es el primero que necesita. 00:09:12
Vale, pues nada, leemos a ver lo que gasta su coche por kilómetro. 00:09:18
Vale, pues venga. 00:09:39
Y ya vamos directamente, como ya somos muy listos y muy rápidos, 00:09:41
vamos a crearnos ya un vehículo 00:09:45
un objeto vehículo, que ya será mi coche 00:09:47
concreto 00:09:49
la marca 00:09:50
no le gusta, no la quiere saber 00:09:53
con ya 00:09:55
directamente 00:10:03
el dato que me den 00:10:04
next double 00:10:07
ala, en lugar de leerlo 00:10:09
en una variable 00:10:13
el dato que me dan 00:10:14
y pasárselo al constructor para que instancie mi coche 00:10:16
pues me ahorro esa variable 00:10:19
me la ahorro, ya directamente 00:10:20
este Scan Next Double se va a quedar 00:10:23
esperando el valor 00:10:25
y tal cual recibe el valor 00:10:26
se lo pasa al constructor y creamos 00:10:29
el coche con ese valor 00:10:31
ala, pues ya tenemos el coche creado 00:10:32
ya está 00:10:35
pero esta aplicación vale 00:10:37
para calcular cuánto va a gastar 00:10:39
en una trayectoria 00:10:41
vale, pues entonces 00:10:42
aquí 00:10:45
¿qué nos interesa aquí? 00:10:47
vamos a decirle, venga, dime qué trayectoria 00:10:49
vas a hacer, entonces habrá que 00:10:51
pedirle los puntos 00:10:53
eso es un rollo porque el usuario va a tener que meterlos 00:10:55
uno por uno, claro, esta aplicación 00:10:57
tendría sentido 00:11:00
hacerla con una interfaz gráfica 00:11:00
y en lugar de pasarle los puntos escribiendo 00:11:03
irlos marcando en la interfaz 00:11:05
y eso es muy fácil, luego lo que 00:11:07
hará el Java simplemente 00:11:09
lo que tú has marcado lo transformará 00:11:11
allá a dos valores x e y 00:11:14
entonces siempre es más cómodo para el usuario 00:11:15
pero como todavía no estamos en interfaz gráfica 00:11:17
en lugar de marcarlo en la pantalla y que él lo transforme 00:11:19
a x e y, vamos a tener que meter 00:11:22
uno por uno, entonces vamos a decirle 00:11:24
ahora ya que introduzca la trayectoria 00:11:26
venga, primero que nos diga 00:11:27
cuántos puntos va a tener, para crear 00:11:32
el array, y así no nos complicamos 00:11:34
la misma 00:11:36
la vida, cuántos puntos 00:11:37
tiene la trayectoria que va a meter usted 00:11:46
entonces como esta aplicación se va a estar toda la vida 00:11:48
ya, calculando precios por 00:11:50
trayectoria, vamos a meter esto en un do while 00:11:52
Para que esté ya la aplicación todo el rato 00:11:54
Pidiéndote trayectorias y calculando 00:11:56
Así de apañados 00:11:58
Claro 00:12:00
¿Por qué? 00:12:01
Hombre, porque cada vez puede meter trayectorias distintas 00:12:07
Hombre, es que 00:12:10
Do while 00:12:17
Habría que decirle en algún momento continuar 00:12:18
Vamos a ponerle aquí abajo 00:12:23
Para que nos quede bonito 00:12:25
Desea continuar 00:12:30
Y ahora leemos aquí la opción 00:12:33
Vamos a ponerle 00:12:37
Sí, no 00:12:49
Con lo cual la opción que sea un char 00:12:50
Esto 00:12:54
Un char 00:12:56
Y ahora ya leemos la opción 00:12:59
Pues ya ves tú que complicación 00:13:01
Leer un char 00:13:03
con next line y quedándome 00:13:03
con el carácter en la primera posición 00:13:06
muy complicado 00:13:08
y ahora ya hace esto 00:13:10
mientras la opción 00:13:12
sea distinta 00:13:13
vale, entonces nuestra aplicación 00:13:19
va a estar todo el rato pidiendo trayectorias 00:13:22
mostrándote el resultado, pidiendo trayectorias 00:13:24
hasta que le digas que ya no quiero más 00:13:25
no voy a hacer más viajes 00:13:27
vale, bueno, pues abrimos 00:13:29
hueco aquí para meterlo de dentro 00:13:32
¿Cuántos puntos tiene la trayectoria? 00:13:33
Vamos a leer los puntos 00:13:35
Vale, ahora vamos a hacer 00:13:36
Nuestro array de objetos punto 00:13:49
Que esta será la trayectoria 00:13:51
Vale 00:13:52
Tengo esto 00:14:04
Pues, colega 00:14:06
Aquí 00:14:08
¿Qué? 00:14:09
Sí, se me está complicando 00:14:15
Pero si le estoy dando a la tecla buena 00:14:16
Qué fuerte 00:14:18
Joder, me ha costado 00:14:20
Vale 00:14:24
New punto, no un puntos 00:14:25
Ahora tenemos el array y ahora viene 00:14:28
Lo peor 00:14:35
Porque es pedir 00:14:36
Las coronas de los puntos uno a uno 00:14:39
Para que cuando probemos esto no sea tan 00:14:41
Rollo, vamos a generarlas aleatoriamente 00:14:43
¿Os parece? 00:14:46
A tomar por saco 00:14:47
Venga, pues vamos a recorrer este 00:14:49
Este array 00:14:51
no con un for each porque vamos a instanciar 00:14:53
los objetos, pero con un for each jamás 00:14:56
jamás 00:14:58
jamás 00:14:59
va a haber momentos en los que no te quede 00:15:00
más remedio, insisto 00:15:06
vale, pues vamos a 00:15:08
ser tan, venga, pongo las llaves 00:15:22
para que no os estreséis 00:15:26
vale, pues vamos a crear 00:15:27
en trayectoria 00:15:30
de i un nuevo 00:15:32
punto con el 00:15:38
constructor que recibe los dos parámetros 00:15:40
y le voy a dar dos puntos 00:15:42
aleatorios como ya hicimos puntos 00:15:44
aleatorios el otro día 00:15:46
math.random 00:15:48
me genera un aleatorio entre 0 y 1 00:15:50
multiplico por 100 para que 00:15:52
me genere un aleatorio entre 0 y 100 00:15:54
y otro 00:15:56
aleatorio entre 0 y 100 para este 00:15:58
ala 00:16:00
pues ya he creado una trayectoria 00:16:04
aleatoria 00:16:07
de numPuntos. 00:16:08
¿Vale? Luego 00:16:15
la clase punto 00:16:16
que está ahí, pero ¿cuántos puntos? Tengo el punto 00:16:19
de no sé qué, el segundo punto, el tercer punto. 00:16:21
La clase punto es 00:16:23
una clase con dos propiedades 00:16:24
y luego cuando haya 00:16:27
un main que haga puntos, pues 00:16:29
habrá tantos puntos como uno quiera. 00:16:31
Entonces, en este main en particular 00:16:33
la aplicación ha decidido 00:16:34
que va a trabajar con trayectorias 00:16:36
que van a ser 00:16:39
Arrays de puntos 00:16:40
Ha decidido eso, vale, pues entonces usa 00:16:42
Un array de puntos, ya está 00:16:44
Podríamos usar puntos sueltos 00:16:46
Lo que fuera, pero esta aplicación en particular 00:16:48
Usa un array de objetos punto 00:16:50
Muy bien 00:16:53
Pues nada, ¿de cuántos? De los que me digan 00:16:53
Y ahora ya los voy rellenando 00:16:56
Vale, pues hasta aquí 00:16:58
Tenemos la trayectoria, ¿está claro? 00:17:00
Vale, dime 00:17:04
¿Cómo? 00:17:04
¿Esto? 00:17:08
vale, ya a partir de ahora 00:17:10
aunque no entendemos todavía muy bien 00:17:12
porque no conocemos métodos estáticos 00:17:14
usad esto de aquí 00:17:16
cada vez que queráis generar un número aleatorio 00:17:18
entre 0 y 1 00:17:20
decimal, entonces como entre 0 y 1 es muy pequeñito 00:17:21
lo multiplicáis luego para extender 00:17:24
el intervalo al tamaño que queráis 00:17:26
es una forma cómoda de generar 00:17:28
algo pseudo aleatorio 00:17:30
que no aleatorio porque la aleatoriedad no existe en el mundo 00:17:32
no existe 00:17:34
¿y por qué no existe? 00:17:36
todo está condicionado por 00:17:38
influencias externas 00:17:44
con lo cual no hay aleatoriedad 00:17:46
entonces si yo tiro la cara de una moneda 00:17:47
¿cuál es? 00:17:49
no, porque me falta información, pero eso significa que la información no exista 00:17:52
si tuviera toda la información 00:17:55
de velocidad del aire, de la gravedad 00:17:57
de en qué punto estamos de la trayectoria terrestre 00:17:59
pero esa información no la tengo ni la sé procesar 00:18:01
bueno, está claro, ¿no? 00:18:03
vale 00:18:08
el caso es que ahora 00:18:08
a ver, el caso es que ahora 00:18:10
lo que tiene que hacer mi aplicación 00:18:14
es sumar 00:18:16
ahora ya, mi array es este 00:18:17
este es mi array, con estos puntitos 00:18:20
ahora, lo que tiene que hacer mi aplicación 00:18:22
ahora es hacer una suma acumulativa 00:18:25
¿de qué? de esta primera distancia 00:18:26
más luego esta 00:18:29
más luego esta, más luego esta, más luego esta 00:18:30
luego tiene que hacer una suma acumulativa 00:18:33
¿de qué? de distancias 00:18:35
entre dos puntos 00:18:37
Vale, pues ahora nos queda la parte de 00:18:38
Oye, que bien me vendría un método 00:18:40
Que me calcule la distancia entre dos puntos 00:18:43
¿Dónde pongo ese método? 00:18:46
Pues como ese método tiene que ver con puntos 00:18:49
Es con lo que trabaja, con puntos 00:18:51
Vamos a meter ese método en la clase punto 00:18:53
¿Vale? 00:18:55
Bueno, vamos a meter este método 00:18:56
Calcular distancia en la clase punto 00:18:58
Nos vamos a la clase punto 00:18:59
Vale 00:19:02
La distancia que va a ser 00:19:09
Entre dos puntos 00:19:11
Siempre. 00:19:14
¿Entre qué dos puntos? 00:19:15
Pues nosotros ya sabemos que a este método lo va a llamar un objeto punto. 00:19:17
Ahí ya tenemos uno. 00:19:22
Es decir, este método al estar en la clase punto, 00:19:24
lo llamará un objeto punto en particular. 00:19:26
Y trabajará este método con las propiedades del objeto punto que lo llama. 00:19:30
Hasta ahí lo sabemos, ¿no? 00:19:35
Entonces, las coordenadas del punto que llama al método 00:19:36
Ya sabemos cuáles son 00:19:45
Estas, estas x e y de aquí arriba 00:19:53
Son estas de aquí 00:19:56
Estas serán las coordenadas del punto que llame al método 00:20:02
Que también las podemos llamar así 00:20:04
Recordad el dis 00:20:07
Que significa el objeto que llama al método 00:20:08
Me da igual poner x e y 00:20:13
que this.x this.y 00:20:15
this.x 00:20:17
lo pondré si hay 00:20:19
ambigüedad porque hay alguna otra variable 00:20:20
que se llame también x 00:20:23
vale, pues entonces ya tenemos el primer punto 00:20:24
el que llama al método 00:20:27
cuyas propiedades son las de arriba 00:20:28
es decir, si aquí 00:20:30
a este método lo llamara 00:20:32
por ejemplo 00:20:34
trayectoria 00:20:35
de 0 00:20:38
punto distancia 00:20:40
este método distancia 00:20:42
cuando dice 00:20:46
coordenadas x e y, estas de aquí 00:20:49
x e y, ¿a cuáles estaría 00:20:51
refiriendo? A las de este, que es el que llama 00:20:53
al método, a las de ese se estaría refiriendo, vale 00:20:55
pero es que la distancia 00:20:57
es entre dos, vale 00:20:59
pues el otro punto 00:21:01
esto 00:21:03
como va a devolver una distancia 00:21:05
la distancia es en double 00:21:06
ya le ponemos double 00:21:08
vale, y el otro punto 00:21:10
con el que hay que calcular la distancia porque se calcula 00:21:13
entre dos, lo dice el enunciado 00:21:15
Te dice, el otro punto, pásaselo como parámetro desde fuera, pásalo como parámetro. 00:21:16
Luego este método necesita que le pasemos un segundo punto, 00:21:23
pero esta vez que se lo pasemos como parámetro, para calcular la distancia 00:21:28
entre el que llama el método, que será este o el que sea, 00:21:32
y el que le pasamos aquí como parámetro, el punto que sea, otro punto cualquiera. 00:21:37
Por ejemplo, si yo hago esta llamada, si hiciera esta, que no es la que tengo que hacer ahora, 00:21:42
si hiciera esta, este método, la idea es que me calcule la distancia entre el que llama al método y el que paso como parámetro. 00:21:53
Ahí están los dos puntos. 00:22:01
El que lo llama y el que es pasado. 00:22:02
Luego, este método, ¿cómo se declarará? 00:22:06
Este método se declarará, aquí tengo que pasar un único parámetro, un único parámetro. 00:22:08
y ese único parámetro 00:22:15
¿de qué tipo es? 00:22:17
es int, si fuera int, pues le pasaría esto 00:22:19
pero es que no es int 00:22:21
lo que yo le quiero pasar es 00:22:23
esto 00:22:24
un objeto de tipo punto 00:22:25
esto es lo que le quiero pasar 00:22:28
pues ya tengo ahí los dos puntos 00:22:29
el que llama al método y el que le paso como parámetro 00:22:32
que tiene que ser de esta clase 00:22:35
¿no? ya estuvimos 00:22:36
viendo el jueves 00:22:39
cuando vimos esto de profesor 00:22:40
que ahora ya es el momento 00:22:43
en que sabemos hacer clases 00:22:44
ya uno puede declarar todas las variables 00:22:46
que necesite de ese tipo 00:22:48
de esa clase que haya hecho 00:22:49
aquí necesitábamos una propiedad 00:22:51
que fuera de clase departamento 00:22:54
porque el profesor tiene un departamento 00:22:55
aquí es otro ejemplo 00:22:58
aquí necesitamos 00:23:00
pasar al método 00:23:02
un objeto que sea de tipo punto 00:23:04
pues le paso un parámetro 00:23:06
que es una variable, pero es una variable objeto 00:23:08
y esa variable ¿de qué tipo es? 00:23:10
de esta, vale 00:23:12
Entonces ahora tendremos aquí ya las otras coordenadas 00:23:13
Las coordenadas del punto parámetro 00:23:17
Pues cuáles serán 00:23:21
Pues está claro, las coordenadas del punto parámetro 00:23:23
¿Cómo accedo yo a las coordenadas del punto parámetro? 00:23:26
Pues punto X y punto Y 00:23:28
¿No? Punto es un objeto punto 00:23:32
¿Cómo accedo a las propiedades que tiene dentro? 00:23:34
¿Qué son estas? Pues con el operador punto 00:23:38
pues entonces 00:23:42
estas son las coordenadas 00:23:44
del punto que llama el método 00:23:48
y estas son las coordenadas del parámetro 00:23:50
ahora lo único que tengo que hacer 00:23:52
es aplicar la fórmula de la distancia 00:23:54
la fórmula de la distancia te dice aquí que es la raíz cuadrada 00:23:56
de esto 00:23:58
pues vamos a aplicar esa fórmula 00:24:00
y se acabó 00:24:02
entonces 00:24:03
ya lo puedo hasta devolver directamente 00:24:04
return 00:24:07
la raíz cuadrada 00:24:09
de la raíz cuadrada de la diferencia de las coordenadas x al cuadrado, 00:24:11
x menos punto x al cuadrado, 00:24:23
que la forma más cómoda de elevarlo al cuadrado es multiplicarlo por sí mismo, 00:24:28
para no anidar muchos más, 00:24:37
esto más lo otro que me dice la fórmula, 00:24:43
más 00:24:46
la diferencia de las coordenadas 00:24:46
y al cuadrado 00:24:50
la bajo aquí abajo 00:24:50
más 00:24:53
y esto es y 00:24:54
ya tengo el método hecho 00:25:09
vale, aquí lo importante es entender 00:25:11
que desde el momento en que uno tiene una clase declarada 00:25:14
ya puede declarar 00:25:16
todos los objetos que le den la gana de esa clase 00:25:18
donde los necesite 00:25:20
aquí lo hemos necesitado como parámetro 00:25:22
aquí lo habíamos necesitado como propiedad 00:25:24
del objeto profesor 00:25:28
¿vale? aquí en el main 00:25:29
pues lo hemos necesitado como array 00:25:32
es un tipo más, lo que pasa es que es un tipo objeto 00:25:33
con propiedades dentro 00:25:36
vale, pues distancia ya está 00:25:37
¿vale? 00:25:39
entonces, había más métodos de aquí que 00:25:43
había que hacer 00:25:45
vehículo.con 00:25:47
el método distancia 00:25:49
y ahora 00:25:50
¿qué tiene que hacer esto? 00:25:52
Ahora hay que hacer, vale, en punto ya tenemos 00:25:56
lo que había que hacer, un método de distancia. 00:25:58
Ahora, en la clase vehículo, 00:26:00
un método que reciba como parámetro una trayectoria 00:26:02
representada por la raíz de objetos 00:26:04
y muestre lo que ha gastado ese vehículo 00:26:07
en hacer el recorrido. 00:26:09
Pues venga, estupendo, 00:26:11
pero cuando tengamos ese método, 00:26:13
le pasaremos esa trayectoria que acabamos de hacer 00:26:14
y listo. 00:26:17
Pues ese método estará aquí. 00:26:19
Ese método que me va a devolver a un gasto, 00:26:23
pues da a ver, gasto total a ese método que hay que pasarle una trayectoria, 00:26:25
es decir, un conjunto de puntos, pues a este método le vamos a pasar un array de objetos punto. 00:26:33
Y ahora, este método ya, tendremos que hacer aquí los cálculos para que sume las distancias de los puntos 2 a 2 y lo devuelva. 00:26:43
Y cuando tengamos este método, ya mi main se queda comodísimo. 00:26:52
porque ya en mi main ya tengo una trayectoria concreto 00:26:55
y ahora ya puedo mostrar aquí 00:26:58
el gasto es 00:27:00
y llamo al método para este vehículo 00:27:04
mi vehículo como se llamaba 00:27:11
mi coche 00:27:13
pues mi coche punto gasto total 00:27:14
al que le paso la trayectoria 00:27:19
y mi main ya está 00:27:20
mi coche tiene un método gasto total 00:27:22
que tengo que hacer, está sin hacer 00:27:26
y ese método gasto total 00:27:28
sé que si le paso una raíz de puntos 00:27:30
pues me dice 00:27:33
lo que gasta, pues ya está 00:27:36
mi main yo le paso el array de puntos 00:27:37
ya concretos que me ha metido 00:27:39
el cliente en ese momento 00:27:41
me ha metido un array concreto, este 00:27:43
que lo acabo de construir, me ha metido ese 00:27:45
se lo paso al método 00:27:47
y ya 00:27:49
el método me calculará eso 00:27:51
y lo muestro, deseo continuar 00:27:53
pues lo que sea 00:27:55
¿qué nos falta en la aplicación? hombre el método 00:27:56
que todavía no lo hemos hecho, que nos ha quedado vacío 00:27:59
nos falta este método 00:28:01
cuando lo tengamos ya el main ya está 00:28:03
vale 00:28:05
y sumar todas las trayectorias 00:28:06
dentro del método 00:28:09
claro, el método yo le paso 00:28:11
la trayectoria entera, entonces el método me tendrá que 00:28:13
hacer la suma dentro todo 00:28:15
vale, entonces ahora ya hay que programar este método 00:28:16
que es lo único que nos falta 00:28:19
pero eso es como en punto de si le tenía el método 00:28:20
de distancia 00:28:23
no, porque esa es la distancia entre dos 00:28:24
puntos, esa es la distancia total 00:28:27
claro, es que lo vamos a hacer 00:28:28
Claro, es que lo vamos a usar porque si no se nos complica la vida 00:28:31
Dime 00:28:35
Sí 00:28:35
Vale, pues ahora vamos a hacer este método 00:28:37
Vale, entonces 00:28:42
Este método, ¿qué tiene que hacer? 00:28:45
Vamos a estudiarlo, vamos a analizarlo a ver qué tiene que hacer 00:28:47
Va a recibir todo este array 00:28:49
Este, este, este y este 00:28:51
Pues va a tener que hacer un sumatorio 00:28:53
Una suma 00:28:55
De esta distancia más esta más esta 00:28:56
Vale, pues menos mal que tenemos 00:28:59
Un método distancia 00:29:01
En la clase punto 00:29:02
que si lo llama 00:29:04
un objeto punto y le pasas otro 00:29:06
te devuelve la distancia 00:29:08
hombre, vamos a recorrer el array de trayectorias 00:29:09
vamos a recorrerlos 00:29:12
hasta el penúltimo 00:29:13
y voy a 00:29:15
para cada punto calcular la distancia 00:29:18
entre ese y su siguiente 00:29:20
y ya está, y vamos incorporando eso a la suma 00:29:21
entonces lo que está claro es que este 00:29:24
método va a ser una suma acumulativa 00:29:26
de cosas, eso está claro 00:29:28
que va a ser una suma acumulativa 00:29:30
hasta ahí hemos llegado 00:29:31
entonces esto va a ser así 00:29:33
y ahora va a ser un bucle 00:29:36
este bucle que va a ir recorriendo 00:29:38
dígame 00:29:40
para no poner 00:29:41
el mismo nombre 00:29:45
a propósito para que veáis 00:29:47
claro que da igual el nombre que yo le pongo aquí 00:29:49
al parámetro, que no tiene nada que ver 00:29:51
con el que tú le pasas aquí, luego tú le pasas el que quieras 00:29:52
lo he hecho a propósito 00:29:55
para que no creáis 00:29:57
que se tiene que llamar igual, no hay ninguna razón 00:29:58
para que tenga que llamar igual 00:30:00
vale 00:30:01
yo aquí al parámetro este lo llamo como me da la gana 00:30:02
y luego ya en el main le paso ya 00:30:05
el array que yo quiera con el nombre que tenga 00:30:07
vale 00:30:09
pues que sumando vamos a ir acumulando 00:30:11
la suma 00:30:13
pues vamos a ir a recorrer el array, el array este 00:30:14
que me han pasado como parámetro 00:30:17
vamos a recorrerlo 00:30:18
aquí se podría usar un for each 00:30:20
pero no se adapta bien 00:30:25
porque hemos dicho que este recorrido 00:30:27
lo vamos a hacer hasta el penúltimo 00:30:29
porque en cada parada vamos a sumar 00:30:31
la distancia entre este y su siguiente 00:30:34
luego nos vamos a parar en el penúltimo 00:30:36
el for each lo recorre todos 00:30:38
obligatoriamente, con lo cual nos interesa 00:30:40
mejor el for normal para pararnos en el 00:30:42
penúltimo 00:30:44
pues venga, desde igual a 0 00:30:45
mientras si sea menor que 00:30:48
track.length 00:30:49
menos 1, porque nos vamos a parar 00:30:52
en el penúltimo, nos vamos a parar 00:30:54
en este, para sumar 00:30:56
que la última distancia que sumamos sea entre esta y su siguiente 00:30:58
Incrementando Y 00:31:00
Vale, pues aquí es una suma acumulativa 00:31:04
Con lo cual esto va a ser algo así 00:31:12
Suma más igual 00:31:15
Y aquí 00:31:16
Esto una vez que lo tengamos 00:31:19
Pues ya devolveremos suma 00:31:22
Y ahora lo único que nos falta es 00:31:23
¿Y qué le vamos sumando? 00:31:26
¿Qué le vamos sumando a esta suma acumulativa? 00:31:28
Pues cada uno de estos segmentos 00:31:30
Para cada posición Y 00:31:32
Hay que sumar la distancia 00:31:34
Entre el punto Y y el Y más 1 00:31:36
eso es lo que hay que sumar 00:31:38
para cada posición y la distancia entre i y el i más 1 00:31:39
pues magnífico, porque tenemos un método 00:31:42
distancia en la clase punto 00:31:44
tenemos un método distancia 00:31:46
en la clase punto 00:31:48
que si lo llama un punto y tú le das 00:31:49
otro, te calcula la distancia 00:31:53
entre ambos, pues estupendo 00:31:54
vamos a 00:31:56
llamarle al método distancia 00:31:58
para el punto i 00:32:02
pasándole 00:32:03
tras de i, perdón 00:32:05
pasándole su siguiente 00:32:07
y se acabó, ¿ya está hecho? 00:32:13
pero, pero, pero 00:32:21
pero, no muevo nada 00:32:22
pero se ha añadido una línea 00:32:24
vale, entonces 00:32:32
gracias a que tenemos 00:32:51
el método distancia en la clase punto 00:32:54
gracias a que lo tenemos 00:32:56
cada vez que tenga yo 00:32:58
dos puntos puedo calcular la distancia 00:33:01
entre ellos. En este caso 00:33:03
nos interesa la distancia entre el i y el 00:33:05
iésimo y el siguiente. Pues ya 00:33:07
está, magnífico, gracias a este método. 00:33:09
Con lo cual, ahora ya 00:33:14
el main ya está. 00:33:15
Llama gasto total para la trayectoria 00:33:17
que yo le pase y me lo 00:33:19
devuelve. Vamos a ejecutar 00:33:21
a ver si tenemos algún error. 00:33:24
Gasta 100. 00:33:27
Entonces, ¿cuántos puntos tiene? 00:33:29
Tenemos una trayectoria de 7. 00:33:30
Ups. Ah, este es el scan 00:33:32
No, pero esto es porque no he puesto un scan 00:33:34
Next line este 00:33:37
O sea, los next line estos 00:33:38
O algo así 00:33:41
Esto es porque 00:33:42
No he revisado 00:33:44
Los next line estos 00:33:47
Entonces, main, ¿dónde está? Aquí 00:33:49
Después de leer este número 00:33:50
Se ha quedado 00:33:53
Y aquí el next line ya se ha quedado 00:33:55
Con el salto de línea 00:33:57
Luego aquí me falta 00:33:58
Después de este punto 00:33:59
Un scan 00:34:02
Next line 00:34:04
Para quitar el salto de línea 00:34:06
Vale, pues gasta 100 00:34:10
La trayectoria es aleatoria 00:34:19
Una trayectoria de 7, aleatoria 00:34:20
Pues en esta, si desea continuar 00:34:22
Vamos a darle una más cortita 00:34:24
Venga, 3 puntos 00:34:26
Pues gasta un poco menos 00:34:27
Le vamos a dar una trayectoria 00:34:29
Ahora de 100 puntos 00:34:33
A ver cuánto gasta, pues un huevo 00:34:34
Vale 00:34:36
Ala 00:34:37
Bueno 00:34:39
Funciona, está bien hecho 00:34:42
Vale 00:34:44
¿Dudas? 00:34:44
No, todo no puede ser 00:34:49
No te funciona 00:34:51
Pero después de funcionarme 00:34:54
Me voy a ir 00:34:57
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:
16
Fecha:
9 de diciembre de 2024 - 17:38
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
34′ 58″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
145.59 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid