Saltar navegación

Ejemplo Ajencia de Viajes - 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 22 de noviembre de 2022 por Stefano C.

25 visualizaciones

Más información Transcripción

Descargar la transcripción

Voy a grabar esta clase, si habláis durante la clase me autorizáis automáticamente a que vuestra voz sea grabada, ¿vale? 00:00:00
Entonces, new class, hemos dicho que vamos a intentar hacer un sistema, una serie de objetos, ¿vale? 00:00:12
Que hablarán entre ellos y trabajarán entre ellos para crear una simulación de una agencia de viaje, un aeropuerto 00:00:22
Ahora veremos por donde va 00:00:29
Empezamos con 00:00:30
Vuelo, objeto vuelo 00:00:32
El objeto vuelo representa 00:00:35
Un vuelo posible 00:00:37
A nivel de 00:00:39
Cuando vosotros vais al aeropuerto por ejemplo 00:00:40
Y miráis el vuelo FR471 00:00:42
Es un vuelo 00:00:46
Que tiene una fecha 00:00:47
La fecha no, porque luego se repite 00:00:48
Pero tiene un horario 00:00:51
No se, vale 00:00:53
Entonces vamos a intentar modelizar 00:00:54
Ese concepto 00:00:57
Y a ver que hacemos, no tiene main, vale 00:00:58
Es un objeto que lo hago utilizar 00:01:00
De alguna forma 00:01:03
Aquí lo tengo, ¿qué es interesante 00:01:03
De un vuelo? 00:01:07
Venga, decídmelo 00:01:08
String 00:01:10
Compa... 00:01:17
Compa... 00:01:18
Compa... 00:01:19
String 00:01:20
Número vuelo 00:01:25
Bueno, hagamos un int vuelo 00:01:28
Hacemos un 00:01:31
Identificador 00:01:32
Normalmente es un código 00:01:33
Dos letras y luego un número 00:01:40
Pero haremos que la compañía 00:01:42
Serán estas dos letras 00:01:44
Ya está, sucio, ¿no? 00:01:45
Int 00:01:47
Num modulo 00:01:48
Más 00:01:50
Int 00:01:52
Asientos disponibles 00:01:58
Asientos, sí 00:02:03
Asientos disponibles 00:02:03
qué más me encantáis ahora salida del vuelo como lo 00:02:07
definimos interesa todo excepto de dónde está la hora de salida es que no sabía 00:02:16
cómo utilizarla ahora mismo con lo que tenéis vosotros que lo ponemos un string 00:02:29
Le ponemos la hora con un número 00:02:33
En los minutos con otro número 00:02:36
O creamos un tipo de fecha 00:02:37
O creamos un tipo de hora 00:02:41
Pero ahora lo dejamos por ahí, ¿vale? 00:02:42
No me interesa, hay un vuelo cada día 00:02:44
Destino 00:02:46
Ring, destino 00:02:48
Ring, origen 00:02:51
No, venga, que lo quito 00:02:55
Aprovecho para recordar 00:02:58
Las variables 00:03:02
siempre empiezan por minúsculas 00:03:04
si son dos palabras 00:03:06
pues entonces la segunda 00:03:07
o tres o cuatro, pues las siguientes 00:03:09
empiezan con mayúsculas, ¿vale? 00:03:11
os recuerdo también que las clases en vez 00:03:14
empiezan por mayúsculas 00:03:16
y os recuerdo también que las 00:03:17
los métodos empiezan 00:03:19
por minúsculas 00:03:22
y los 00:03:23
las constantes son 00:03:24
todo mayúsculas 00:03:28
¿sí? 00:03:30
bueno, yo creo que eso 00:03:31
suficiente, por ahora 00:03:34
este de aquí 00:03:36
yo lo relleno 00:03:38
tendré que tener 00:03:39
un constructor que me construya eso 00:03:42
¿cómo hago el constructor? 00:03:44
¿os acordáis? public vuelo 00:03:50
y le pongo aquí la información 00:03:52
que yo quiero 00:03:54
entonces un string 00:03:54
compañía 00:03:57
int 00:04:01
número 00:04:03
Un int 00:04:05
Bueno, hacemos que cada vuelo 00:04:07
Tendrá siempre un cierto número 00:04:10
De asientos disponibles 00:04:12
Que se lo pongo yo en automático, ¿vale? 00:04:13
Todos los aviones son iguales 00:04:15
Para simplificar, ¿eh? 00:04:17
Luego estará un string 00:04:19
Destino 00:04:20
Y un string 00:04:24
Origen 00:04:25
Esto es feo, ¿eh? 00:04:27
No se debería poner así, ¿eh? 00:04:30
Se debería poner con algo que se entienda 00:04:32
estaría bien también poner directamente 00:04:33
esto, tanto no lo sabemos 00:04:36
para que luego la gente 00:04:37
sepa que es cada uno de estos 00:04:42
que es de, no lo sé, que es destino 00:04:44
pues sí, el destino no lo sé 00:04:45
vale 00:04:48
y entonces ahora asigno 00:04:48
todo lo que tengo que asignar 00:04:51
dis.compañia 00:04:54
es igual a compañía 00:04:57
dis.compañia 00:05:02
NumVuelo es igual a NumVuelo 00:05:06
Y ese punto 00:05:09
Asientos disponibles 00:05:15
Es igual a asientos disponibles 00:05:16
Ah no, esto habíamos dicho 00:05:17
Cinco 00:05:18
Son aviones pequeños 00:05:20
¿Vale? 00:05:24
¿Por qué hago aviones pequeños? 00:05:25
Bueno 00:05:34
¿Qué sentido? 00:05:34
Cinco, si es pequeño 00:05:42
Pero un INTA puede llegar a 00:05:44
Miles y miles y centinares de miles 00:05:46
Lo hago pequeño porque si quiero que esto tenga algún sentido 00:05:48
Ahora lo veremos, estamos inventando, por lo tanto no lo sé 00:05:53
Pero si quiero que haya algún sentido 00:05:56
En plan, que cuando alguien intenta comprar un billete 00:05:57
Si no hay asientos disponibles 00:06:00
Le diga, no puedes comprar este billete 00:06:01
¿Vale? 00:06:03
En un cierto sentido, pues 00:06:05
No puedo poner 500 00:06:07
Porque si no lo hago, no lo voy a probar 00:06:08
Tengo que hacer 500 billetes antes que me diga que no 00:06:10
Entonces pongo un número bajo 00:06:13
Así luego si hago 5 billetes 00:06:15
ya me dirá, has comprado 00:06:18
y luego después cuando esto 00:06:20
entre en producción, este de aquí 00:06:22
dependerá del avión 00:06:23
en el que está conectado 00:06:25
que se yo, y cuantos plazas tiene, no lo sé 00:06:27
pero por ahora 00:06:30
pongo un número bajo 00:06:32
5, 3, vale 00:06:34
para probar 00:06:35
vuelo 00:06:37
mira, para 00:06:40
para lo que quiero 00:06:43
hacer yo, yo lo dejaría 00:06:46
hasta así, esta clase, ¿vale? 00:06:48
en el sentido que esto representa un vuelo 00:06:50
no me 00:06:52
interesa tanto decir 00:06:54
que hora sale el vuelo, hora aterrizado 00:06:55
hora 00:06:58
no sé qué, ¿vale? 00:06:58
esto a lo mejor lo hará otra persona 00:07:01
podría añadir aquí un estado 00:07:03
un string estado que me dice 00:07:05
en tierra 00:07:07
despegado, viajando 00:07:09
o cosa por el estilo, ¿vale? 00:07:12
no lo sé, pero 00:07:13
Pero como mi perspectiva es más bien de una agencia de viaje, cuando la agencia de viaje te vende el billete, no sabes si despega o no despega. La hora podría ser interesante, el día también, pero repito, yo lo veo desde la perspectiva de agencia de viaje. 00:07:15
Entonces, el día tampoco me interesa mucho, o sea, el día no hace parte del vuelo. A mí me interesa que el vuelo exista, que haya la conexión Madrid-Pisa, ¿vale? Luego, la fecha no depende tanto de vosotros, sino depende de cuando queréis, o sea, no depende del vuelo, sino de cuándo queréis viajar vosotros. 00:07:37
Entonces lo pongo en otro contexto, por ejemplo 00:07:56
¿Sí? 00:07:59
O sea que esto es 00:08:01
Esto me dará una simulación 00:08:02
De cuáles son las conexiones posibles 00:08:05
Digamos así 00:08:08
Y cómo se llaman 00:08:09
Quién opera esa conexión 00:08:11
Y qué número de vuelo opera esa conexión 00:08:14
Cuando yo te compraré un billete 00:08:16
Si tú quieres ir de Madrid a Pisa 00:08:17
Tendré que buscar cuál es el vuelo que va de Madrid a Pisa 00:08:19
Y te diré 00:08:22
En tu billete te pondré 00:08:23
por ejemplo, no huele 00:08:26
la compañía para que tú te identifiques 00:08:28
¿sí? 00:08:30
¿me explico? entonces esto 00:08:32
es por ejemplo una clase 00:08:34
sin métodos 00:08:36
¿vale? 00:08:38
en la realidad de las cosas 00:08:40
en la realidad verdadera 00:08:42
es posible que 00:08:44
esta clase tenga que 00:08:46
tener getResetter 00:08:48
¿vale? los getResetter 00:08:50
son métodos especiales para 00:08:52
pillar 00:08:54
Estos valores 00:08:55
O setar o configurar 00:08:57
O dar un valor a estas variables 00:09:00
¿Vale? 00:09:02
Pero eso tiene sentido 00:09:02
Cuando nosotros empezaremos a utilizar 00:09:04
Cosas como 00:09:06
Public 00:09:07
O protected 00:09:09
Protected 00:09:11
O private 00:09:14
Que será la que nos interesará más 00:09:16
En estos contextos 00:09:19
Como nosotros esto no lo estamos utilizando 00:09:20
Tampoco los getter y los setter nos sirven de mucho 00:09:23
Entonces nosotros accederemos directamente a estas variables 00:09:26
No lo haremos a través de un método, ¿vale? 00:09:32
¿Por qué? 00:09:35
Lo descubriremos después, ¿vale? 00:09:36
Porque nos puede venir bien acceder por un método 00:09:38
Un getter y un setter, ¿vale? 00:09:40
Como todavía estamos aprendiendo la base 00:09:42
No sobrecargamos de dificultad, ¿vale? 00:09:45
Además los getter y setter 00:09:49
Si me acuerdo como se hacen 00:09:52
Hay un botón aquí que te los hace 00:09:54
En seguido 00:09:55
¿Dónde? 00:09:57
Surge 00:10:00
Ahí 00:10:01
Y aquí 00:10:03
Generate getter y setter 00:10:05
Tú pinchas aquí y ya te lo genera él 00:10:08
Porque son cosas básicas 00:10:10
Son cosas fáciles de hacer 00:10:11
Pero ¿Por qué lo hago? 00:10:13
Pues lo veremos más adelante 00:10:15
Por ahora dejámoslo así 00:10:16
Y trabajamos con esto normal 00:10:19
¿Vale? Entonces, ¿Esta clase qué hace? 00:10:22
Nada 00:10:24
¿Vale? Por ahora no hace absolutamente nada 00:10:24
Y se queda allí 00:10:29
Es una clase de soporto 00:10:31
Para mi sistema 00:10:33
Porque ahora yo haré un sistema donde crearé 00:10:34
Varios posibles vuelos 00:10:37
Y esos me acordaré que existen 00:10:39
¿Vale? 00:10:42
Y luego crearé billetes 00:10:43
A partir de eso 00:10:45
Entonces, vamos a hacer una nueva 00:10:46
Clase 00:10:49
¿Vale? 00:10:50
Esta nueva clase 00:10:55
Será la que 00:10:56
Gestiona un billete 00:11:00
O sea, un billete de avión, ¿no? 00:11:06
Billete 00:11:08
De avión 00:11:09
A ver si luego tenemos que 00:11:11
Volver a 00:11:14
A mirar cosas 00:11:17
¿Vale? Pero por ahora 00:11:20
¿Qué es un billete de avión? ¿Vale? 00:11:21
Entonces, el billete de avión 00:11:24
Es lo que yo 00:11:25
Compro, ¿vale? 00:11:26
Y tendrá dentro 00:11:29
La información para que yo ya 00:11:30
Con ese pueda viajar, ¿vale? 00:11:33
Entonces, ¿qué es la información 00:11:35
Que me sirve 00:11:36
En un billete de avión? 00:11:39
String 00:11:44
Nombre 00:11:47
Dejamos la nombre, ¿vale? 00:11:48
Nombre incluye también los apellidos 00:11:50
Es un identificador, podría poner 00:11:53
DNI, ¿vale? 00:11:55
El número de vuelo 00:11:56
¿Se puede enlazar? 00:12:03
Ah, perdón, perdón 00:12:11
Hagamos así 00:12:12
Vuelo, vuelo 00:12:13
¿Lo puede hacer? 00:12:16
Vuelo punto 00:12:20
No recuerdo cómo se llama la variable 00:12:21
Pues doy a asignar a este billete 00:12:24
Un objeto de tipo 00:12:26
Vuelo, para decirle 00:12:28
Oye mira, toda la información del vuelo 00:12:30
Que vas a hacer, pues la encuentras 00:12:32
En este objeto que es un objeto de este tipo 00:12:34
Entonces te encontrarás ahí dentro 00:12:36
Toda esta información 00:12:38
Si yo quiero 00:12:39
Puedes poner vuelo punto en un vuelo 00:12:45
Y encontraré esta cosa aquí 00:12:47
Por ejemplo, si quiero saber de dónde va 00:12:49
A dónde viene 00:12:51
Pues aquí tendré un 00:12:52
Vuelo punto destino 00:12:54
Vuelo punto origen 00:12:57
Si yo asigno a este billete 00:12:58
Un determinado vuelo, sé que es un billete 00:13:01
Para este vuelo 00:13:03
Por ejemplo 00:13:05
Que podría servir también para aquí 00:13:07
Eh, sí, son cosas un poco raras porque aquí 00:13:12
Esto de aquí ya me genera algún tipo de problema 00:13:26
¿Vale? Pero bueno, ya veremos qué hacemos con él 00:13:30
Eh, el número de asiento nuestro lo queremos gestionar 00:13:34
Hagamos que no 00:13:39
¿Vale? En el sentido que me da igual 00:13:40
Si me venden un billete es que hay espacio en ese avión 00:13:43
¿Vale? Luego donde me siento 00:13:46
Ya es relativo 00:13:48
Hay compañías que 00:13:50
Por ejemplo, no permiten 00:13:59
Ha habido un periodo en que ni siquiera creo Ryanair 00:14:00
Te permitía pillar el asiento 00:14:03
Tú entrabas y era 00:14:04
Y era la lucha 00:14:05
¿Vale? Nosotros estamos ahí 00:14:08
¿Vale? 00:14:10
¿Qué más podría interesar en un billete de avión? 00:14:12
El día 00:14:16
La fecha 00:14:17
Pongámosla así 00:14:19
General, ¿vale? 00:14:24
Luego ya 00:14:27
Veremos qué hacemos 00:14:28
Bueno, por ahora lo dejamos así 00:14:30
Veremos si nos sirve algo más 00:14:32
Pues modificaremos estas cosas, ¿vale? 00:14:35
Entonces, public 00:14:38
Billete 00:14:39
De avión 00:14:42
Pilla uno 00:14:45
String nombre 00:14:47
Vuelo 00:14:50
No, vuelo, vuelo, escucha 00:14:56
precios y lo que hace aquí dentro es asignar esto es igual 00:14:59
fecha 00:15:22
precio 00:15:26
es igual a precio 00:15:37
vuelo 00:15:40
es igual a vuelo 00:15:43
nombre 00:15:46
es igual a nombre 00:15:48
punto 00:15:50
vale 00:15:57
no se si he dicho algo raro 00:16:00
porque no me pone los coordines justos 00:16:11
lo descubriremos, vale 00:16:16
Que podemos hacer 00:16:18
Dejamos así también 00:16:22
Hay un error aquí 00:16:28
No sé si el billete de avión 00:16:31
Por si mismo, estos son objetos 00:16:39
Que representan datos 00:16:41
Entonces poco le podemos hacer 00:16:44
Podría hacer 00:16:47
para trabajar le voy a hacer dos constructores distintos, un constructor que no dice nada 00:16:49
De la first class 00:17:38
Entonces asume que automáticamente es falso 00:17:39
Y si en vez quiero que sea 00:17:41
De primera clase 00:17:44
Pues al final 00:17:45
Le pongo 00:17:46
Otro boolean 00:17:48
Se lo puedo pasar o no pasar 00:17:54
Si se lo paso 00:18:02
En automáticamente 00:18:06
Asume que no es primera clase 00:18:07
Si en vez le paso true o false 00:18:09
Pues dirá si es primera clase o 00:18:11
O segunda 00:18:13
O clase económica 00:18:15
¿Vale? Esto para que veáis que hay dos constructores 00:18:16
Se puede meter constructores 00:18:22
Lo importante de los constructores, si os acordáis 00:18:23
Es que no tengan la misma secuencia de parámetros 00:18:25
¿Vale? Porque yo en cada momento tengo que saber 00:18:31
Si estoy utilizando este constructor o este constructor 00:18:35
Entonces si a mi constructor le paso estos tipos de valores 00:18:37
Cuatro valores que correspondan a estos tipos 00:18:42
Estoy usando este constructor 00:18:45
Si le paso 5 00:18:47
Correspondientes a estos tipos 00:18:49
Estoy usando este otro constructor 00:18:50
Pero en ningún momento me puedo confundir 00:18:52
¿Vale? 00:18:55
Si yo quitara este de aquí y hubiera 2 00:18:56
Diría, ¿Cuál de los dos tengo que usar? 00:18:58
¿Sí? 00:19:01
¿Dudas? 00:19:03
Vale, entonces vamos a usar estas clases 00:19:07
¿Vale? 00:19:09
La nueva clase 00:19:11
Que hacemos prueba 00:19:17
Aviones 00:19:18
O agencia 00:19:20
Esta vez le pongo main 00:19:24
¿Vale? Para que haga algo 00:19:29
¿Si? Entonces 00:19:30
Primero no hago interacción 00:19:32
Con el usuario ¿Vale? 00:19:35
Me voy a 00:19:37
Gestionar las cosas 00:19:38
Yo y hacer pruebas yo 00:19:41
Luego después cambiamos un poco 00:19:43
Para que yo pueda hablar con el sistema 00:19:45
Que el sistema me responda algo 00:19:47
¿Vale? Entonces 00:19:49
El primer paso que yo haría 00:19:51
Es crear las conexiones 00:19:53
Es decir, cuáles son los vuelos posibles 00:19:54
Lo hago con el main 00:19:57
Para crearme una serie de vuelos 00:19:59
Es posible que estos vuelos 00:20:01
En la realidad ya me los den hecho 00:20:03
Lo encuentre en una base de datos 00:20:04
Lo vaya a buscar 00:20:06
En un fichero, no lo sé 00:20:08
Pero como no los sabemos usar, me las creo yo 00:20:10
Entonces la primera cosa que hago 00:20:13
Como string es 00:20:15
Crear 00:20:16
Vuelos 00:20:19
Un metodito 00:20:20
Que se llama crear vuelos 00:20:24
Vale 00:20:26
¿Qué quiero que haga crear vuelos? 00:20:27
No, yo quiero que me cree 00:20:36
Todos los vuelos posibles 00:20:37
¿Vale? 00:20:39
Sobre el que yo luego jugaré un poco 00:20:40
El concepto es que 00:20:43
¿Dónde guardo estos vuelos? 00:20:44
¿Qué hago? 00:20:46
¿Un objeto, un vuelo solo? 00:20:48
¿En qué sentido? 00:20:53
¿Cómo? 00:20:57
Es como guardo una serie de objetos 00:20:58
Como guardaba una serie de string 00:21:01
Por ejemplo 00:21:05
¿Vale? 00:21:08
Entonces si yo hago que este método de aquí 00:21:10
Sea lo que sea 00:21:12
Me devuelve 00:21:14
Un array de que 00:21:16
¿Qué hace esta cosa aquí? 00:21:18
Este método de aquí 00:21:31
Que ahora no he creado todavía 00:21:32
Lo tengo que crear 00:21:33
Lo que va a crear es 00:21:34
Una serie de objetos vuelos 00:21:37
Los guardas 00:21:39
Lo guardas en un array de vuelo 00:21:41
Y luego estos array de vuelo 00:21:45
Me los devuelve 00:21:47
Aquí 00:21:48
Entonces a partir de este punto de mi programa 00:21:50
Y asumo que tendré 00:21:53
Un array vuelos 00:21:54
Con dentro todos los vuelos que gestiona 00:21:56
Mi empresa 00:21:58
Mi agencia 00:22:00
¿Si? 00:22:01
Vale, vamos a hacer 00:22:04
Este método de aquí 00:22:06
Entonces, aquí abajo 00:22:09
Yo hago public 00:22:10
Que tiene que devolver 00:22:11
A ver, aquí 00:22:15
Tatic 00:22:25
Lo pongo o no 00:22:27
Luego tengo que poner 00:22:29
Lo que devuelve 00:22:31
Nombre 00:22:33
Parámetros 00:22:37
¿Sí? 00:22:41
Así es como declaro 00:22:46
Un método 00:22:48
¿Vale? 00:22:52
Por ahora esto 00:22:53
Lo dejamos por ahí 00:22:54
¿Hay que ponerlo estático o no? 00:22:55
Ni idea 00:22:57
¿Qué devuelve? 00:22:58
¿Estamos seguros que no devuelve nada? 00:23:02
Tiene que devolver un vuelo 00:23:05
Un vuelo 00:23:12
Tiene que devolver un vuelo 00:23:13
Tiene que devolver un array de vuelos 00:23:15
Si yo pongo esto 00:23:19
Le estoy diciendo 00:23:22
Oye, mira, tú hagas lo que hagas 00:23:26
Al final me tienes que devolver un vuelo 00:23:28
Un objeto vuelo 00:23:31
Pero yo no quiero un objeto vuelo 00:23:32
Quiero un array de vuelos 00:23:34
Entonces, ¿qué le hago? 00:23:36
Ahí está 00:23:45
Esto lo que me está diciendo es 00:23:45
Te devolveré un array de vuelos 00:23:49
¿Sí? 00:23:51
¿Cómo se llama? 00:23:56
¿Qué parámetros pilla? 00:24:02
Ninguno 00:24:09
Que yo sepa ninguno 00:24:10
¿Vale? 00:24:11
Por lo que quiera hacer con este método, ninguno 00:24:12
¿Vale? 00:24:14
Y yo no le digo nada, no le paso nada 00:24:15
Y él lo que hará es crearse una serie de vuelos 00:24:17
¿Sí? 00:24:19
Ahora veremos cómo lo hacemos dentro 00:24:20
Si luego necesitaré que me pasen algunos parámetros 00:24:22
Pues se los pediré y lo pasaré desde aquí 00:24:25
¿Vale? 00:24:27
Y ahora el problema es 00:24:28
¿Qué hago? ¿Lo hago estático o no? 00:24:30
A esto se llama crear vuelos 00:24:33
¿Vale? 00:24:35
Antes de mirar este estático 00:24:42
Sigamos un poquito más 00:24:43
Lo que voy a hacer aquí dentro es 00:24:45
Necesitaré un array de vuelos 00:24:48
¿Cuántos? 00:24:50
Quiero más, quiero menos, esto lo veremos 00:25:05
¿Vale? 00:25:11
Es para hacer pruebas 00:25:12
Y al final de todo 00:25:13
Antes de acabar, ¿qué tendré que hacer? 00:25:15
¿Vale? 00:25:23
Entonces, lo que voy a hacer aquí 00:25:24
Es lo siguiente 00:25:26
El main empieza llamando a este método 00:25:27
Crear vuelos 00:25:31
¿Qué hace este crear vuelos? 00:25:31
Pues me crea un array de vuelos 00:25:33
Lo rellenará 00:25:35
Y al final 00:25:37
Me lo pasa a mí 00:25:39
Y yo lo guardo aquí dentro 00:25:40
Entonces 00:25:42
Sustantemente este método lo que hace es crearme 00:25:44
Un array de vuelos 00:25:46
Que luego yo podré 00:25:47
Acceder desde mi mail 00:25:50
Me da un error 00:25:52
Vamos a ver que error es 00:25:56
No puedo hacer una referencia 00:25:57
Estática 00:26:07
A un método 00:26:08
Al método no estático crear vuelos 00:26:10
Desde el tipo agencia 00:26:13
¿Qué quiere decir esta cosa? 00:26:17
me dice yo soy estático estoy en un contexto estático vale dentro de agencia desde aquí 00:26:20
no puedo llamar un método que no sea estático cuidado que esto es sutil y es interesante y lo 00:26:35
veremos varias veces antes que lo entendemos os acordáis ayer en los ejemplos que hacíamos 00:26:49
Nosotros cuando llamamos 00:26:55
Un método, por ejemplo 00:26:58
Esto lo llamamos un método 00:26:59
Este método 00:27:01
¿Era estático o no? 00:27:02
Veámoslo 00:27:09
Este método de aquí 00:27:11
No es estático 00:27:13
Oye, pero 00:27:17
Lo estoy llamando desde el main 00:27:19
Que es estático 00:27:22
Entonces, ¿qué diferencia hay 00:27:23
entre este de aquí que está llamando un método no estático con respecto a este 00:27:26
de aquí que está llamando un método estático qué diferencia notáis entre 00:27:34
esto y esto no pero futbolista 00:27:38
Vale, entonces entre esto y 00:27:47
Esto 00:27:51
¿Dónde está aquí? 00:27:53
Esto 00:27:56
¿Dónde está? 00:27:57
Acelera, esto 00:27:59
¿Ahora están en la misma clase? 00:28:00
No hay nubos delante 00:28:10
Aquí 00:28:15
Dice entre este 00:28:16
Y este 00:28:20
Ideas 00:28:23
Que este de aquí 00:28:31
Se está llamando 00:28:45
Sobre un objeto 00:28:48
Yo estoy diciendo 00:28:50
Acelera del objeto 00:28:52
Big2 00:28:54
Estoy haciendo hacer 00:28:54
Una acción a este objeto 00:28:57
Entonces no es estático 00:29:00
Es un objeto 00:29:02
Concreto que hace una acción 00:29:04
Sin embargo aquí, crear vuelos, no lo estoy llamando sobre un objeto 00:29:05
Y entonces no es un objeto que crea los vuelos 00:29:11
Es crear los vuelos en general 00:29:17
Es la clase que crea los vuelos, no un objeto concreto que crea los vuelos 00:29:19
Si el método es de clase, es estático 00:29:24
Si el método es de un objeto, no es estático 00:29:29
¿Puede ser estático ser un objeto o no? 00:29:35
Luego depende de qué estás diciendo 00:29:40
¿Puede un objeto llamar un método estático? 00:29:42
Sí 00:29:45
Dentro de un método 00:29:45
Dentro de un método estático 00:29:48
Puedes llamar un método 00:29:50
Dentro de un método no estático puedes llamar un método estático si quieres 00:29:51
Y al revés, lo hemos visto aquí 00:29:54
La única cosa es que 00:29:56
Si el método que yo tengo 00:29:58
Si el método que yo he hecho 00:30:00
No es estático 00:30:02
Quiere decir que lo tendré que llamar sobre un objeto 00:30:03
Es algo propio de un objeto 00:30:06
Cada instancia ejecutará su propio método 00:30:09
Y tendrá, tendencialmente, resultados distintos 00:30:13
¿Vale? 00:30:17
Sin embargo, si lo llamo así 00:30:20
O sea, no lo llamo sobre un objeto 00:30:24
Pues entonces es un método que se define como estático 00:30:26
Es un método de clase 00:30:31
¿Sobre qué objeto se lanza este aquí? 00:30:32
Sobre ninguno 00:30:35
Como no sé sobre qué objeto lanzarlo 00:30:35
Pues no es un objeto normal 00:30:38
Es un estático 00:30:40
¿Vale? 00:30:41
Grosso modo 00:30:43
Profundizaremos sobre esto más adelante 00:30:44
Por ahora 00:30:46
Sigamos con el ejemplo así 00:30:50
Por ahora simplemente asumir que esto es estático 00:30:52
Porque si lo quito me da un error 00:30:55
Entonces lo dejo 00:30:57
¿Vale? 00:31:00
La razón de por qué estoy haciendo esto es porque esto no tiene un objeto punto crear vuelos 00:31:01
Entonces sería no estático 00:31:08
Como este de aquí es un objeto, es un método que se llama desde aquí 00:31:11
Es como una función de la que veíamos antes 00:31:16
Las funciones y procedimientos son parecidos a los métodos estáticos 00:31:19
De hecho cuando nosotros habíamos visto las funciones y los procedimientos 00:31:24
Todos los ejemplos que hemos hecho hemos siempre puesto static 00:31:28
Es desde que hemos introducido los objetos 00:31:31
Que hemos quitado el static 00:31:35
¿Si? 00:31:37
Un método static 00:31:40
Es algo que es siempre igual 00:31:41
Para toda la clase 00:31:45
No depende de un objeto 00:31:46
Mientras que un método sin static 00:31:48
Depende del propio objeto 00:31:51
¿Vale? 00:31:53
Si yo llamo cambia posición 00:31:54
Sobre el objeto A o sobre el objeto B 00:31:56
Cambiaré la posición del objeto A o del objeto B 00:31:58
¿No? De los dos 00:32:02
Entonces, dependiendo de quién llama este método 00:32:03
El resultado es distinto 00:32:06
¿Sí? 00:32:09
Después hacemos más ejemplos sobre esto 00:32:11
Con un ejemplo matemático 00:32:13
Para clarificar 00:32:15
Por ahora simplemente tenemos esto 00:32:16
Vale, entonces yo tengo un método aquí 00:32:19
Que lo que hace es crearme los vuelos 00:32:21
Y luego los tendré aquí 00:32:24
A partir de ahora los puedo utilizar 00:32:25
Vamos a implementar bien este vuelo 00:32:26
¿Qué quiero hacer? 00:32:28
Pues aquí quiero crear 10 vuelos 00:32:29
Para que luego los pueda utilizar 00:32:33
¿Vale? 00:32:35
Entonces 00:32:38
Lo voy a crear manualmente 00:32:38
¿Vale? 00:32:43
Para tener una base sobre lo que hago jugar 00:32:43
¿Vale? 00:32:46
Sobre qué jugar 00:32:46
Entonces voy a crear 00:32:47
Un vuelo de posición 0 00:32:48
Por ejemplo, ¿qué pongo? 00:32:51
¿Cómo creo un nuevo objeto vuelo? 00:32:53
¿Cómo lo creo? 00:32:55
¿Qué escribo? 00:33:09
¿Qué escribo? 00:33:13
Necesito una referencia, ya la tengo 00:33:16
¿Ves esto? 00:33:18
Esto es como haber puesto vuelo x es igual 00:33:19
Pues en vez de ponerlo en la variable x 00:33:22
Lo estoy poniendo en la posición 0 00:33:25
De este array de 10 posiciones 00:33:27
New 00:33:28
Vuelo 00:33:31
Si quiero crear un nuevo objeto 00:33:34
Necesito la new 00:33:38
¿Vale? 00:33:39
Vuelo es el constructor que tenía aquí 00:33:42
¿Vale? 00:33:44
Entonces, el vuelo pilla 00:33:46
Todas estas cosas de aquí 00:33:48
¿Vale? 00:33:50
Entonces, compañía en un vuelo, destino y origen 00:33:51
Creo que hay amantes del destino y del origen 00:33:55
Pero da igual 00:33:58
Gracias 00:33:59
Entonces, compañía 00:34:05
¿Qué compañía tiene? 00:34:07
Ahí está 00:34:09
¿Qué es? 00:34:11
Que ponemos otra 00:34:13
Venga 00:34:14
¿Qué más? 00:34:18
Número 00:34:19
¿Cómo me da? 00:34:20
Origen 00:34:24
Destino 00:34:25
Ya está 00:34:31
Este es uno 00:34:37
¿Vale? 00:34:38
Lo que estoy haciendo es crear las conexiones de posibles aviones que hay 00:34:40
Para luego poder jugar con ellas 00:34:45
¿Vale? 00:34:47
Entonces 00:34:48
¿Lo podría esto automatizar? 00:34:48
Sí 00:34:52
Ahora 00:34:52
Requeriría un poquito de trabajo, ¿vale? 00:34:53
Entonces 00:35:00
El 1 00:35:00
El 2 00:35:02
El 3 00:35:04
Y el 4 00:35:05
Hacemos que son 5 solas 00:35:06
Porque si no me aburro 00:35:09
Y cambiamos un poco cosas así 00:35:10
Este es FR 00:35:12
Esto es ahí 00:35:15
Esto es 00:35:16
Así 00:35:18
este aquí cambió así 1 2 00:35:20
entonces tenemos madrid pisa tenemos para madrid de roma tenemos 00:35:28
pisa madrid y tenemos 00:35:36
roma pisa 00:35:45
que no y tenemos roma madrid es para dejarlo sencillo 00:35:49
vale porque si no luego puede haber caos entonces tengo varios porque os 00:36:02
recuerdo que por algo que nosotros somos malvados esta es la origen 00:36:09
y este es el destino porque porque yo así lo he declarado 00:36:14
dónde está 00:36:23
Antes el destino y luego el origen 00:36:25
Si cambiara 00:36:27
Esto, origen y destino 00:36:29
Pues a lo mejor 00:36:31
Origen 00:36:32
Destino 00:36:33
Somos menos simpáticos 00:36:35
Destino 00:36:38
¿Vale? Más lógico para nosotros pensarlo así 00:36:39
Que luego nos confundimos 00:36:43
Vale, ahora este es el origen y este es el destino 00:36:44
¿Vale? Y con esto he creado 00:36:46
Una red de 5 posibles 00:36:51
Vuelos, ¿vale? 00:36:53
Que luego pasaré aquí 00:36:54
Ahora, aquí dentro hay estos cinco objetos 00:36:56
¿Vale? Son cinco objetos distintos 00:36:58
¿Sí? 00:37:01
Vale 00:37:06
¿Qué vamos a hacer ahora con esto? 00:37:06
Pues la idea es que 00:37:10
Vamos a pedir al usuario, por ejemplo 00:37:11
Dónde quiere viajar o de dónde sale 00:37:14
Y le decimos las posibilidades de dónde puede viajar 00:37:17
¿Sí? 00:37:21
Entonces habrá un string 00:37:23
Origen 00:37:24
Que por ahora la fijo 00:37:25
Luego la preguntaré al usuario 00:37:29
¿Vale? Madrid 00:37:30
¿Sí? 00:37:32
Ahora, ¿cómo hago? 00:37:36
Hacerle decir al 00:37:38
Al sistema 00:37:40
Todos los posibles destinos 00:37:43
Desde Madrid 00:37:45
Los posibles destinos 00:37:46
Desde 00:37:54
Origen 00:37:55
Son 00:37:58
¿Cómo lo hago? 00:38:05
muestra vuelos 00:38:10
muestra destinos 00:38:24
vamos a hacer 00:38:28
otro 00:38:32
que pongo 00:38:33
public 00:38:36
static 00:38:39
muestra 00:38:42
destino 00:38:49
que necesito para poder 00:38:51
mostrar los destinos 00:38:55
ah, eh, espera 00:38:56
que devuelvo, perdón 00:39:02
Puedo devolver un string y luego imprimirla 00:39:04
O puedo que imprima directamente 00:39:12
Haré que imprime directamente 00:39:13
Que así le dejo un void 00:39:16
¿Vale? 00:39:17
¿Qué necesito para que funcione? 00:39:19
Se enfada porque 00:39:23
Lo he escrito mal 00:39:24
Nuestra destino 00:39:30
Muy bien, ahora 00:39:33
¿Qué necesito? 00:39:35
El array 00:39:43
Y ¿qué más? 00:39:44
El string origin 00:39:54
Pásame todos los vuelos posibles 00:39:55
Y el origen 00:40:02
Y yo te voy a escribir desde este origen 00:40:03
Donde puedes ir 00:40:05
Entonces cuando lo llamo aquí 00:40:05
¿Qué le tengo que pasar? 00:40:10
Vuelos 00:40:16
Origen 00:40:16
Este 00:40:20
Array de aquí, que es este de aquí 00:40:26
Que contiene todas las posibles conexiones 00:40:29
Será esto 00:40:31
Aquí dentro 00:40:33
Y mi origen, que en este caso 00:40:33
en Madrid, luego la pediré al usuario 00:40:37
será esta aquí 00:40:39
¿si o no? 00:40:40
entonces ¿qué hago ahora? 00:40:44
for 00:40:48
int igual a cero 00:40:49
y menor que 00:40:54
vuelo 00:40:57
v punto 00:40:59
lenght 00:41:01
y más más 00:41:02
v de i 00:41:17
Punto destino 00:41:21
Origen 00:41:32
Es igual 00:41:36
Punto equals 00:41:41
Ya me las quitó él 00:41:46
Entonces, ¿qué hago? 00:41:56
¿Sí? 00:42:16
Voy recorriendo todos estos arrays de aquí 00:42:18
¿Dónde están? Aquí 00:42:21
Todo este array de aquí, ¿vale? 00:42:22
Si la origen 00:42:24
Es igual a esto que me has dado tú 00:42:26
En este caso sale Madrid 00:42:29
O sea, si Madrid es igual a Madrid 00:42:32
Entonces escríbeme el destino 00:42:33
Entonces me escribirás Pisa 00:42:36
¿Este es igual? Sí 00:42:38
Entonces escríbeme Roma 00:42:40
¿Este es igual? No, no escribo nada 00:42:41
¿Este es igual? No, no escribo nada 00:42:43
¿Este es igual? No, no escribo nada 00:42:45
Y al final habré escrito o Pisa o Roma 00:42:46
Que son los dos destinos al que puedo llegar 00:42:50
Desde Madrid 00:42:52
¿Sí o no? 00:42:53
¿Sí o no? 00:42:57
Lo repito 00:42:58
Lo repito 00:43:00
Entonces, lo que estoy haciendo es 00:43:03
Yo tengo 00:43:06
Este array que he creado 00:43:07
Que tiene cinco posiciones 00:43:09
Que son estos cinco objetos 00:43:11
Dentro de estos objetos 00:43:12
Este es el origen, este es el destino 00:43:15
Entonces lo que estoy haciendo yo es 00:43:17
Por un índice 00:43:20
Y que recorre 00:43:22
Todos estos valores de aquí 00:43:23
Vete a ese índice de allí 00:43:25
Por ejemplo estamos en cero 00:43:27
Vete a v de cero 00:43:28
Vete a mirar la variable origen de esta posición 00:43:29
Entonces me voy a v de 0, me voy a origen y encuentro esto 00:43:37
Si esto es igual a lo que me has dado tú 00:43:42
Entonces escribe por pantalla lo que hay en destino 00:43:50
O sea esto 00:43:57
Si no, no 00:43:58
Cuidado con esto, punto origen, punto equals, ¿vale? 00:44:03
Esto sería igual a ponerlo así. 00:44:07
Si estoy de aquí, punto origen, porque es un objeto, 00:44:12
o sea, estoy en un objeto, entonces cuando accedo a esto, ¿vale? 00:44:18
Estoy aquí, tengo mucha información, de esta información accedo a este campo, 00:44:21
al campo que se llama origen, ¿vale? 00:44:26
Si este es igual, igual a lo que me has dicho tú de buscar, 00:44:29
pues entonces escribo su correspondiente destino. 00:44:32
Solo que os recuerdo que cuando hay un string por un lado 00:44:35
Lo veis todos que este es un string 00:44:40
Porque si yo accedo a esto 00:44:42
¿Qué es esto? ¿Qué tipo es esto? 00:44:45
VDI, ¿qué tipo tiene? 00:44:52
¿Qué ha metido dentro de VDI? 00:45:04
¿Un objeto? ¿De qué tipo es ese objeto? 00:45:07
Por lo tanto, este señor, ¿qué tipo tiene? 00:45:15
Vuelo 00:45:19
De hecho, si yo voy a ver el tipo vuelo, ¿vale? 00:45:20
La clase vuelo que me define su tipo 00:45:24
Sé que cualquier objeto de tipo vuelo 00:45:26
Luego dentro tiene todas estas cosas aquí a las que puedo acceder 00:45:28
Y entonces de todas las cosas que yo pueda acceder 00:45:32
Voy a acceder al campo origen 00:45:35
Fijaos que si yo hago esto 00:45:39
Aquí él me dice, vale, muy bien 00:45:43
¿A qué quieres acceder? 00:45:47
Y entre las varias cosas que puede tener un objeto vuelo 00:45:48
Tiene origen, destino, compañía, número vuelo, asiento disponible 00:45:53
¿Sí o no? 00:45:57
Vale 00:46:00
Entonces yo accedo a este campo de aquí 00:46:01
Origen 00:46:04
Ahora tengo que comprobar si lo que he seleccionado 00:46:04
La origen de este vuelo 00:46:10
¿Vale? 00:46:12
Es igual a la origen que me han dado aquí 00:46:13
Entonces 00:46:16
Me saldría de ponerle el igual igual 00:46:18
Pero no puedo ponerle el igual igual 00:46:21
Porque cuando se comparan 00:46:23
Dos strings 00:46:25
No se compara con igual igual 00:46:26
Se compara con 00:46:28
Punto equals 00:46:29
Este es un método 00:46:31
¿De qué clase? 00:46:34
Pregunta para vosotros 00:46:41
¿Dónde está 00:46:43
Definido este método de aquí? 00:46:44
Sí 00:46:52
¿Pero a qué clase pertenece? 00:46:52
O sea, cuando yo llamo este de aquí 00:46:55
¿En qué clase busco para este método? 00:46:56
String 00:47:01
Porque lo estoy llamando sobre un string 00:47:02
¿Vale? 00:47:04
Entonces, en realidad este señor de aquí 00:47:07
No pertenece a string 00:47:09
Si no me equivoco, pertenece a object 00:47:11
A object 00:47:13
Pero no sabemos qué es 00:47:14
Pero yo iré a mirar la implementación de string 00:47:16
Porque estoy haciendo 00:47:20
Lo estoy llamando sobre un objeto 00:47:21
¿Qué objeto es? 00:47:23
Sobre el que lo estoy llamando 00:47:24
Este objeto 00:47:25
Porque este señor de aquí 00:47:28
Si va a mirar que es 00:47:33
Su string 00:47:34
String es un objeto 00:47:37
Entonces 00:47:39
En la 00:47:42
Definición de string 00:47:43
En la clase string 00:47:47
Estará definido el objeto equals 00:47:48
Y yo llamo 00:47:51
Un objeto 00:47:52
Punto equals 00:47:54
Que lo veo mal 00:47:55
Lo hago por pasos 00:47:57
String 00:47:59
Un posible origen 00:48:00
¿Cómo se llama? 00:48:10
¿Sí? 00:48:13
Es igual a esta cosa aquí 00:48:15
Y si esta cosa de aquí 00:48:17
Es igual a 00:48:26
Así lo veis mejor 00:48:28
Primero hacer al vuelo 00:48:31
Mira 00:48:36
Todavía más por pasos 00:48:36
Vuelo, mi vuelo 00:48:38
Es igual a 00:48:41
V de Y 00:48:43
Mi vuelo 00:48:43
Esto lo está haciendo pasito a pasito 00:48:50
Primero acedo a la posición 00:48:55
Y de la array 00:48:57
Y me saco un objeto vuelo 00:48:59
Vale, lo tengo aquí, este es un objeto vuelo 00:49:01
Vale, desde este objeto vuelo 00:49:03
Acedo a su 00:49:06
Atributo origen 00:49:07
Que es un string, y me lo guardo en un string 00:49:08
Vale, lo tengo aquí 00:49:11
Si ahora este origen 00:49:13
Es igual a la que me has dado tú 00:49:14
Entonces 00:49:17
Aquí podría poner 00:49:19
Ory 00:49:22
No, mi vuelo 00:49:24
Entonces accede a este objeto de aquí 00:49:25
Que estabas considerando 00:49:32
Y mira su destino 00:49:33
¿Sí? 00:49:34
Estos todos divididos pasito a pasito 00:49:39
Pero claro, no lo necesito hacer así 00:49:42
¿Vale? 00:49:44
Y entonces ¿Cómo lo hago? 00:49:47
V de I 00:49:55
Esto 00:50:04
¿Sí? 00:50:06
Que sería esto 00:50:09
Entonces, punto origen 00:50:10
Todo esto 00:50:12
Es esta cosa aquí 00:50:16
¿Vale? 00:50:19
Punto equals 00:50:21
O, entonces accede a 00:50:23
V de I 00:50:26
Estas dos cosas hacen la misma 00:50:27
Hacen lo mismo, ¿vale? 00:50:30
Solo que esto lo va 00:50:32
Descomponiendo el acceso 00:50:33
A los varios 00:50:36
Objetos, trocito a trocito 00:50:37
Mientras que este de aquí 00:50:40
Lo hace de golpe 00:50:42
Así es como se usa 00:50:43
Así no 00:50:47
Dudas 00:50:49
Entonces, este de aquí lo hace para todos 00:50:52
Estos vuelos de aquí 00:50:59
Y me saca 00:51:01
Solo los destinos 00:51:02
Cuyo origen 00:51:05
Sea Madrid 00:51:07
Vamos a ver si funciona 00:51:08
Los posibles destinos 00:51:13
Desde Madrid son Pisa 00:51:20
Y Roma 00:51:22
Entonces yo ahora 00:51:23
Pediré al usuario 00:51:32
Elige un destino 00:51:33
Y él lo pondré 00:51:35
Dentro de destino 00:51:40
Luego se lo preguntará a él 00:51:42
Pero por ahora voy a poner aquí 00:51:50
Yo directamente los valores 00:51:52
Para hacer pruebas 00:51:54
Porque así cada vez que 00:51:55
Lanzo el programa, no tengo que escribir nada 00:51:57
Se prueba 00:52:00
¿Vale? 00:52:01
Si cada vez me dice, ¿de dónde vienes? 00:52:03
De Madrid, tengo que escribir Madrid 00:52:06
¿De dónde vas? Pues pisa, pues tardo mucho tiempo 00:52:07
¿Sí? 00:52:10
Vale 00:52:16
Entonces, ¿qué hago ahora? 00:52:16
La origen ya la tengo 00:52:27
Tengo origen y destino 00:52:29
Billete 00:52:31
¿Por qué tengo que mostrar el origen? 00:52:32
La origen ya la sé 00:52:37
No lo sé, decidme vosotros 00:52:38
Soy una agencia, viene un señor 00:52:43
Me dice, ay, yo quiero salir de Madrid 00:52:45
Vale, desde Madrid podéis ir a Pisa, Roma 00:52:48
Vale, quiero ir a Pisa 00:52:49
¿Y ahora qué hago? Hasta luego 00:52:51
Tendrá que construirle el billete 00:52:52
Con esta base de aquí 00:52:55
¿Cómo construyes el billete? 00:52:56
Hagámoslo aquí 00:53:02
Para variar 00:53:03
¿Qué necesito para un billete? 00:53:05
Estas cosas de aquí 00:53:11
Nombre 00:53:12
¿Vale? 00:53:13
Entonces, aquí le preguntaré su nombre 00:53:16
Luego se lo preguntaré 00:53:18
Todas estas cosas, ¿vale? 00:53:23
Eh, pésalo 00:53:25
Vale, hecho, lo tengo 00:53:26
¿Qué más quiero? El vuelo 00:53:30
¿Cómo saco el vuelo? 00:53:32
¿Cómo lo hago? 00:53:45
Tengo que hacer otro método parecido a eso 00:53:51
¿Se puede hacer de forma más eficiente? 00:53:53
Pues probablemente sí, eh 00:53:55
Pero bueno, por ahora la eficiencia 00:53:56
Es el último de mis problemas 00:53:58
¿Vale? Entonces aquí 00:54:01
Ahora yo le diré que 00:54:02
El vuelo que yo busco 00:54:04
¿Cómo lo encuentro? 00:54:05
Amente con busca vuelo 00:54:13
¿Quién me dice cómo se hace 00:54:15
Busca vuelo? 00:54:26
Public, static 00:54:30
¿Quién me tiene que devolver? 00:54:32
Vuelo 00:54:43
Busca vuelo 00:54:44
¿Qué necesito 00:54:47
Para buscar un vuelo? 00:54:51
Por ejemplo, el destino, ¿no? 00:54:59
Cuidado 00:55:08
En la realidad, eso sería un poquito más 00:55:08
Complejo, porque podría tener 00:55:10
Varios vuelos 00:55:12
Varias compañías que hacen el mismo vuelo 00:55:14
¿Vale? Pero lo simplificamos, ¿eh? 00:55:16
Aquí busco el primero que encuentro 00:55:18
Y ya está 00:55:20
Entonces, cuando lo busco 00:55:20
Desde aquí, ¿qué le tengo que pasar? 00:55:24
¿Dónde tengo el origen? 00:55:26
¿Os acordáis? 00:55:34
Tenía el origen, el origen, el destino, el destino 00:55:34
Por lo tanto 00:55:37
Antes lo que estaba buscando 00:55:39
Eran 00:55:41
Los posibles vuelos 00:55:42
Desde una determinada origen 00:55:46
¿Sí? 00:55:48
Ahora yo quiero un vuelo concreto 00:55:49
El que va desde aquí hasta aquí 00:55:51
¿Le tengo que pasar algo más? 00:55:54
¿Os acordáis? 00:56:09
¿Le tengo que pasar todos los vuelos? 00:56:11
Porque lo tengo aquí 00:56:13
¿O no? 00:56:15
Como antes cuando buscaba un origen 00:56:18
No le pasaba solo el origen 00:56:21
Y él buscaba 00:56:23
Le pasaba todas las posibles conexiones 00:56:24
Y de este búscame 00:56:27
Solo la que tiene un determinado origen 00:56:29
Ahora en vez de lo que hago es 00:56:30
Búscame 00:56:33
En todas las conexiones 00:56:34
La que tiene un determinado origen o un determinado destino 00:56:38
¿Cómo? 00:56:41
¿Cómo? 00:56:45
Porque como devuelvo algo 00:56:49
Pues entonces se enfada 00:57:02
¿Vale? 00:57:03
Es decir, que yo ahora tendré un vuelo 00:57:05
Mi vuelo 00:57:08
Y al final 00:57:11
Tendré que devolver este mi vuelo 00:57:15
Al principio 00:57:18
Este es nul 00:57:27
¿Vale? 00:57:29
Vamos a ver que hacemos aquí 00:57:31
Como hago para buscar dentro de este array 00:57:35
La que tiene 00:57:39
Origen O y destino D 00:57:40
Ah, fijamos que me he equivocado 00:57:43
O y D 00:57:45
Es igual a aquel otro 00:57:47
Solo que ahora 00:57:53
Lo que me interesa es que 00:58:03
Además que la origen sea O 00:58:06
El destino 00:58:08
Sea 00:58:16
Este if de aquí 00:58:22
Me está diciendo 00:58:27
Vete por todo la ray 00:58:29
Que teníamos nosotros, ¿vale? 00:58:32
Y pregúntate si 00:58:34
La posición actual la que estás mirando 00:58:36
Esta de aquí, ¿vale? 00:58:38
Por ejemplo 00:58:40
El origen se corresponde 00:58:40
Y el destino se corresponde 00:58:44
Entonces este es el objeto que yo quiero 00:58:46
¿Vale? 00:58:48
Si no, no 00:58:51
Y si este es el objeto que yo quiero 00:58:52
¿Qué tengo que hacer? 00:58:55
¿Qué estoy buscando? 00:59:13
He encontrado que este es el vuelo correcto 00:59:15
VDI es el vuelo correcto 00:59:17
Pues ¿qué hago? 00:59:18
Me guardo dentro de esta variable de aquí 00:59:24
El vuelo 00:59:26
Que he encontrado en este momento 00:59:28
Así que cuando salgo del for 00:59:30
¿Qué hay dentro de mi vuelo? 00:59:32
Dos opciones 00:59:39
Si lo he encontrado 00:59:40
Me ha devuelto el objeto correcto 00:59:43
Si no lo he encontrado 00:59:46
Tengo null 00:59:48
¿Si o no? 00:59:50
El resultado 00:59:57
Me lo devuelve aquí 00:59:58
Y me lo pone aquí dentro 01:00:01
O sea que yo ahora aquí dentro tengo 01:00:02
O el vuelo que estoy buscando 01:00:05
O un null 01:00:07
Vuelo 01:00:14
Not null 01:00:16
Siga adelante 01:00:18
Si o no 01:00:28
Veamos que hago 01:00:32
Entonces, ahora tengo el nombre y el vuelo 01:00:38
El, donde está, no, el billete 01:00:41
Nombre, vuelo 01:00:45
Necesito precio, fecha 01:00:47
Y si afiscas, vale 01:00:49
Entonces 01:00:51
Pinta precio 01:00:52
Es igual que la gente hace en dólares 01:00:55
Siempre 01:00:57
Que más tenía 01:00:57
Fecha 01:01:00
Tring 01:01:02
Fecha es igual 01:01:06
Al 25 01:01:09
De diciembre de 2022 01:01:11
Siempre 01:01:13
Viajamos por navidad 01:01:14
Fresh class 01:01:18
Fals 01:01:20
Esto todo lo podré preguntar al usuario 01:01:27
Hacer métodos que me lo calculan 01:01:33
Todo lo que te da gana 01:01:36
¿Vale? Pero por ahora, para hacerlo más sencillo 01:01:37
Le doy yo, siempre es 01:01:39
Que costa 100 euros 01:01:41
Siempre vamos por Navidad 01:01:42
Y siempre vamos que falte 01:01:44
¿Vale? 01:01:46
Ok, ahora tengo que crear 01:01:49
El billete, tengo todos los datos 01:01:51
Tengo 01:01:53
La origen, tengo el vuelo, perdón, aquí 01:01:55
El nombre de quien vuela 01:01:59
El vuelo 01:02:01
Que va a pillar 01:02:02
Tengo el precio, la fecha 01:02:04
Y si haces caso, no 01:02:08
Entonces ya puedo crear el billete 01:02:09
¿Cómo creo el billete? 01:02:11
Billete 01:02:25
De avión 01:02:25
No todos a la vez, por favor 01:02:27
¿Cómo creo un objeto, señores? 01:02:35
Esto ya no es la primera vez que lo hemos visto 01:02:39
Billete es igual a qué? 01:02:41
New 01:02:46
¿De qué? 01:02:46
De billete de avión 01:02:48
¿Os acordáis? 01:02:52
El constructor 01:02:56
¿Vale? 01:02:58
¿Qué le pongo aquí dentro? 01:03:00
Nombre 01:03:03
Este nombre de aquí 01:03:04
Vuelo 01:03:06
Este vuelo de aquí 01:03:10
¿Vale? 01:03:12
Porque acordaos que 01:03:15
Si estoy aquí dentro, esto no es nul 01:03:17
Por lo tanto es un objeto 01:03:19
Vuelo válido 01:03:21
¿Si? 01:03:22
Precio, fecha, Fsclass 01:03:25
Y ya está, ya me he creado 01:03:26
Mi objeto billete 01:03:37
Ahora para ver 01:03:38
Que esto ha hecho algo 01:03:47
Hagamos lo siguiente 01:03:49
Creamos 01:03:51
En billete de avión 01:03:53
Un método 01:03:55
Un toString, un imprime 01:03:57
¿Vale? Algo por el estilo 01:03:59
Quiero un método que si lo llame 01:04:01
Sobre un billete, me escriba 01:04:05
Algo de este billete, me escriba 01:04:07
Todas estas cosas bonitas 01:04:09
¿Vale? 01:04:10
Entonces, public 01:04:12
¿Qué más? 01:04:15
¿Estático o no? 01:04:17
¿Es un método 01:04:20
Que depende de la clase 01:04:21
Y será siempre igual independientemente 01:04:22
Del billete que yo llamo 01:04:24
O depende del billete sobre el que yo llamo 01:04:26
Depende del billete 01:04:28
Por lo tanto no es estático 01:04:31
Dos billetes distintos 01:04:32
Escribirán cosas distintas 01:04:35
Que devuelve 01:04:37
Hasta void 01:04:39
Puedo devolver un string 01:04:40
Depende de donde lo quiero imprimir 01:04:41
Hagamos void que es más sencillo 01:04:43
Imprimir 01:04:45
Y me dirá 01:04:47
Si eso 01:04:52
El día 01:04:57
Más 01:05:00
No, porque tú lo llamarás 01:05:03
Sobre su objeto 01:05:11
Y el objeto tendrá sus datos 01:05:11
¿Qué datos estos? 01:05:13
Entonces lo puedo llamar directamente 01:05:15
El día 01:05:16
Fecha 01:05:20
Voy a viajar 01:05:23
Más origen 01:05:31
Más destino 01:05:39
En el vuelo 01:05:44
Interesante 01:05:49
¿Cómo lo hago? 01:06:09
Lo que quiero yo es 01:06:21
Compañía en un vuelo 01:06:23
¿Vale? 01:06:26
Pongamos así, en el vuelo 01:06:27
Y el número del vuelo 01:06:29
¿Cómo saco el número del vuelo desde aquí? 01:06:30
Yo tengo aquí 01:06:33
Vuelo, que es un vuelo 01:06:36
Por lo tanto puedo acceder 01:06:39
Desde aquí 01:06:41
A vuelo 01:06:42
Este es un objeto vuelo 01:06:45
vale punto todas las características de un objeto vuelo incluidos en un vuelo 01:06:47
sí sí porque no origen el destino no están aquí verdad a jornadas que origen el destino no 01:07:04
pertenecen a billete pertenecen a este vuelo se me ha pasado a mí vale entonces aquí no hay origen 01:07:11
Aquí no hay destino 01:07:20
El origen y el destino están dentro de un objeto vuelo 01:07:21
Aquí 01:07:24
Origen y destino 01:07:24
Por lo tanto, para accederlo desde aquí 01:07:27
Lo que tengo que hacer es acceder 01:07:30
A mi campo vuelo 01:07:32
Y luego desde mi campo vuelo 01:07:34
Al origen y el destino 01:07:39
¿Sí o no? 01:07:40
De hecho, mirad, si yo lo dejo así con destino 01:07:45
Se enfada, ¿eh? 01:07:47
Me dice, destino no existe 01:07:49
Marcado en rojo 01:07:50
Me dice, destino cannot be resolved 01:07:52
To a variable 01:07:55
No es posible encontrar una variable 01:07:55
Que se llama destino, no existe destino aquí 01:07:59
Verdad, culpa mía 01:08:01
Tienes que ir a vuelo.destino 01:08:03
Ahora sí 01:08:05
En el vuelo o en un vuelo 01:08:06
Vale, dejámoslo así, podría sacar más información 01:08:12
Pero 01:08:14
Entonces 01:08:15
Si ahora llamo imprime 01:08:18
Imprimir 01:08:20
Me debería decir toda esta información 01:08:21
Por lo tanto, desde la agencia, después de haber creado el billete 01:08:24
Hago que el billete se imprima 01:08:30
¿Cómo hago que el billete se imprima? 01:08:32
Llamando el método, imprimir 01:08:37
Pero el método de imprimir es estático 01:08:38
No, por lo tanto no lo puedo llamar así 01:08:42
Lo tengo que llamar sobre un objeto 01:08:46
Billete.imprimir 01:08:49
dudas 01:08:53
veamos si esto funciona 01:08:56
aquí es cuando yo había puesto Madrid 01:09:00
me dice que los destinos son Pisa y Roma 01:09:07
luego he elegido Pisa 01:09:09
entonces el día 25 este de aquí 01:09:10
voy a viajar de Madrid a Pisa 01:09:13
en el vuelo este de aquí 01:09:15
parece funcionar 01:09:17
voy a hacer otra prueba 01:09:22
y si le pongo 01:09:24
Pisa 01:09:26
Madrid 01:09:27
el día no se que no se que 01:09:29
va a volar desde Pisa a Madrid 01:09:37
en el vuelo 1111 01:09:39
el otro vuelo 01:09:41
estos datos de aquí no cambian porque siempre lo ha dejado igual 01:09:46
pero esto 01:09:49
si que cambia 01:09:51
y si voy a Roma 01:09:52
Pisa-Roma 01:09:56
no me acuerdo si hay Pisa-Roma 01:09:57
o Roma-Pisa 01:10:01
si no está 01:10:02
los posibles vuelos desde Pisa son Madrid 01:10:05
Y como cuando he buscado Pizaroma 01:10:09
No he encontrado ninguno 01:10:12
Entonces cuando he llegado aquí 01:10:14
Vuelo 01:10:17
Seguía siendo null 01:10:17
Y por lo tanto esta cosa de aquí no la he hecho 01:10:19
Y no he hecho nada 01:10:22
Podría poner un 01:10:24
Y eso 01:10:26
Lo sentimos 01:10:33
Nuestra 01:10:36
Agencia 01:10:38
Agencia no se escribe así 01:10:40
Agencia 01:10:42
No gestiona vuelos de origen a destino 01:10:44
Entonces, si ahora pongo algo que no es 01:11:03
Dice, lo sentimos, nuestra agencia no gestiona vuelos de pisarro 01:11:08
Entonces, vamos ahora a 01:11:11
Completar este ejercicio 01:11:19
lo dejamos de en vez que este de aquí lo lea lo ponga yo directamente pues que 01:11:22
interactúe con el usuario vale entonces al principio le diré 01:11:30
dime la origen y leo la origen para leer la origen llamaré un método que es leer algo 01:11:39
Vamos a crearle el algo 01:11:59
Aquí al fondo 01:12:01
Public 01:12:02
Porque todo es otro public 01:12:05
¿Qué pongo? ¿Static o no? 01:12:06
Leer algo 01:12:13
¿Lo estoy llamando sobre un objeto o no? 01:12:14
Por lo tanto static 01:12:22
¿Qué me tiene que devolver? 01:12:23
Miradlo aquí 01:12:27
¿Qué me tiene que devolver? 01:12:28
String 01:12:32
¿Cómo se llama? 01:12:32
Lee algo 01:12:36
¿Pilla parámetros? No 01:12:37
¿Y qué hace? 01:12:39
Scanner scan 01:12:42
Es igual 01:12:44
A new 01:12:45
Scanner 01:12:47
De system.in 01:12:49
Return 01:12:51
Scan.nextline 01:12:55
Por ejemplo 01:13:00
Te lee una línea 01:13:04
Y te la devuelve 01:13:07
Como esto lee una string 01:13:09
Pues el resultado de esta operación 01:13:11
Te la devuelve 01:13:13
Entonces aquí he leído algo 01:13:14
Para el origen 01:13:18
Y aquí que haré 01:13:20
Leer algo también 01:13:23
Cada vez que llamo leo algo 01:13:29
Me leerá una línea 01:13:30
O no 01:13:32
Antes le tendré que decir algo 01:13:34
Bueno podría ponerle aquí 01:13:38
Mirad esto de dime la origen 01:13:40
Se lo pongo aquí 01:13:42
Y esto 01:13:44
Lo pongo dentro de 01:13:47
Lealgo 01:13:52
Así 01:13:53
Bring mensaje 01:13:54
Imprime mensaje 01:13:59
Ahora yo tengo una función 01:14:03
Lealgo que le doy un parámetro 01:14:06
Un mensaje, lo que hace él es escribir 01:14:08
Este mensaje, luego solicitarme algo 01:14:11
Por lo tanto, aquí le diré 01:14:13
Lealgo de dime la origen 01:14:18
Y aquí le diré 01:14:20
Le algo 01:14:22
Le dime el destino 01:14:23
Y ahora ya puedo trabajar 01:14:25
Con esto 01:14:33
Lanzo este de aquí 01:14:34
Ahora me dice 01:14:40
Dime la origen 01:14:42
Digo Madrid 01:14:44
Y me dice 01:14:46
Los posibles destinos 01:14:49
Desde Madrid 01:14:55
Son Pisa y Roma 01:14:56
Dime el destino 01:14:58
¿Dónde queréis ir? 01:15:00
Pisa 01:15:04
Pisa 01:15:05
El día 25 no sé qué 01:15:06
Voy a viajar de Madrid a Pisa 01:15:09
En el vuelo 8458 01:15:11
Vale 01:15:13
Cambiamos 01:15:13
¿Dónde queréis ir? 01:15:15
Dime el origen 01:15:17
Pisa 01:15:18
Desde Pisa puedo viajar solo a Madrid 01:15:22
Dime el destino 01:15:25
Madrid 01:15:27
¿Vale? 01:15:28
Voy a viajar de Pisa a Madrid 01:15:30
Vale 01:15:31
Roma 01:15:32
O Roma 01:15:35
Origen, Roma 01:15:36
A Roma puedo viajar a Pisa o Madrid 01:15:38
¿De dónde voy? 01:15:41
A Genova 01:15:45
Lo sentimos 01:15:46
Nuestra agencia no gestiona vuelos 01:15:48
De Roma a Genova 01:15:52
Idioma/s:
es
Autor/es:
Stefano Chiesa
Subido por:
Stefano C.
Licencia:
Reconocimiento - No comercial
Visualizaciones:
25
Fecha:
22 de noviembre de 2022 - 13:25
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
1h′ 15′ 56″
Relación de aspecto:
1.78:1
Resolución:
1280x720 píxeles
Tamaño:
345.99 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid