Saltar navegación

20251212 POO-Ejer_4 - 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 diciembre de 2025 por Raquel G.

1 visualizaciones

Más información Transcripción

Descargar la transcripción

Bueno, pues hemos dicho entonces que íbamos a hacer el 14. 00:00:01
Como de costumbre, pues primero lo leemos para hacernos una idea de qué va esto. 00:00:07
Pues es hacer cosas con los vehículos. 00:00:12
¿Cosas como cuál? 00:00:15
Pues ver lo que han gastado en cada trayecto. 00:00:16
Vale. 00:00:19
Entonces, la entidad vehículo que es con la que vamos a trabajar se va a caracterizar por cosas para hacer esos cálculos. 00:00:21
Una, lo que gasta por combustible. 00:00:27
Perdón, lo que gasta por kilómetro recorrido. 00:00:30
Solamente se caracteriza por esto porque esta aplicación lo único que hace es calcular gastos. 00:00:33
Ya está. 00:00:37
Entonces, como lo único que hace es calcular gastos, pues el gasto por kilómetro. 00:00:38
Es lo único que necesitamos del vehículo. 00:00:44
Ya está. 00:00:46
Vale, pues entonces vamos a empezar haciendo esa primera entidad. 00:00:48
Entonces, pues ejercicio 14. 00:00:54
vale, y el ejercicio 14 tiene una clase 00:01:00
vehículo 00:01:09
bueno, propiedades del vehículo 00:01:12
el gasto por combustible 00:01:21
por defecto en condiciones normales 00:01:23
pues las propiedades las hacemos de ámbito privado 00:01:26
y luego ya que los métodos Getty Set 00:01:28
decidan si las ofrecen al exterior 00:01:31
para consulta y o escritura 00:01:34
pues el gasto por combustible 00:01:37
Perdón, jodín 00:01:39
El gasto por kilómetro 00:01:41
Un double 00:01:42
No, es 00:01:43
Otra cosa 00:01:48
Que es desde la propia clase 00:01:50
Perdón, desde el propio paquete 00:01:52
Private es 00:01:54
Solo desde la clase 00:01:56
Public es 00:01:57
Desde cualquier clase de cualquier otro paquete 00:01:59
Y nada 00:02:02
Es desde este paquete 00:02:03
Son tres posibilidades distintas 00:02:06
Bueno, pues entonces, para que esta propiedad se pueda establecer o se pueda recuperar desde fuera, 00:02:10
tenemos que hacer sus getter y sus setter, claro. 00:02:17
Pues venga, hacemos sus getter y sus setter, que estos ya sí que son públicos. 00:02:20
Quien quiera ver el gasto por kilómetro del coche llamará a este método. 00:02:27
Y el que quiera cambiar el gasto por kilómetro del coche, porque ha cambiado por lo que sea, 00:02:31
llama a ese método, que ya sí que son públicos. 00:02:35
Vale, para facilitar la tarea de instanciar un coche 00:02:39
Y darle valor a su propiedad 00:02:43
Vamos a hacer un constructor 00:02:45
¿No viniste a clase ni viste la grabación? 00:02:46
Pues muy mal 00:03:00
Porque entonces lo habrías visto 00:03:01
Botón derecho, source 00:03:03
Vale 00:03:06
Vale, pues ya tenemos el kilómetro 00:03:07
Uy, el kilómetro 00:03:14
El constructor 00:03:15
Este constructor será llamado cuando se instancie el objeto 00:03:16
En ese momento pasamos un valor para esa propiedad y se utiliza para inicializar esa propiedad. 00:03:21
Bueno, pues esta es lo que viene a ser una entidad normal y corriente, una entidad vehículo. 00:03:29
¿Para qué sirve esta aplicación? 00:03:38
Esta aplicación sirve para calcular lo que me gasto yo cuando recorro una trayectoria. 00:03:40
pues entonces tendré que ser capaz 00:03:46
de representar el objeto trayectoria 00:03:50
esta aplicación trabaja con vehículos 00:03:53
está claro, ya hemos hecho una clase para ellos 00:03:57
pero también va a trabajar con trayectorias 00:03:59
porque es una aplicación que dada una trayectoria 00:04:01
me va a decir lo que gasta este vehículo 00:04:05
entonces, ¿cómo podemos caracterizar 00:04:08
una trayectoria? 00:04:11
En un ámbito digital, claro 00:04:13
Pues vamos a tener que, lógicamente 00:04:17
Cuantificarla de alguna manera 00:04:20
Entonces 00:04:23
Uy va 00:04:24
Si esta es 00:04:26
Si esta es una trayectoria, bum bum bum 00:04:28
Vale, yo como la mido 00:04:35
Como la mido para pasársela 00:04:37
Luego al método que calcule 00:04:39
El gasto, como la mido 00:04:41
Pues hombre, voy a tener que 00:04:42
Rectificarla, pues una forma posible es 00:04:45
Voy a tomar muestras en diferentes puntitos, voy a tomar muestras y la trayectoria se va a caracterizar por toda la sucesión de puntos, lo que puede ser una raíz de puntos, ¿verdad? La trayectoria se va a caracterizar por un montón de puntitos. 00:04:47
Y ahora ya, la trayectoria total 00:05:02
¿Cuál va a ser? 00:05:05
La suma de las distancias entre los puntos 00:05:06
¿Vale? 00:05:09
La suma de las distancias entre los puntos 00:05:10
¿No va a ser exactamente la distancia? 00:05:12
Dependerá de cómo de cerca 00:05:15
Tome yo los puntitos, ¿no? 00:05:16
O sea, si mi trayectoria es esta 00:05:18
Y yo tomo un punto aquí, otro aquí y otro aquí 00:05:19
La trayectoria 00:05:22
Me va a salir 00:05:24
La medida me va a salir esto 00:05:25
Es una aproximación, pero es una aproximación un poco grosera 00:05:27
aproximarla por esta distancia y esta distancia 00:05:31
si quiero que la aproximación a la trayectoria real 00:05:33
sea más fiel, pues tendré que tomar más puntitos 00:05:37
más cerca, entonces ya la aproximación 00:05:40
está mucho más afinada 00:05:43
¿verdad? cuanto más puntos tome yo de muestra 00:05:46
de esa trayectoria real, más puntos tome 00:05:50
más se va a aproximar la medida 00:05:52
la estimación a la medida real 00:05:55
esto en un caso límite 00:05:58
si os acordáis de los límites de las matemáticas 00:06:00
de segundo de bachillerato 00:06:03
pues el límite 00:06:04
cuando el número de puntos tiende a infinito 00:06:05
es la distancia real 00:06:09
pero el límite 00:06:12
es un concepto astral 00:06:13
el límite no se puede cuantificar 00:06:14
pero sí que podemos 00:06:18
poner un montón de puntitos 00:06:19
conclusión 00:06:21
hemos decidido 00:06:23
podría haber sido de otra manera pero hemos decidido 00:06:25
que para cuantificar una trayectoria, 00:06:27
que es otro dato que mi aplicación necesita, 00:06:31
voy a utilizar un montón de puntos. 00:06:34
¿Qué es un montón de algo en Java? 00:06:37
Pues un array. 00:06:39
Pues un array de puntos me va a caracterizar la trayectoria. 00:06:41
Pues estoy hablando de punto como si punto fuera algo. 00:06:45
¿Punto es un int? ¿Punto es un double? 00:06:48
No. 00:06:50
Punto es una posición en el plano. 00:06:51
Una posición en el plano no es un tipo de variable, 00:06:53
no es un tipo de dato estándar de Java 00:06:56
el plano es esto 00:06:58
y una posición en el plano es esto 00:06:59
o esto, o esto 00:07:02
es decir, una posición en el plano 00:07:03
es una coordenada X y una coordenada Y 00:07:05
eso es una posición en el plano 00:07:08
y eso no es un tipo 00:07:10
de dato estándar, no es un int, no es un double 00:07:12
es un tipo de 00:07:14
dato que me voy a tener que crear 00:07:16
porque es 00:07:18
la combinación de dos cosas 00:07:19
son dos valores, ¿vale? 00:07:21
una posición en el plano 00:07:24
que eso es lo que es un punto 00:07:25
una posición en el plano 00:07:27
está formada por dos valores 00:07:29
coordenada X, coordenada Y 00:07:31
luego 00:07:33
voy a tener que hacerme una clase punto 00:07:34
porque el tipo de dato punto no existe 00:07:37
no existe el tipo de dato 00:07:39
par de valores 00:07:41
ese tipo de dato no existe 00:07:42
pues entonces aquí nos surge ya la necesidad 00:07:44
de crearnos otra clase 00:07:47
para especificar ya un tipo 00:07:49
de dato nuestro propio 00:07:51
que es la combinación de una 00:07:53
coordenada X y otra Y. 00:07:55
Y ahora ya, cuando tengamos esa clase 00:07:58
punto, ya podremos hacer 00:07:59
array de puntos. Y un array 00:08:01
de puntos, ¿qué va a ser? Una trayectoria. 00:08:03
Podríamos 00:08:07
hacernos, de hecho, otra clase trayectoria. 00:08:07
¿Qué vamos a hacer? 00:08:10
Para cuya 00:08:12
propiedad fuera el array de puntos 00:08:13
que la forman, por ejemplo. 00:08:15
Tendríamos tres clases. El vehículo 00:08:17
que guarda el gasto por kilómetro. 00:08:19
La clase 00:08:22
punto que representa una posición en el 00:08:23
plano y la clase trayectoria que representa un montón de puntos. Y ya con eso mi aplicación 00:08:25
ya hará sus métodos, trabajará, operará, pues como toque hacerlo, ya veremos cómo. 00:08:32
Pero primero, antes de empezar a decidir qué hacer, hay que tomar la decisión sobre qué 00:08:38
hay y cómo caracterizarlo. Pues aquí qué hay, coches con su gasto por kilómetro, puntos 00:08:44
con sus dos coordenadas 00:08:52
y trayectorias, un montón de puntitos 00:08:53
eso es lo que hay 00:08:56
una vez que tenemos claro lo que hay 00:08:56
y cómo se caracteriza 00:08:59
es decir, qué propiedades tiene dentro 00:09:01
una vez que eso ya hemos hecho una foto 00:09:03
ya sabemos lo que hay 00:09:05
ahora ya pongámonos a hacer código 00:09:06
a hacer métodos que ejecutan cosas 00:09:10
¿qué trayectoria se puede hacer una raíz de puntos? 00:09:12
pues por meter una entidad más 00:09:16
vamos a una trayectoria 00:09:18
que se caracteriza por una raíz de puntos 00:09:20
porque va a quedar la aplicación más clara 00:09:22
si tú ahora un método 00:09:24
en lugar de pasarle raíz de puntos 00:09:25
le pasas un objeto trayectoria 00:09:27
cuando alguien ve el método 00:09:29
ya sabe que eso trabaja con 00:09:31
una trayectoria para lo que sea 00:09:33
pasas una raíz de puntos 00:09:35
puede representar muchas más cosas 00:09:36
entonces 00:09:39
la razón de hecho sería 00:09:40
para hacer un diseño 00:09:43
más claro 00:09:44
a los ojos del que echa un vistazo al código 00:09:45
¿vale? 00:09:47
no pasa nada por hacer una clase más 00:09:48
si clases puede haber 2.000 millones, 00:09:50
si estimamos que ayudan a dejar el código claro, 00:09:52
esa sería la razón de alguna manera real. 00:09:56
Nosotros además ahora la vamos a poner, 00:09:59
ya que nos hemos puesto, 00:10:01
pues para practicar más, 00:10:02
con pasar objetos de clases, etc. 00:10:04
¿Vale? 00:10:06
Pues venga. 00:10:08
Vamos a hacernos esas clases. 00:10:12
Vale, el vehículo ya estaba. 00:10:17
Entonces, vamos a hacernos punto. 00:10:20
vale, vamos a hacernos la clase punto 00:10:23
la clase punto 00:10:26
la trayectoria 00:10:32
claro, la clase trayectoria se caracterizaría 00:10:36
solamente por la raíz de puntos 00:10:39
pero claro, la aplicación se haría 00:10:40
si elegimos una clase trayectoria 00:10:42
la aplicación automáticamente se convertiría 00:10:44
en una aplicación escalable, por ejemplo 00:10:47
que si dejamos la trayectoria como raíz de puntos 00:10:49
sería muy difícilmente escalable 00:10:51
¿qué quiero decir con escalable? 00:10:52
que cualquier actualización, cualquier incorporación 00:10:54
de funcionalidades añadidas va a ser más fácil. 00:10:59
Una aplicación muy escalable significa que puedo escalar 00:11:03
su funcionalidad o lo que es lo mismo, 00:11:07
que puede incorporarle funcionalidades de forma muy sencilla. 00:11:09
Una aplicación poco escalable implica, 00:11:13
le voy a incorporar funcionalidades nuevas, 00:11:16
tengo que hacer un montón de retoques. 00:11:18
Entonces, una aplicación que tiene una clase trayectoria 00:11:20
y está planteada con esa clase trayectoria 00:11:23
y dices, voy a incorporar 00:11:25
una funcionalidad más, que es además 00:11:27
de la trayectoria, ponerle 00:11:29
la cualidad del terreno, porque 00:11:31
si el terreno es muy rugoso, el coche salta 00:11:33
y gasta más, por ejemplo 00:11:35
eso sería escalar la aplicación 00:11:37
añadir una funcionalidad 00:11:40
si tú tienes ya una clase trayectoria 00:11:41
que se caracteriza por su array de puntos 00:11:43
dices, magnífico, le meto otra 00:11:45
propiedad que sea 00:11:47
dificultad del terreno, y es mucho 00:11:48
más bonito, más natural 00:11:51
La ampliación 00:11:52
Si tú has trabajado con 00:11:54
Array de puntos como trayectorias sueltos 00:11:56
Aquí y allí 00:11:59
Y de repente tienes que meter la rugosidad del terreno 00:11:59
Vas a tener que retocar los cálculos en muchos sitios 00:12:02
¿Vale? 00:12:05
Venga, pues entonces 00:12:08
Punto se caracteriza 00:12:09
Solo por sus coordenadas 00:12:11
¿Coordenadas de Abel también? 00:12:13
Pues sí 00:12:16
X e Y 00:12:16
X e Y son nombres en este caso 00:12:18
bien elegidos 00:12:22
porque normalmente las llamamos así 00:12:24
el eje de abscisas la llamamos X 00:12:25
y el eje de ordenada lo llamamos Y 00:12:27
sí, pero eso sí que 00:12:29
quizás complicarlo un poco 00:12:40
esto es muy intuitivo, X e Y 00:12:41
tú ves el nombre, ves rápidamente 00:12:44
coordenada X, coordenada Y 00:12:45
y usar un array 00:12:47
solo para englobar dos cosas 00:12:49
quizás matar moscas a cañonazos 00:12:52
otra cosa es que 00:12:54
tú tuvieras un espacio 00:12:56
n dimensional 00:12:57
de 20 coordenadas 00:12:59
un espacio de 20 coordenadas 00:13:01
pues entonces poner las 20 coordenadas sueltas 00:13:02
sería muy pesado, entonces ahí podríamos hacer un array 00:13:05
para todas las coordenadas, pero va a un espacio 00:13:07
de dos dimensiones, queda casi más claro 00:13:09
poner x y que meterlo 00:13:11
en un array, pero sí, podríamos, pero quizás 00:13:13
es un poquito más, lo estás complicando 00:13:15
a lo igual sin necesidad 00:13:17
en este caso 00:13:19
vale, pues hacemos los get y los set 00:13:20
de las propiedades 00:13:23
Posibilidades y el constructor. 00:13:25
¡Hala! 00:13:40
Ya está. 00:13:41
Nuestra clase punto con su constructor Getty Set. 00:13:42
Vale. 00:13:45
Vamos a hacer el objeto trayectoria ahora cuando lo necesitemos. 00:13:49
Para comparar un poquito cómo serían las dos posibilidades. 00:13:52
Con objeto trayectoria y sin él. 00:13:56
A ver, hay mucho ruido de fondo. 00:13:58
Y así no se puede. 00:14:02
Venga. 00:14:04
Por ahora vamos a dejar esta en su trayectoria 00:14:05
y vamos a incorporarlo cuando lo necesitemos 00:14:06
para ver un poquito cómo serían las dos posibilidades. 00:14:08
Repito. 00:14:10
Vale, tenemos la clase punto y la clase vehículo. 00:14:11
Ahora, ¿qué más dice? 00:14:15
La clase punto. 00:14:16
Como vamos a necesitar calcular la distancia entre dos puntos 00:14:18
y eso es una cosa que se hace con puntos, 00:14:21
pues vamos a meter un método en la clase punto 00:14:25
para calcular la distancia 00:14:27
entre un punto que llame al método 00:14:29
y el que se le pasa por parámetro. 00:14:31
entonces distancia entre dos puntos 00:14:33
es esta fórmula 00:14:37
la distancia entre dos puntos 00:14:38
ya es un método, algo que hay que operar 00:14:41
¿dónde lo coloco? 00:14:43
ese método en la clase punto porque afecta 00:14:44
a puntos, vale, pues que este método 00:14:47
se coloca en la clase punto está claro 00:14:49
pues lo colocamos 00:14:50
en la clase punto el método distancia 00:14:53
vale, distancia 00:14:55
¿qué me va a devolver? una distancia 00:15:02
entre puntos que va a ser un double 00:15:04
pues dabble, voy a etiquetarlo 00:15:05
como public para permitir 00:15:08
usar este método desde fuera del 00:15:10
paquete, si es que lo voy a usar 00:15:12
desde fuera del paquete, aquí estamos 00:15:14
en todas las clases, en el mismo da igual 00:15:16
pero en general, lo normal 00:15:17
es que alguien tuviera la aplicación 00:15:20
aquí y usara estas clases que están en este otro 00:15:22
paquete de modelo, entonces necesitaría el public 00:15:24
vale, ahora viene lo más importante 00:15:26
¿qué parámetros 00:15:28
necesita el método distancia? 00:15:29
bueno, lo que 00:15:32
me dice el enunciado es 00:15:34
a este método lo va a llamar un punto 00:15:35
eso está claro, a este método lo llama un punto 00:15:37
porque a los métodos los llaman los objetos 00:15:39
luego ya tengo el primer punto de los 00:15:41
dos, para calcular la distancia 00:15:44
pues ¿cuál es el segundo 00:15:45
punto del cual vamos a calcular la distancia? 00:15:47
ese ya sí que se lo tengo que pasar por parámetro 00:15:50
luego este 00:15:52
método, del punto que 00:15:53
llame al método, me va a calcular la distancia con 00:15:55
ese que le paso desde fuera 00:15:57
bueno, pues 00:15:59
entonces, para pasarle un objeto 00:16:02
punto, pues 00:16:03
esto, por ejemplo. 00:16:05
¿Vale? 00:16:08
Entonces, aquí tengo 00:16:11
las coordenadas 00:16:13
del punto que llame al método. 00:16:14
Las coordenadas del punto que llama 00:16:23
al método son estas dos que tengo aquí arriba. 00:16:25
X e Y. 00:16:27
X e Y. 00:16:29
Esas son las coordenadas 00:16:31
del punto que llame al método. 00:16:33
¿Y cuáles van a ser las coordenadas 00:16:35
del 00:16:38
punto 00:16:41
Pasado como parámetro 00:16:41
El punto pasado como parámetro es P 00:16:44
Sus coordenadas son 00:16:48
P.getX 00:16:50
Y P.getY 00:16:53
Esas son sus coordenadas 00:16:56
La que me da el método get 00:16:59
Del objeto P 00:17:01
Y la que me da el método get 00:17:02
Del objeto P 00:17:05
Estas dos son las del punto 00:17:06
Que llama el método 00:17:09
Que son las de arriba 00:17:10
y estas dos son las coordenadas del punto P 00:17:11
porque P al ser de la clase punto 00:17:14
puede llamar a sus get para sacar sus coordenadas 00:17:18
bueno, pues ya tengo los dos pares de coordenadas 00:17:21
ahora aplico la fórmula que me han dado 00:17:24
y la fórmula es la raíz cuadrada de la diferencia 00:17:26
vamos a hacer primero la diferencia y luego hacemos la raíz 00:17:29
sería x menos p punto get x 00:17:31
todo esto al cuadrado 00:17:43
o lo que es lo mismo multiplicado por sí mismo 00:17:45
todo esto multiplicado por sí mismo 00:17:47
porque es al cuadrado 00:17:53
más 00:17:54
lo mismo pero con la i 00:17:58
vale 00:18:01
con esto 00:18:19
he hecho la primera parte de la fórmula 00:18:21
que es 00:18:24
esta, esta de aquí 00:18:25
la suma 00:18:29
del cuadrado de las diferencias de las coordenadas 00:18:31
he hecho la primera parte 00:18:34
me falta la raíz cuadrada 00:18:35
de todo esto. Pero bueno, ya me dicen, ¿cómo puedo hacer la raíz cuadrada? Pues ahora mismo 00:18:38
que sepamos que hay un método que se llama SQRT 00:18:42
para hacer la raíz cuadrada de algo y que puedo llamar a ese 00:18:46
método como math. Vale, pues entonces 00:18:50
la verdadera distancia será 00:18:54
eso, la raíz cuadrada 00:18:58
de esto que acabo de calcular. Esto 00:19:01
a ser la verdadera distancia. Y esto 00:19:06
es lo que quiero yo devolver. 00:19:08
Quiero que el método lo devuelva. 00:19:11
El método tiene que tener 00:19:14
un return porque he puesto que devuelve un double. 00:19:14
Pues hala, ya está. 00:19:19
Ya tengo ese método. 00:19:20
Que no me hace falta la variable 00:19:26
auxiliar div. Podría meter 00:19:28
todo esto, lo podría meter aquí dentro. 00:19:30
Y me ahorro 00:19:33
esa variable auxiliar. Pero bueno, si queda más 00:19:34
claro así el código, pues lo dejamos 00:19:36
así. 00:19:38
vale, entonces este método está claro 00:19:38
este método es un método 00:19:45
que me dice, cuando en un 00:19:47
programa que se esté ejecutando, que todavía 00:19:49
no hay ningún programa ejecutándose 00:19:51
pues cuando un programa con un main que se ejecute 00:19:52
cree un punto 00:19:55
y ese objeto punto, llame al método distancia 00:19:56
pasándole otro punto que también tendrá 00:19:59
que haber creado el programa 00:20:01
es decir, cuando existan dos puntos 00:20:02
porque ya estoy en un programa que se está ejecutando 00:20:05
y ya estén creados, cuando ya existan 00:20:07
dos puntos, si uno de ellos 00:20:09
llame a este método, recibiendo como parámetro 00:20:11
el otro, yo te voy a entregar 00:20:13
la distancia entre ambos 00:20:15
magnífico, es justo lo que necesitamos 00:20:16
para calcular valores 00:20:19
de trayectorias, sumas de distancia 00:20:21
esta suma más esta suma más esta suma 00:20:23
más esta suma, es justo lo que necesitamos 00:20:25
pero este método no va a venir muy bien para hacer eso 00:20:27
vale, en la clase 00:20:29
punto, hay que meter más cosas 00:20:31
hay que hacer más cosas con los puntos 00:20:32
no hay que hacer más cosas con los puntos 00:20:35
de hecho 00:20:38
O sea, aquí me dice solamente el método distancia, ¿vale? 00:20:39
Ahora, con los vehículos, ¿qué hay que hacer? 00:20:44
Pues con los vehículos hay que meter un método que te diga cuánto has gastado 00:20:47
para una trayectoria en concreto. 00:20:51
¿Cuánto has gastado? 00:20:55
Eso afecta al vehículo. 00:20:56
Lo que ha gastado en una trayectoria afecta al vehículo. 00:20:58
Pues ese método tendrá que ir en vehículo, porque afecta al vehículo. 00:21:01
Vale, pues entonces 00:21:05
En vehículo 00:21:09
Ponemos ese método 00:21:10
Que me va a devolver un gasto 00:21:13
Con lo cual me va a devolver un double 00:21:15
Gastado 00:21:17
Trayectoria, yo que sé el nombre 00:21:22
Lo más explicativo que se os ocurra 00:21:24
Trayectoria 00:21:26
Vale, pues este método 00:21:27
Tendrá que calcular algo 00:21:33
Y devolvernolo 00:21:36
Tendrá que calcular algo 00:21:38
por ahora pongo esto para 00:21:40
tendrá que hacer el cálculo 00:21:48
que sea y devolverlo 00:21:53
cuando ya lo haya hecho, el cálculo que sea 00:21:55
eso nos falta aquí 00:21:57
pero claro, antes de nada 00:21:58
pues tenemos que pensar, vale, que me va a devolver 00:22:00
un double, sí, me va a devolver un gasto 00:22:03
un double, muy bien 00:22:05
¿qué necesita 00:22:06
este método para trabajar? 00:22:08
necesita lo que este coche 00:22:11
gasta por kilómetro 00:22:13
eso no hay problema, lo que este coche 00:22:14
gasta por kilómetro está aquí arriba 00:22:17
el propio vehículo va a llamar al método 00:22:18
y él ya tiene dentro el gasto 00:22:21
el método accede a eso y ya está 00:22:23
luego ese método 00:22:24
puede acceder a ese dato sin problema 00:22:26
pero también necesita 00:22:29
la trayectoria para saber 00:22:31
cuántos kilómetros tiene 00:22:33
y la multiplicación de los kilómetros 00:22:34
de la trayectoria por el gasto por kilómetro 00:22:37
será el resultado de volver 00:22:39
luego la trayectoria 00:22:40
no es una característica del coche 00:22:42
la trayectoria es un 00:22:45
a veces es una 00:22:47
a veces es otra, la trayectoria es un dato externo 00:22:48
que se le pasa al método para decir 00:22:51
para esta, ¿cuánto consumes? 00:22:53
muy bien, y ahora para esta otra 00:22:55
¿cuánto consumes? muy bien, y ahora para esta otra 00:22:57
¿cuánto consumes? la trayectoria se pasa 00:22:59
desde fuera 00:23:01
no caracteriza al vehículo 00:23:01
el vehículo lo caracteriza a su gasto por combustible 00:23:04
vale, pues entonces 00:23:07
tenemos que pasar aquí la trayectoria 00:23:09
entonces aquí tenemos las dos posibilidades 00:23:10
ya hemos dicho que la trayectoria 00:23:13
es una raíz de puntos 00:23:15
Luego, si nos olvidamos de la clase trayectoria 00:23:16
Le pasaríamos esto 00:23:21
Un array de puntos 00:23:22
Yo le paso mi trayectoria 00:23:25
Y cálculame cuánto has gastado 00:23:32
Vale, vamos a hacerlo así 00:23:35
Vamos a hacer así esta primera versión del método 00:23:39
Bueno, pues ahora ya 00:23:42
Lo que tenemos es que hacer 00:23:44
cuál va a ser 00:23:47
la distancia total 00:23:48
tendremos que calcular 00:23:50
la distancia entre cada dos puntos 00:23:52
es una suma acumulativa 00:23:54
voy al primero, distancia con el siguiente 00:23:56
le sumo la distancia de este con el siguiente 00:23:58
la distancia de este con el siguiente, es una suma acumulativa 00:24:00
que sabemos hacer, esto va a ser 00:24:02
una suma acumulativa, pero tendremos 00:24:04
que recorrer el array 00:24:06
y qué suerte que tenemos un método 00:24:08
distancia en punto que me dice 00:24:10
la distancia entre un punto y otro, qué suerte 00:24:12
pues una suma acumulativa 00:24:15
que para cada punto va incorporando a esa suma la distancia entre este y el siguiente. 00:24:16
Bueno, pues como sabemos hacer la suma acumulativa, vamos a recorrer el array suma acumulativa. 00:24:23
Partiendo de cero, vamos a ir sumando para cada punto en el que estamos parados, 00:24:42
para cada punto en el que estamos parados 00:24:47
vamos a ir haciendo esto 00:24:49
puntos de Y 00:24:55
punto distancia 00:24:59
puntos de Y más 1 00:25:01
y esa sería mi suma acumulativa 00:25:06
el método distancia me calcula 00:25:11
la distancia entre este punto y su siguiente 00:25:14
a la suma acumulativa 00:25:17
avanzo al siguiente 00:25:20
Suma entre ese y su siguiente 00:25:22
¿Vale? 00:25:24
Es decir, mi array 00:25:28
Será esto 00:25:30
Me paro en este punto 00:25:34
Calculo distancia entre este y el siguiente 00:25:35
A la suma acumulativa 00:25:37
Ahora avanzo a este 00:25:39
Distancia entre este y su siguiente 00:25:40
A la suma acumulativa 00:25:42
Ahora me paro en este 00:25:44
Distancia entre este y el siguiente 00:25:45
A la suma acumulativa 00:25:47
Y así la suma de todas estas distancias 00:25:48
Me devuelve 00:25:52
¿Vale? ¿Estaría bien el método? 00:25:52
Muy bien. 00:25:58
Eso estaba esperando que me dijerais. 00:25:59
No estaría bien, tendría un detalle, 00:26:00
me saldría aquí una Reindersbaun Exception. 00:26:03
Porque me tengo que parar en el penúltimo. 00:26:05
Me tengo que parar en el penúltimo. 00:26:08
Porque cuando me paro el penúltimo, 00:26:10
ya estoy sumando esta distancia. 00:26:12
Me paro en el penúltimo. 00:26:14
No tengo que pararme aquí, 00:26:16
porque este me guía a este más su siguiente. 00:26:17
Que no hay siguiente a Reindersbaun Exception. 00:26:18
¿Vale? Me tengo que parar en el penúltimo. 00:26:21
Luego el recorrido sería hasta menos 1, ¿vale? 00:26:24
Me tengo que parar en el penúltimo. 00:26:29
Luego esto, para que no me dé a Reinders Bound Exception, 00:26:33
cuidado porque tengo que pararme antes, en el penúltimo. 00:26:37
Buen ejemplo este para decir, oye, como solo estoy consultando, 00:26:43
ah, bueno, ni siquiera, porque nada, nada, olvidamos, 00:26:47
ni siquiera podríamos. 00:26:49
Vale, ahora este método en principio ya sí que estaría bien. 00:26:51
Me da el gasto por trayectoria. 00:26:54
Y ya está, ya está todo hecho. 00:26:57
Ahora ya mi programa principal 00:26:58
Que arranque los puntos 00:27:00
Que arranque las cosas 00:27:02
Aquí que me dice 00:27:03
El main vamos a hacerlo ahora 00:27:05
Como nos dé la gana 00:27:10
Pero aquí no dice un main 00:27:10
Eso ya depende 00:27:11
Eso ya en tiempo de ejecución 00:27:20
Se decidirá 00:27:22
Este no se compromete a nada 00:27:23
Aquí estamos simplemente declarando 00:27:24
Lo que va a hacer el método 00:27:26
Cuando le llegue un array 00:27:28
¿ese array cuánto va a tener? no lo sé 00:27:29
a lo mejor en una ejecución le paso un array de 3 00:27:31
pero a lo mejor en la siguiente 00:27:34
le paso un array de 5 00:27:36
a este método le da igual, porque tiene el punto led 00:27:37
que le va a decir siempre cuál es su tamaño 00:27:40
a este método no le importa 00:27:41
que longitud tenga en particular 00:27:43
él ya accede a ella, a esa longitud 00:27:46
con punto led 00:27:48
¿que me llamas con un array de 7? pues ya está, son 7 00:27:49
¿que me llamas con un array de 12? 00:27:52
pues son 12, me da igual 00:27:55
mi for se va a ejecutar tantas veces 00:27:56
como necesite, aquí no nos comprometemos 00:27:58
al tamaño, luego ya en el main 00:28:01
ahora ya sí, en el main es donde 00:28:03
las cosas existen, ahí ya hay que 00:28:05
crear una trayectoria con una serie de puntos 00:28:07
concretos, un coche y ahí ya 00:28:09
pues las cosas 00:28:11
se ejecutan y dan resultados 00:28:13
aquí solo se dice cómo 00:28:15
se va a hacer, luego ya 00:28:17
cuando se hace realmente 00:28:19
en el main 00:28:20
pues venga, vamos a hacer el main 00:28:21
tengo mi main, ahora 00:28:24
Aquí ya hay que crear los coches 00:28:33
Las trayectorias, todo 00:28:35
Pues venga, vamos a hacer un main guapo 00:28:36
A ver 00:28:38
Un scanner, porque vamos a leer 00:28:40
Del teclado 00:28:44
Vale, y ahora vamos a decir 00:28:45
¿Cuánto gasta tu coche? 00:28:58
Para poder hacer los cálculos 00:29:01
Vale 00:29:03
Pues el gasto 00:29:09
Lo vamos a leer 00:29:12
Con scan.nextdabel 00:29:15
pues vamos a hacernos ya un objeto vehículo con ese gasto 00:29:19
pues vamos a instanciar un objeto vehículo 00:29:24
v, new vehículo 00:29:28
y como he dicho, aquí 00:29:31
si yo lo dejo en paréntesis vacíos, el constructor me dice, el compilador me dice 00:29:35
perdona, no puedo, claro, porque nos hemos inventado 00:29:40
un constructor, hemos pasado del por defecto, ese olvidado ya no existe 00:29:44
Porque me he inventado uno 00:29:48
Y este me dice 00:29:49
Que un double, lo siento 00:29:52
Pero tienes que darme un double, si no yo no puedo 00:29:54
Llamar al constructor 00:29:56
Venga, pues 00:29:57
Gasto 00:29:59
El que yo he pedido, este 00:30:01
Vale, el coche ya está 00:30:04
Ahora 00:30:05
Tenemos que meter la trayectoria, esto es más rollo 00:30:07
Vamos a hacerlo, primero cuántos puntos 00:30:10
De la trayectoria y luego ya rellenamos la raya 00:30:12
Y ya está, ahora 00:30:14
Vamos a decirle, venga, ahora vamos 00:30:16
a leer, a escanear la trayectoria 00:30:18
este escaneo 00:30:21
pues lógicamente 00:30:23
lo haría el maps 00:30:24
pues el maps pipipi 00:30:27
con el satélite pipipi haría el escaneo 00:30:29
llamaría 00:30:31
a distancia 00:30:32
a gasto y ya está 00:30:34
nosotros se lo tenemos que meter 00:30:35
a mano, pues nada, vamos a metérselo a mano 00:30:38
primero vamos a decir 00:30:40
cuántos puntos 00:30:42
cuántos puntos va a tener la trayectoria 00:30:43
Esto va a ser un int, el número de puntos, lógicamente 00:30:53
Cuántos puntos va a tener, pues lo que nosotros queramos en un momento dado 00:30:57
Los que nos den la gana 00:31:05
Y ahora ya vamos a hacer el bucle para leer los puntos de la trayectoria 00:31:06
Se los tenemos que meter a mano porque la aplicación no sabe leerlas directamente 00:31:11
Pues venga, ahora ya vamos a hacernos un array con la trayectoria 00:31:15
Punto 00:31:22
La voy a llamar 00:31:24
Trayectoria 00:31:27
Este array trayectoria 00:31:29
New punto 00:31:32
De num puntos 00:31:34
¿Verdad? 00:31:36
Ya tengo mi array 00:31:39
Mi array con tantos puntos como yo le he pedido 00:31:40
Mi array de puntos 00:31:44
Y ahora vamos a recorrerlo para leerlo 00:31:45
Simplemente 00:31:47
Trayectoria 00:31:48
Punto led 00:31:55
Vale 00:31:57
Pues le vamos a decir 00:32:00
Que meta coordenada x e y seguidas 00:32:02
No, pero vamos a hacer la versión 2 00:32:04
¿Vale? Para compararlos 00:32:08
Vamos a hacer el método con la versión 2 00:32:10
x e y 00:32:12
Bueno, x e y 00:32:13
Vale, entonces primero que lea 00:32:15
La coordenada x 00:32:18
Double x igual a 00:32:19
Scan.nextdouble 00:32:24
Y luego la y 00:32:29
y ahora 00:32:31
metemos en la 00:32:37
posición iésima un punto 00:32:39
con esas coordenadas 00:32:41
trayectoria 00:32:42
de i 00:32:46
igual 00:32:47
a new.x 00:32:49
listo el for 00:32:53
listo el for 00:32:56
que lee la trayectoria 00:32:58
vale 00:32:59
nos pide tantos puntos 00:33:03
Como le hemos dicho, como longitud tenga el array 00:33:06
Nos pide coordenada X, nos pide coordenada Y 00:33:09
Instancia un punto con esas coordenadas 00:33:13
Y lo mete en la posición del array que toque 00:33:16
¡Hala! Muy bien, ya tenemos los datos rellenos 00:33:19
Y ahora ya vamos a mostrarle cuánto ha gastado 00:33:22
Gasto 00:33:26
Su gasto en esa trayectoria 00:33:31
Su gasto 00:33:35
pues su gasto ha sido 00:33:36
pues mi vehículo 00:33:39
tiene un método estupendo 00:33:43
que se llama gastado 00:33:47
trayectoria, que si yo le paso 00:33:49
una raíz de puntos 00:33:51
me devuelve lo que ha 00:33:52
gastado, bueno, pues venga voy a 00:33:55
meterlo directamente en el siso 00:33:57
y ya está 00:33:58
y ya está, se acabó el programa 00:34:00
entonces, mi main 00:34:05
se olvida de las peculiaridades 00:34:07
de este método, le dan igual 00:34:10
ese método ya está encapsulado 00:34:11
metido en la clase vehículo 00:34:13
con toda su complejidad, con todo lo que sea 00:34:16
y mi clase llama 00:34:18
al método y punto pelota 00:34:20
pasándole eso si la información 00:34:22
que necesita, que la información que necesita 00:34:24
es la trayectoria, en concreto 00:34:26
que ejecuto el programa 00:34:27
con otra trayectoria, pues 00:34:30
me devolverá otro valor, lógicamente 00:34:31
¿vale? 00:34:34
y ya está 00:34:38
¿puedes un segundo mostrar 00:34:39
la clase vehículo y trayectoria? 00:34:41
¿cuál es la vehículo según? 00:34:44
¿cuál es la trayectoria? 00:34:46
el método sería ese 00:34:47
¿hace la fórmula? 00:34:48
¿hace la fórmula con las coordenadas? 00:34:56
bueno, hace la suma acumulativa 00:34:59
¿pero esto te devuelve la distancia? 00:35:01
¿no te devuelve el precio? 00:35:03
¿qué atributos has puesto en vehículo? 00:35:06
el gasto por kilómetro 00:35:09
entonces, este te dice 00:35:11
¿cuántos kilómetros hay? 00:35:12
Claro, y ahora tienes que multiplicarlo por el... 00:35:14
Ay, no lo he multiplicado, perdón, perdón, perdón, perdón. 00:35:16
Que he gastado trayectoria, efectivamente, 00:35:19
me falta multiplicarlo. 00:35:21
Esta es la distancia, perdón, claro, 00:35:22
me falta multiplicarlo por el gasto por kilómetro. 00:35:24
Efectivamente, tenéis razón, claro. 00:35:28
Efectivamente, este método me ha calculado 00:35:31
todo lo que mide la trayectoria, los kilómetros, 00:35:34
pero lo que tiene que ver el método 00:35:37
es lo que ha gastado el coche. 00:35:39
Entonces esa distancia que resulta la multiplico por el gasto por kilómetro que es la propiedad del coche que está arriba, ¿vale? 00:35:40
Sí, a ese método le faltaba esto, efectivamente. 00:35:48
Vale, entonces el main llama al método y ya está. 00:36:03
Si ejecutamos, venga, ¿cuánto gasta tu coche? Pues 2, gasta 2. 00:36:11
¿Cuántos puntos quieres? Venga, 3, x e y. 00:36:18
coordenadas 00:36:21
1, 1 00:36:23
para que sea una recta 00:36:26
y así podemos calcular bien 00:36:28
coordenadas, 2, 2 00:36:29
coordenadas 00:36:32
ah no, espera 00:36:34
le quiero pasar una recta horizontal 00:36:36
porque si es en vertical, bueno 00:36:37
3, 3 00:36:39
su gasto ha sido este, pero le voy a pasar 00:36:41
una trayectoria que sea más fácil de calcularla 00:36:44
de cabeza 00:36:46
a ver, claro 00:36:46
1, 0, 2, 0, 3, 0 00:36:49
Que eso es una recta, y ya está 00:36:51
Porque 1, 1 tendría que hacer la raíz cuadrada 00:36:52
Entonces, ¿cuánto gasta tu coche? 00:36:54
Gasta 2 00:36:56
¿Cuántos puntos? 3 puntos 00:36:57
Coordinada X del primer punto 00:37:00
1, 0 00:37:02
2, 0 00:37:04
3, 0 00:37:07
¿Vale? 00:37:11
Su gasto ha sido 4, 2 por 2, 4 00:37:18
Efectivamente, entre esos dos puntos 00:37:21
Tengo 1 y 1, 2 por 2, 4 00:37:23
¿vale? está bien calculado 00:37:25
vale 00:37:26
pues entonces 00:37:37
aquí se trata de 00:37:38
todas las complejidades 00:37:41
que afectan a una entidad 00:37:43
hacer cosas con esa entidad, con ese objeto 00:37:44
se meten ahí dentro y ahí se queda todo 00:37:46
encerrado 00:37:49
y luego la clase main llama a lo que necesite 00:37:49
¿vale? 00:37:53
primera cosa importante 00:37:54
y segunda 00:37:55
los objetos son otros datos más 00:37:56
otras variables más 00:38:00
como aquí 00:38:02
aquí ha habido que pasarle 00:38:03
una variable como parámetro 00:38:05
pues es otra variable más 00:38:07
normal y corriente 00:38:08
otra variable más 00:38:09
lo que pasa es que es una variable 00:38:09
que es de tipo objeto 00:38:11
porque es de la clase punto 00:38:12
y eso hace que tenga propiedades dentro 00:38:13
pueda llamar a método si hace falta 00:38:16
etcétera 00:38:18
vale, que nos hacemos una tercera clase 00:38:19
trayectoria 00:38:25
porque queremos que esto sea más escalable 00:38:25
por si añado yo propiedades a la trayectoria 00:38:28
como 00:38:31
rugosidad alta o lo que sea 00:38:32
vamos a completarlo antes de parar 00:38:34
para así ya dejar el ejercicio 00:38:36
olvidado, que no se nos olvide 00:38:38
pues venga, me voy a hacer 00:38:40
una clase trayectoria 00:38:42
inicialmente mi trayectoria 00:38:44
solo se va a caracterizar 00:38:49
por un array de puntos 00:38:51
ala, esto es a lo que caracteriza 00:38:53
mi trayectoria, por ahora 00:39:03
a lo mejor en el futuro le meto más propiedades 00:39:05
pero ahora mismo es eso 00:39:07
bueno, una única propiedad 00:39:09
array de puntos, una única 00:39:11
Un get y set 00:39:13
Ahí tengo el get y set 00:39:14
Que como veis el get devuelve un array de puntos 00:39:19
Y el set recibe un array de puntos 00:39:22
Ningún problema 00:39:24
Y ahora vamos a hacerle un constructor 00:39:26
Que es lo habitual 00:39:28
Hacer un constructor 00:39:31
Con parámetros 00:39:32
Vale, ya tengo mi constructor 00:39:37
Vale 00:39:38
¡Hala! Ya está 00:39:41
Ahora 00:39:44
¿Cómo cambia mi programa? 00:39:46
Pues vamos a copiarlo en un main2 00:39:49
main2, vale 00:39:50
sería este, bueno 00:40:01
¿cuánto gasta tu coche? 00:40:03
muy bien, hago mi vehículo, trayectoria 00:40:05
vale, leo 00:40:07
los puntos, y una vez que tengo ya 00:40:09
los puntos leídos 00:40:11
pues ahora ya 00:40:13
me podría 00:40:15
hacer un objeto 00:40:18
trayectoria 00:40:19
un objeto trayectoria 00:40:20
que sería new 00:40:22
trayectoria a la que le paso 00:40:24
ese array de puntos 00:40:29
Ese array de puntos 00:40:30
Que lo he llamado así 00:40:32
Vale, ahora tengo 00:40:33
Ese array de puntos envuelto 00:40:38
En este objeto trayectoria 00:40:40
Bueno, pues vamos a añadir 00:40:41
Otro método 00:40:44
En vehículo 00:40:46
La versión 2 de este 00:40:47
Que recibe el objeto trayectoria 00:40:49
Vamos a hacer la versión 2 de este 00:40:52
Copiadlo 00:40:53
Y pegadlo 00:41:00
Pero llamadle aquí 00:41:02
Pues versión 2 00:41:03
Copiad el de arriba 00:41:04
Versión 2 00:41:07
Esta versión 2 no recibe la raíz de puntos 00:41:08
Recibe el objeto trayectoria 00:41:11
Que los tiene dentro 00:41:13
¿Eh? 00:41:14
¿Por qué? 00:41:19
Vale, pues entonces esta versión 2 00:41:24
De este método 00:41:27
Recibe el objeto trayectoria 00:41:28
No recibe la raíz de puntos 00:41:30
Yo veo esto y digo, raíz de puntos 00:41:32
¿Qué será esto? Una raíz de puntos 00:41:34
Una raíz de puntos de examen 00:41:35
¿Una raíz de qué? 00:41:37
sin embargo veo esto y digo 00:41:38
este método trabaja con trayectorias 00:41:40
parece que no 00:41:43
a lo mejor en este contexto no se ve tan claro 00:41:44
que sea más útil 00:41:47
pero en general si lo es 00:41:49
vale y en que me cambia esto 00:41:51
pues me cambia que ahora 00:41:53
yo ya puntos 00:41:55
este array es la propiedad 00:41:57
punto de trayectoria es decir será 00:41:59
t.get 00:42:00
puntos es lo que me cambia 00:42:02
es lo que me cambia 00:42:04
Que mi array puntos se ha convertido 00:42:07
En la propiedad puntos de t 00:42:14
Eso es lo que cambia 00:42:16
Que mi array puntos 00:42:18
Se ha convertido en la propiedad 00:42:19
Puntos de t 00:42:22
En esta y en esta 00:42:23
¿Veis? Ahora le paso la trayectoria 00:42:25
Trayectoria, su array está dentro 00:42:31
Lo saco con el get 00:42:34
Con get puntos 00:42:36
Pues ya está, no pasa nada 00:42:37
Este es mi array con su longitud 00:42:39
La posición id de ese array mío 00:42:41
la posición y más uno de ese array 00:42:44
que está dentro de t 00:42:47
vale 00:42:48
es el mismo método de arriba pero en lugar de 00:42:50
trabajar con un array directamente 00:42:55
trabaja con lo que hay dentro de esto 00:42:58
y ahora en mi main2 00:43:00
en mi main2 00:43:05
su gasto ha sido 00:43:07
pues yo ahora 00:43:08
cuando llame al versión 2 00:43:10
le llamo 00:43:13
le paso el objeto 00:43:15
tr, este de aquí 00:43:17
vale 00:43:18
Mi método versión 2 00:43:21
Necesita el objeto trayectoria 00:43:24
Que tiene el array dentro 00:43:26
Pues ahí va, el objeto trayectoria 00:43:27
Con el array dentro 00:43:30
¿Vale? Venga, pues ahora sí que paramos 00:43:31
Iba a decir para que vayáis al baño 00:43:38
Pero eso duele 00:43:39
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:
1
Fecha:
12 de diciembre de 2025 - 13:57
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
43′ 42″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
175.32 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid