Saltar navegación

Ejemplo Clase Bicicleta - 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 21 de noviembre de 2022 por Stefano C.

16 visualizaciones

Más información Transcripción

Descargar la transcripción

entonces hemos hecho esta primera clase esta clase en la clase bicicleta dentro hemos decidido que 00:00:00
tenga estos parámetros de aquí vale estos son los atributos de la clase entonces yo me espero 00:00:06
que cada objeto de la clase bicicleta tenga dentro estos parámetros de aquí y luego veremos algunos 00:00:13
métodos para que la bicicleta haga algo vale ok fenómeno vamos a empezar hemos dicho ahora que 00:00:21
Íbamos a hacer lo que se llama un constructor 00:00:29
Un constructor es un método especial 00:00:31
Cuyo objetivo es 00:00:33
Crear un objeto de esta clase 00:00:35
Una instancia de esta clase 00:00:37
Un objeto particular que tendrá 00:00:38
Estos cuatro valores 00:00:40
O sea, cuatro atributos instanciados 00:00:42
A determinados valores 00:00:45
Entonces, ¿cómo se hace un constructor? 00:00:46
Public 00:00:50
Y el nombre de la clase 00:00:51
Dentro de esos conceptos 00:00:53
El constructor 00:01:02
Es parte de la clase 00:01:04
Es un método especial 00:01:05
Entre comillas, porque yo aquí me esperaría algo 00:01:07
Void, int 00:01:10
¿No? 00:01:12
Un método cualquiera 00:01:13
Aparte el static, que por ahora lo dejamos por un lado 00:01:14
Y aquí, si quisiera hacer 00:01:18
Este método de aquí 00:01:20
El método bicicleta, pues 00:01:21
Puede hacer el método bicicleta 00:01:23
¿Por qué me marca esto? 00:01:25
Ah, porque tiene que devolver un entero, entonces 00:01:27
Return 00:01:29
7, ya está 00:01:30
Return 00:01:32
Ya está, he hecho un método 00:01:33
¿Vale? 00:01:36
¿Qué método hace esto? Pues un método inútil 00:01:37
Yo lo llamo, se llama bicicleta 00:01:39
Pues me rende 7, ¿vale? 00:01:41
Siempre, porque esto solo devuelve 7 00:01:43
Entonces es un método inútil 00:01:46
Pero esto sería un método 00:01:47
Un constructor no tiene esto 00:01:48
¿Por qué no tiene esto? 00:01:51
Sabéis que cuando yo hago un método 00:01:58
Un método es como 00:01:59
Por ahora yo pongo siempre public 00:02:02
Static a veces 00:02:03
Esto entenderemos dentro de un rato 00:02:06
Para que sirve 00:02:10
Luego un tipo retorno 00:02:11
Nombre 00:02:14
Parámetros 00:02:17
Esto es como declaro un método 00:02:20
Este de aquí 00:02:23
Tiene dos particularidades 00:02:26
Primero que su nombre es igual a la clase 00:02:32
Y segundo que no tiene 00:02:34
Tipo return 00:02:37
¿Por qué no tiene tipo return? 00:02:38
¿Eh? 00:02:45
Porque un constructor 00:02:48
No tiene tipo 00:02:49
No tiene tipo de devolución 00:02:52
Porque ¿Qué devuelve un constructor? 00:02:54
El objeto de tipo bicicleta 00:03:00
En un cierto sentido 00:03:02
Entonces no me interesa definirle 00:03:03
¿Qué me va a devolver? 00:03:05
Porque lo que va a hacer esto es construir un objeto de tipo bicicleta 00:03:06
Es eso lo que crea y que me devuelve 00:03:09
¿Sí? 00:03:12
Entonces, ¿cuándo yo creo una bicicleta, qué necesito saber de la bicicleta? 00:03:14
Ok. 00:03:20
Bolean tipo. 00:03:24
¿Vale? 00:03:31
El bolean tipo me dice si es de carretera o no. 00:03:32
En concreto, si es falso, es de montaña. 00:03:36
Si es truco, es de carretera. 00:03:40
Justo. 00:03:45
Vale. 00:03:46
¿Qué más necesito saber? 00:03:47
Lo necesito saber 00:03:48
Cuando yo compro la bicicleta 00:04:01
Cuando yo creo la bicicleta 00:04:02
Quiero que vaya ya a 100 km por hora 00:04:03
Pregunto 00:04:05
Cuando yo creo una nueva bicicleta 00:04:06
Ya ha hecho 600 km 00:04:09
Pregunto 00:04:11
El ID 00:04:12
String ID 00:04:15
¿Vale? 00:04:18
Y con esto para mí es suficiente 00:04:21
¿Por qué? 00:04:22
Vamos a verlo 00:04:25
Y ahora tengo que inicializar estos 4 valores 00:04:26
¿Cuál es la velocidad cuando creo? 00:04:29
Por ejemplo, ¿eh? 00:04:36
¿Es de carretera? 00:04:41
¿Cuánto vale es de carretera? 00:04:43
¿Eh? 00:04:55
True 00:04:56
Entonces, ¿puedo crear una bicicleta que no sea de carretera? 00:04:57
Porque si mi constructor 00:05:03
Cada vez que yo lo llamo 00:05:05
Me dice que es de carretera, es true 00:05:07
Pues no lo puedo cambiar 00:05:09
Si yo lo pongo así 00:05:10
Es lo mismo, pero al revés 00:05:25
Es decir, no puedo crear una bicicleta 00:05:27
Que sea de carretera 00:05:30
Porque todas las bicicletas que creo 00:05:32
Son siempre falsas 00:05:34
¿Para qué me sirve esto? 00:05:35
No sé por qué lo he puesto ahí 00:05:45
¿Sí? 00:05:46
¿Entendéis lo que estoy haciendo? 00:05:49
Cuando yo creeré una nueva bicicleta 00:05:51
Le diré aquí true 00:05:53
O aquí false 00:05:55
Y si le digo true, estoy creando una de carretera 00:05:56
Y si le digo false, estoy creando una que no es de carretera 00:06:00
O sea que este parámetro de aquí es 00:06:03
Este atributo de aquí es parametrizado con este parámetro del constructor 00:06:06
¿Sí? 00:06:11
¿Distancia recorrida? 00:06:15
Cero 00:06:17
Al principio, cuando la creo, no ha recorrido nada 00:06:23
¿Y su identificador? 00:06:26
Se lo he pasado como parámetro, ¿no? 00:06:32
Para que cuando yo cree una nueva 00:06:35
¿Cómo se dice? 00:06:36
Cuando yo crea una nueva bicicleta 00:06:40
Le diré cómo se llama 00:06:42
Así luego la puedo reconocer 00:06:44
¿Sí? 00:06:47
O sea que cuando creo una nueva bicicleta 00:06:48
Al crear una nueva bicicleta 00:06:49
Yo tengo que dar dos parámetros 00:06:51
El parámetro de qué tipo es 00:06:52
Si es de carretera o no 00:06:54
Y su identificador 00:06:56
Los otros dos 00:06:58
Siempre son cero 00:07:00
Al crear una bicicleta 00:07:01
¿Veis algo raro aquí? 00:07:05
Espera, hago zoom 00:07:08
Los colorines 00:07:09
¿Vale? 00:07:21
Si os fijáis 00:07:22
Hay dos colorines 00:07:23
Hay un pseudo marrón 00:07:25
Cosa rara, no es negro 00:07:27
¿Por qué negro es esto? 00:07:30
Es algo raro 00:07:30
Y azul 00:07:31
¿Vale? 00:07:32
Fijaos que cuando yo estoy trabajando con los atributos 00:07:34
Los atributos salen en azul 00:07:39
Sin embargo, el otro tipo, este de aquí 00:07:41
Que son variables locales 00:07:44
¿Vale? Son variables locales a este bloque de aquí 00:07:49
En particular, en este caso son tipos 00:07:51
Pero si creara otra int gatito es igual a 7 00:07:54
Veis que también gatito me lo da como variable local 00:07:59
¿Vale? Me lo pone en este marroncito raro 00:08:03
¿Sí? 00:08:05
Entonces, las variables que valen aquí dentro 00:08:07
En este bloque de aquí 00:08:10
Pues me lo pone de otro color 00:08:11
Entonces, estamos de acuerdo que aquí 00:08:13
Hay un problema 00:08:16
Porque me está poniendo 00:08:17
Dentro de id 00:08:21
O sea, perdón 00:08:22
Está pillando el valor de id 00:08:25
El que me han pasado y lo guarda 00:08:26
Dentro de esta variable aquí 00:08:28
Y yo en vez de lo quiero guardar 00:08:31
Dentro de esta variable aquí 00:08:33
¿Por qué antes 00:08:35
No me ha dado el problema? 00:08:38
Porque se llamaban de forma distinta 00:08:40
Y hasta ahora es de carretera 00:08:44
Existe solo una vez 00:08:47
Esto 00:08:48
Entonces él es suficientemente inteligente para decir 00:08:49
Vale, te estabas refiriendo a este de aquí 00:08:51
Pero ahora hay dos id 00:08:53
Este id de aquí 00:08:56
Y este id de aquí 00:08:57
Hay dos variables distintas 00:08:58
Solo que esta es local 00:09:01
Vale solo aquí dentro 00:09:02
Es un parámetro que valdrá dentro de este bloque aquí 00:09:04
Mientras esta es mi atributo 00:09:08
Ahora, como estoy aquí dentro 00:09:09
Cuando yo uso id 00:09:14
Él hace referencia a la más cercana a él 00:09:15
Que es esta 00:09:19
Es local, es aquí dentro 00:09:19
Y no veo esta de aquí 00:09:22
Entonces, para poder ver esta de aquí 00:09:24
Tengo dos opciones 00:09:28
La primera es 00:09:30
Esto 00:09:32
¡Voilá! 00:09:36
He cambiado el nombre de la variable interna 00:09:41
Y ahora me reconoce que esta id que ya no existe como variable local 00:09:44
Pues es esta id de aquí 00:09:50
¿Justo? 00:09:52
¿Sí? 00:09:54
Ahora, el problema de estas cosas de aquí 00:09:55
Es que me fuerza a encontrar nombres distintos por cada uno de estos 00:09:56
¿Vale? 00:10:03
Y luego tengo que saber yo cuando lo voy a leer 00:10:04
Que nombre y id son la misma cosa 00:10:07
Lo que no es guay 00:10:09
¿Vale? 00:10:13
En los constructores 00:10:14
Y en otro lado 00:10:16
Normalmente si tengo que hacer una cosa así 00:10:17
Que son lo mismo 00:10:19
Lo que voy a hacer es llamarlo de la misma forma 00:10:20
Porque es la misma cosa 00:10:23
O sea, cuando yo voy a poner esto 00:10:27
En realidad estoy poniendo esto 00:10:30
¿Sí? 00:10:33
Solo que en el constructor estoy construyendo una nueva bicicleta 00:10:35
Y le estoy diciendo que esta nueva bicicleta es de carrera 00:10:38
Tiene que valer true, false o lo que sea 00:10:41
Pero me causa este problema de aquí 00:10:42
Que ahora aquí dentro tengo una dualidad 00:10:47
Entre lo que es la variable local y la variable atributo 00:10:53
¿Cómo puedo referirme a esta existiendo esta? 00:11:00
Con una palabra reservada 00:11:08
This 00:11:10
Fijaos que ahora es azulito 00:11:11
¿Qué es este this? 00:11:16
This es este objeto 00:11:32
This es esta bicicleta 00:11:34
Tú estás creándolo en la bicicleta 00:11:38
Tienes aquí el objeto, ¿vale? 00:11:39
Y le estás poniendo que su velocidad es cero 00:11:41
Luego estás pillando una variable por algún lado 00:11:43
Que se llama este carretera 00:11:46
Esta de aquí que me están pasando 00:11:48
Y su valor, sea cual sea su valor 00:11:49
Cuando me llamen a este constructor 00:11:52
Lo quiero poner dentro 00:11:53
Es de carretera de this object 00:11:55
Este objeto 00:11:58
¿Vale? 00:11:59
Entonces cuando uso el this punto 00:12:01
Me estoy refiriendo a 00:12:03
Esto 00:12:05
¿Se entiende? 00:12:07
Entonces si tengo características 00:12:16
De este estilo que se llaman igual 00:12:19
Entonces no podría ponerlo de esta forma 00:12:20
Para si quiero utilizar 00:12:23
Esta variable la uso directamente 00:12:25
Si quiero utilizar 00:12:27
El atributo le pongo 00:12:29
Dis.delante 00:12:31
Podría poner 00:12:32
Dis.velocidad 00:12:35
Sí, tranquilamente 00:12:36
Ningún problema 00:12:38
Lo único es que no me hace falta porque 00:12:39
Velocidad hay una sola 00:12:42
Vale 00:12:43
Esto no me pone los colorines 00:12:51
Porque no lo sé 00:12:54
Vale, entonces este de aquí 00:12:56
Es mi constructor de bicicletas 00:13:01
Vale 00:13:04
Vamos a construir una bicicleta 00:13:06
Estoy dentro del main 00:13:07
Aquí empieza mi programa 00:13:11
Quiero construir una bicicleta 00:13:13
¿Cómo se construye una bicicleta? 00:13:15
Pues llamando a su constructor 00:13:17
¿Cómo llamo a mi constructor? 00:13:19
Con una new 00:13:23
Como cuando hacía new 00:13:24
Scanner 00:13:30
Y al scanner le tenía que pasar un 00:13:31
¿Cómo se llama esto? 00:13:36
Un parámetro 00:13:38
Que era system.in 00:13:39
¿Qué es esta cosa aquí? No lo sé 00:13:41
Todavía 00:13:43
En realidad lo sé 00:13:46
Es un input stream 00:13:47
¿Pero qué es un input stream? No lo sé 00:13:49
Ya lo veréis 00:13:54
Pues aquí es la misma cosa 00:13:55
Si para crear un nuevo scanner 00:13:57
Tenía que hacer new scanner 00:14:00
Para crear una nueva bicicleta tendría que hacer un new 00:14:01
Bicicleta 00:14:04
¿Vale? 00:14:07
Ahora, pero new bicicleta 00:14:13
Se enfada porque me dice 00:14:15
El constructor bicicleta 00:14:16
Sin nada 00:14:20
No está definido 00:14:21
Is undefined 00:14:23
Porque el único que yo encuentro 00:14:25
Que tiene argumentos 00:14:28
Que corresponden con 00:14:31
Bicicleta boolean string 00:14:33
Ese es el que he hecho yo 00:14:34
Mi constructor necesita un booleano o un string 00:14:36
Pues le tengo que poner un booleano 00:14:39
O un string 00:14:41
Como quiero que sea 00:14:42
De carretera o de montaña 00:14:43
Montaña 00:14:47
Vale 00:14:49
El primero booleano 00:14:53
Me dice si es 00:14:55
De carretera o de montaña 00:14:57
Justo 00:15:00
El segundo 00:15:01
Tiene que ser el nombre 00:15:03
¿Cómo lo llamo? 00:15:05
Artax 00:15:07
Este señor de aquí 00:15:08
Me crea un objeto 00:15:15
¿Si? 00:15:18
Crea un nuevo objeto 00:15:23
Utilizando el constructor bicicleta 00:15:24
Que pilla un atributo 00:15:28
Un booleano 00:15:29
Y un string 00:15:31
Este booleano 00:15:32
Se hará una bind 00:15:34
Se ligará 00:15:37
Se atará 00:15:39
A esta variable 00:15:41
De aquí 00:15:43
Por lo tanto cuando luego 00:15:44
Llegará aquí en este objeto 00:15:49
Es de carrera 00:15:51
Pondrá 00:15:52
False 00:15:53
Esta id de aquí 00:15:58
Se juntará 00:16:02
Con este 00:16:04
Valor de aquí 00:16:06
Y por lo tanto cuando llega aquí 00:16:07
En this.id 00:16:10
En el atributo id de este objeto 00:16:11
Pondrá artax 00:16:14
Si o no 00:16:15
He creado el objeto 00:16:19
Ahora 00:16:22
Que pasa con este objeto 00:16:23
Que se pierde en la nada 00:16:24
Llega un señor que conoceremos en un futuro 00:16:31
Que se llama el garbage collector 00:16:34
El recolector de basura 00:16:36
Y lo tira 00:16:37
¿Por qué? 00:16:38
Porque no tengo nada 00:16:41
Que me permita 00:16:42
Llegar a este objeto 00:16:44
Yo lo he creado 00:16:46
Pero no he hecho nada 00:16:47
Para que pueda manejar este objeto 00:16:50
Un handler 00:16:52
Lo que se llama 00:16:54
Un mango 00:16:55
Un manipulador 00:16:56
Un puntero 00:16:59
Necesito algo 00:17:01
Que me permita acceder a este objeto 00:17:04
¿Cómo puedo hacerlo? 00:17:06
¿Qué se os ocurre? 00:17:08
¿Os acordáis cuando hacía New Scanner? 00:17:09
De System.in 00:17:13
Esto crea el objeto 00:17:15
Pero ¿qué hacía yo con esto? 00:17:19
¿Era así el comando? 00:17:25
Claro, porque necesitabas un igual 00:17:27
¿Qué hacía yo? 00:17:28
Este señor 00:17:34
Lo que me hace 00:17:35
Es crear un puntero 00:17:37
Un handler 00:17:40
Para luego poder trabajar con este objeto de aquí 00:17:41
De hecho, a partir de ahora 00:17:44
Yo no uso nunca esta cosa de aquí 00:17:46
Uso siempre scan 00:17:48
Haciendo scan.nextint 00:17:50
Estoy llamando 00:17:53
Este método de aquí 00:17:59
Que no sé qué hace, pero está aquí un método 00:18:01
Sobre este objeto de aquí 00:18:03
¿Cuál es este objeto? 00:18:06
El que has creado aquí 00:18:07
¿Se entiende? 00:18:07
Pues entonces, ¿para mi bicicleta qué tendré que hacer? 00:18:13
Ya está, ya he creado mi bicicleta 00:18:15
¿Sí? He creado mi bicicleta 00:18:34
Tiene una referencia dentro de mi programa 00:18:39
Que se llama bicuno 00:18:43
A partir de ahora 00:18:44
Puedo utilizar bicuno 00:18:46
Como por ejemplo puedo decir 00:18:48
System.out.println 00:18:49
¿Cómo escribo 00:18:53
Mi bicicleta se llama y su nombre? 00:18:54
Mi bici se llama 00:18:59
¿Cómo se llama mi bicicleta? 00:19:01
¿Cómo me referencia al objeto que he creado? 00:19:10
Vicuno 00:19:14
Y este es el objeto 00:19:15
De este objeto tengo cuatro opciones 00:19:19
¿Cuál quiero de estos? 00:19:22
¿Cómo acedo desde aquí a ID? 00:19:26
Vete al objeto 00:19:37
Vicuno 00:19:38
Y desde allí accedes 00:19:39
A su parámetro, a su atributo ID 00:19:42
Vamos a ver 00:19:44
Nuestro fantástico programa 00:19:51
Esputado 00:19:52
Ah, por escáner 00:19:59
Oye, la escáner 00:20:01
No te necesito por ahora 00:20:04
Vamos a crear otra bici 00:20:07
Bicicleta 00:20:16
Pic2 00:20:22
¿Cómo creo otra bici? 00:20:24
New 00:20:28
Bicicleta 00:20:29
¿Qué pongo? 00:20:32
Oh, ya he tocado eso 00:20:43
¿Qué me pondrá aquí ahora? 00:20:55
Mi bici se llama 00:21:18
Artax 00:21:19
Tu bici se llama 00:21:21
Falco 00:21:24
Fijaos 00:21:27
El atributo se llama id 00:21:35
Es el mismo atributo 00:21:37
Porque un objeto tiene estos atributos 00:21:39
Cualquier bicicleta tendrá atributo id 00:21:42
¿Sí? 00:21:45
Pero si yo pido el atributo id de big1 00:21:46
Entonces será del objeto este de aquí 00:21:52
Y entonces es alta 00:21:55
Si yo pido el id de big2 00:21:56
Me pedirá de este objeto de aquí 00:22:01
Es la misma clase que siempre tiene estos cuatro parámetros 00:22:04
Estos cuatro atributos 00:22:09
Pero de dos instancias distintas 00:22:10
Una instancia es esta y una instancia es esta 00:22:13
Dos objetos distintos 00:22:16
¿Dudas? 00:22:17
Sí 00:22:27
Como pregunto si es de montaña 00:22:28
O de carretera 00:22:32
Quiero saber si Bicuno es de montaña 00:22:34
¿Cómo? 00:22:39
¿Cómo? 00:22:47
Bicuno, por ejemplo 00:22:49
¿Bicuno qué? 00:22:54
Punto 00:22:57
Es de carretera 00:22:58
Igual o igual a true, por ejemplo 00:23:02
Hace falta 00:23:07
No, porque ya es un boolean 00:23:09
Si es de carretera 00:23:12
Escribiré 00:23:15
Iré con 00:23:17
Vicuno.id 00:23:20
Vicuno.id 00:23:23
Por carretera 00:23:25
¿Sí? 00:23:31
Elche 00:23:38
Ah bueno, espera que aquí me falta 00:23:42
Un system.8.ptl 00:23:46
Ahora 00:23:48
Si no, por montañas 00:23:53
Y hacemos lo mismo 00:24:06
Con la siguiente 00:24:19
Pero con VIX2 00:24:20
A ver, ¿qué hace esto? 00:24:22
Mi bici se llama Artax 00:24:30
Iré con Artax por montañas 00:24:31
Tu bici se llama Falkor 00:24:33
Iré 00:24:36
Que se la robo 00:24:36
Con Falkor por carretera 00:24:38
Correcto 00:24:40
He hecho al revés 00:24:43
Artaxa era de montaña 00:24:45
Por lo tanto está bien 00:24:50
Veis que estoy utilizando 00:24:51
En la primera parte 00:24:58
Iras 00:24:59
Iras también 00:25:04
La primera parte lo estoy haciendo 00:25:05
Estoy pidiendo toda la información 00:25:08
De la primera bicicleta que he creado 00:25:10
Y en la segunda, toda la información de la segunda 00:25:13
Bicicleta que he creado 00:25:16
Aquí tengo las dos bicicletas que he creado 00:25:19
Y luego voy preguntando cosas 00:25:26
Si pongo Bic 1 y algo 00:25:29
Estoy preguntando de Bic 1 00:25:32
Si pongo Bic 2 y algo 00:25:34
Pues estoy preguntando de Bic 2 00:25:36
Dudas 00:25:39
Vamos a hacerle hacer algo 00:25:41
Comportamiento 00:25:47
Entonces 00:25:49
Esta es mi clase 00:25:53
Bicicleta 00:25:56
Tiene un constructor que se llama bicicleta 00:25:57
Que pilla dos parámetros 00:25:59
¿Estamos a acuerdo hasta aquí? 00:26:01
Vamos a hacerle hacer algo 00:26:03
Un método 00:26:05
Public 00:26:05
Nope 00:26:08
Cortaos, static 00:26:14
Lo utilizamos antes 00:26:17
Ahora cuando usamos objetos 00:26:19
Static no lo ponemos 00:26:21
¿Vale? Para entender la diferencia entre el estático y el no 00:26:22
Dejámoslo un tiempo por ahora 00:26:25
¿Vale? Pero ahora cuando hacemos 00:26:27
Métodos que trabajan sobre 00:26:28
Objetos, no va el estático 00:26:31
¿Vale? 00:26:33
Entonces, queremos que devuelva algo 00:26:35
Hacemos el método acelerar, por ejemplo 00:26:37
Para ir más rápido 00:26:38
¿Quieres decir que lo que queramos hacer hoy sería acelerar? 00:26:40
¿Quiero que luego me des la velocidad? 00:26:45
O sea, cuando acelero me dices la velocidad actual 00:26:47
¿O no? 00:26:49
Podría hacer dos versiones, ¿vale? 00:26:50
Una así 00:26:54
Dis.velocidad 00:26:54
Más, más 00:27:04
Cada vez que llamo acelera 00:27:05
Aumenta de uno la velocidad 00:27:12
Y podría tener otro método 00:27:13
En que le paso 00:27:21
De cuanto 00:27:25
Aceleración 00:27:25
¿Dónde ves 2C tú? 00:27:28
Diferencia 00:27:48
Si yo llamo acelera 00:27:49
Aumenta de 1 00:27:50
Si llamo acelera de 5 00:27:51
Me aumenta de 5 00:27:54
De golpe 00:27:55
¿Lo veis? 00:27:56
Habría podido hacer una cosa distinta 00:28:05
Que es 00:28:07
Por ejemplo 00:28:08
Resultado es igual 00:28:10
Que hace esto 00:28:18
Lo mismo que antes 00:28:40
Aumenta de 1 velocidad 00:28:42
Pero además 00:28:45
Cuando ha hecho la operación 00:28:47
El valor nuevo de la velocidad 00:28:48
Me lo devuelve 00:28:51
Entonces cuando ya me acelera 00:28:52
Puedo saber a qué velocidad estoy yendo 00:28:55
Me interesa 00:28:56
Relativamente 00:29:02
Dejámoslos así que más sencillo 00:29:04
Por ahora 00:29:07
¿Vale? 00:29:08
Y vamos a usarla 00:29:10
¿Cómo uso 00:29:11
Estas cosas? Por ejemplo, aquí he creado 00:29:15
La bicicleta 1 00:29:18
¿Cómo acelero con la bicicleta 1? 00:29:20
Diz 00:29:24
Vicuno 00:29:33
Punto 00:29:38
Acelera 00:29:39
Voy a acelerar tres veces 00:29:42
System. 00:29:51
Punto 00:29:56
Vicuno 00:29:57
Punto ID 00:30:09
Más 00:30:18
Como veo la velocidad 00:30:20
Vic1.velocidad 00:30:21
Kilómetros hora 00:30:31
¿Qué me espero que me ponga aquí? 00:30:38
Porque he acelerado 3 veces 00:30:48
Vamos a verlo 00:30:51
Y si ahora pregunto lo mismo 00:30:53
Para Vic2 00:31:02
¿Qué me pone? 00:31:04
Son dos objetos distintos 00:31:12
Mira, misma clase 00:31:26
Tienen los mismos atributos 00:31:27
Pueden hacer las mismas cosas 00:31:29
Pero en el objeto 1 00:31:30
La bici 1, en Artax 00:31:33
He acelerado 3 veces 00:31:35
Y en Falkor todavía no he acelerado 00:31:37
Por lo tanto su velocidad se ha quedado a 0 00:31:40
Son dos instancias distintas 00:31:41
Hacen las mismas cosas 00:31:44
Tienen los mismos parámetros 00:31:45
Pero son dos instancias distintas 00:31:47
Ahora voy a acelerar Falkor 00:31:49
¿Cuánto lo hacemos acelerar Falkor? 00:31:58
¿Cómo hago para que Falkor 00:32:02
Vaya 80 km por hora? 00:32:09
¿Cómo? 00:32:16
Big dos 00:32:22
Porque voy a trabajar sobre el segundo objeto 00:32:23
Punto 00:32:27
Aquí tengo los métodos que quiero 00:32:28
Tengo, incluye, fijaos que los métodos 00:32:30
Nuevo que he creado yo 00:32:33
Ahora aparecen aquí 00:32:34
Entonces por ejemplo voy a utilizar esto 00:32:35
Y ahora me dice 00:32:40
¿Qué valor le quieres poner aquí? 00:32:44
Le tienes que poner un int 00:32:47
80 hemos dicho 00:32:48
Y si ahora vuelvo a preguntar 00:32:49
A qué velocidad va 00:32:54
Falkor 00:32:56
Antes de llamar la aceleración 00:32:58
Va a 0 km por hora 00:33:11
Después de la deceleración 00:33:12
Va a 80 00:33:15
¿Sí? 00:33:16
Vamos a frenar 00:33:22
Public 00:33:27
Void 00:33:33
Frena 00:33:34
¿Qué hace frena? 00:33:35
X punto velocidad 00:33:47
Para hacer 00:33:48
Lo que queréis hacer con menos menos 00:33:51
Os gusta así 00:33:59
Así razonamos 00:34:02
Esto sería guay 00:34:05
Funciona 00:34:07
Pero no se puede usar sin cero 00:34:08
Si ya está en la velocidad 00:34:11
Cuidado con lo que hacéis vosotros 00:34:12
¿Vale? 00:34:15
Porque si aquí la velocidad es cero y yo freno 00:34:15
Pues esta bicicleta no parte hacia atrás a velocidad menos uno 00:34:18
Entonces, ¿cómo debería ser frena si lo quiero implementar casi? 00:34:23
¿Sí? 00:34:44
Cuando llamo frena, si la velocidad es positiva, reduzco 00:34:45
Si la velocidad ya es cero, no reduzco 00:34:49
¿Dudas? 00:35:00
Entonces, ahora freno 00:35:01
¿Cómo freno con bicuno? 00:35:07
¿Cómo se frena con ARTAX? 00:35:10
Junto frena 00:35:23
Y si ahora pregunto otra vez 00:35:25
¿A cuánto va ARTAX? ¿Qué me debería dar? 00:35:29
Porque hemos dicho que reduce una vez 00:35:37
Y si yo ahora freno 00:35:41
5 veces o 4 veces 00:35:42
¿Cuánto me debería dar? 00:35:47
No va en negativo 00:35:54
Ahora tengo dos objetos 00:35:57
Estoy construyendo dos objetos distintos 00:36:06
Y luego se pueden portar 00:36:09
Y pueden hacer cosas distintamente 00:36:11
Por separado 00:36:13
¿Dudas? 00:36:14
Idioma/s:
es
Autor/es:
Stefano Chiesa
Subido por:
Stefano C.
Licencia:
Reconocimiento - No comercial
Visualizaciones:
16
Fecha:
21 de noviembre de 2022 - 14:01
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
36′ 31″
Relación de aspecto:
1.78:1
Resolución:
1280x720 píxeles
Tamaño:
165.54 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid