Saltar navegación

Java básico 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 26 de septiembre de 2024 por Stefano C.

22 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, voy a grabar la clase de hoy. Entonces, si habláis, me dais consentimiento para que grabe vuestra voz. 00:00:00
Entonces, hasta ayer hemos visto algo de variables, hemos hecho algunos ejemplos. 00:00:08
Vamos a ver ahora algunas cosillas que podemos utilizar para hacer nuestros programas un poquito más interesantes. 00:00:13
Porque con eso de las variables, las variables son la base y son súper importantes y son fundamentales, pero con solo las variables no hacemos nada. 00:00:19
Tenemos que tener algo para poder manipular un poco las variables y hacer algo con ellas 00:00:28
Porque si no, y por ahora tenemos una cosa sola, dos 00:00:34
O sea, el más, que es o suma aritmética o concatenación de string 00:00:37
Vamos a añadir algo más, ¿vale? 00:00:44
Tenemos, por ejemplo, operadores aritméticos que probablemente ya conocéis 00:00:46
El más, que es la suma, el menos, que es la resta, el por, ¿vale? 00:00:51
La multiplicación, que se hace con un asterisco, y la división, que se hace con una barra. 00:00:57
Y lo que no conocéis, probablemente, es el módulo. 00:01:02
Este es un operador, que existe en casi todos los lenguajes, que lo que devuelve es el resto de la división. 00:01:06
Si esto hace la división, el barra, el módulo devuelve el resto de la división. 00:01:15
Entonces, si yo hago 10 módulo 3, el resultado es 1, ¿sí? 00:01:22
Y con esto, efectivamente, el ejercicio de los impares, pues se podía solucionar con esta cosilla de aquí, ¿sí? 00:01:32
Tened en cuenta también que todos estos operadores van por tipos, 00:01:41
y si yo hago 5 dividido 2, el resultado es 2. 00:01:46
porque 5 es un int 00:01:55
2 es un int 00:01:58
y dint dividido int 00:02:00
dará un int 00:02:03
entonces no me dará nunca 00:02:05
2,5 00:02:07
me dará la parte entera 00:02:07
de eso, truncada 00:02:10
no redondeada 00:02:12
¿si? entonces si yo hiciera 00:02:14
10 dividido 3 00:02:17
¿cuánto me da? 00:02:18
Y 10 módulo 1, módulo 3, me da 1 00:02:23
Entonces con estas dos cosas puedo saber, ¿no? 00:02:27
Es, me daría 3 con resto de 1 00:02:31
¿Sí? 00:02:34
Vale 00:02:37
Ten en cuenta que si quiero en vez de hacer 5 dividido 2 y que me dé 2,5, ¿cómo lo hago? 00:02:38
Todos 00:02:48
Con que haya 1, suficiente 00:02:48
Si yo pongo 5f dividido 2, como es un float dividido un int, el resultado será un float. 00:02:52
Entonces me dará 2,5. 00:03:00
Cuidado a no guardarlo en una variable int. 00:03:02
¿Queréis ejemplitos? 00:03:06
Entonces, yo estoy aquí. 00:03:10
Quito esto que es un error. 00:03:14
Vale, entonces, imaginémonos que int x es igual a 5 dividido 2, ¿vale? x ya la he creado, por algún lado, int operación, ¿vale? 00:03:15
Y ahora la imprimo, siso operación, ¿vale? La ejecuto y veis que me da 2, porque este señor de aquí es un int, este señor es un int y el resultado es un int. 00:03:32
Y ahora digo, no, yo quiero que esto sea un double, entonces o el 5 o el 2 lo transformo en un double o en un float o algo por el estilo. 00:03:50
¿Cómo lo hago? Pues por ejemplo así, ¿vale? 5 dividido 2.0, hemos dicho que cuando pongo el punto algo, por ejemplo 2.0, en automático 2.0 me vale, ¿qué tipo tiene? 00:03:59
Double, ¿vale? Este es un double. Entonces, int dividido double, el resultado es un double. 00:04:16
Y se enfada, ¿por qué se enfada? 00:04:23
Me está diciendo 00:04:30
Type mismatch 00:04:31
O sea, los tipos no corresponden 00:04:33
No puedo convertir desde double 00:04:35
To int 00:04:38
Este es un double, no lo puedo convertir para meter en un int 00:04:38
Por lo tanto se enfada 00:04:42
Entonces debería hacer 00:04:44
Doble 00:04:45
Ahora está feliz 00:04:47
Y cuando yo le doy aquí 00:04:52
El resultado es 2,5 00:04:55
Sí 00:04:57
pero 00:05:04
¿por qué él hace esta operación? 00:05:06
¿y el resultado de esta operación cuánto es? 00:05:17
no, no es double, porque es int dividido int 00:05:21
entonces me sale 2 00:05:23
ahora este 2 00:05:26
lo guardo en un double 00:05:27
y me sale 2.0 00:05:29
no 2.5 00:05:30
entonces cuidado con estas cosas 00:05:32
si yo tengo que fijarme 00:05:34
en dos cosas 00:05:38
donde lo guardo 00:05:39
Que es a la izquierda del igual 00:05:41
Pero también en el tipo 00:05:43
De la expresión que pongo a la derecha 00:05:45
Si yo quiero que esto sea considerado 00:05:47
Un double, uno de estos dos 00:05:49
Tiene que ser double 00:05:51
Si no, será int dividido int 00:05:52
Y me dará int 00:05:54
Luego, ¿por qué aquí no se enfada? 00:05:55
Porque un int dentro de un double 00:05:59
Cabe perfectamente 00:06:01
Es lo que se llama un cast implícito 00:06:02
Hace un cambio de tipo 00:06:05
El solo en automático 00:06:09
¿Por qué? Porque cualquier int se puede expresar como double 00:06:10
Es al revés que no se puede 00:06:14
Cualquier double no se puede expresar como int 00:06:16
Los ints son menos que los doubles 00:06:18
¿Sí? 00:06:21
Entonces, ¿qué puedo hacer? 00:06:23
Pues, por ejemplo, así 00:06:24
Digo que este es 5, pero considerarlo como double 00:06:25
Entonces, 2,5 00:06:30
Le podría decir esto 00:06:37
Píllame 5 como float 00:06:39
Lo divide por dos 00:06:43
El resultado será un float 00:06:44
Que ocupa 4 bytes 00:06:46
Y luego este float me lo guardas en un double 00:06:49
¿Vale? Sí, porque cualquier float 00:06:51
Cabe en un double 00:06:53
El double es más preciso que un float 00:06:54
Dame un float cualquiera y te lo puedo escribir como double 00:06:57
Por lo tanto él 00:07:00
Es contento 00:07:01
Al revés no 00:07:05
No lo sé 00:07:05
Pero si lo hay 00:07:13
No es un tipo primitivo 00:07:14
Es una 00:07:16
clase pensada 00:07:17
para manejar números más precisos 00:07:21
que el double, dudas 00:07:23
es que 00:07:27
esta cosa de aquí se tiene en cuenta 00:07:39
después 00:07:43
antes se resuelve la operación 00:07:44
que está a la derecha y cuando ya 00:07:47
tienes un valor final 00:07:48
que es la evaluación de esto 00:07:50
a este punto decides de guardarlo 00:07:52
si tú lo dejas aquí, tú le estás diciendo 00:07:54
que quieres un double, pero en realidad 00:07:56
la operación que estás haciendo es entre int 00:07:58
Entonces int dividido int 00:08:00
El resultado es un int 00:08:04
Variables como 00:08:05
Si una de las dos variables es double 00:08:12
Entonces estarás haciendo double dividido int 00:08:16
Y es un double el resultado 00:08:19
Esto ya 2.5 00:08:20
Porque esto es double, esto es int 00:08:32
Y double dividido int es double 00:08:34
Con que uno de los dos operadores sea double 00:08:36
El resultado va a ser double 00:08:39
¿Cómo? 00:08:40
A lo mejor tú no quieres 00:08:46
Ponerlo en una variable, quieres escribirlo 00:08:52
Directamente en pantalla 00:08:54
Si yo hago esto, esto me lo puedo saltar 00:08:55
Y el resultado 00:09:01
Será siempre un double, porque esta cosa 00:09:05
De aquí es un double 00:09:07
¿Sí? ¿Dudas? 00:09:08
Vale 00:09:13
Más 00:09:13
Y el módulo, si queréis 00:09:18
Veamos el módulo 00:09:22
¿Cuánto sería? 00:09:23
Que así vemos las dos cosas 00:09:28
Si yo hago op1 00:09:29
Módulo 2 00:09:32
¿Cuánto me da? 00:09:36
1 como double 00:09:41
Porque este es un double 00:09:50
¿Vale? 00:09:51
Y si en vez de esto hiciera 00:09:53
Módulo 7 00:10:00
¿Qué me da? 00:10:01
3 como int 00:10:06
Porque este es int 00:10:13
Y este es int 00:10:15
Aquí no hay decimales 00:10:16
No estoy usando la división, estoy usando el módulo 00:10:23
Es el resto de la división 00:10:26
10 dividido por 7 es 1 00:10:28
Con el resto de 3 00:10:31
Me da este 3 00:10:33
Entonces aquí 00:10:34
En el módulo la coma 00:10:37
No sale porque es el resto de la división 00:10:40
¿Dudas? 00:10:42
Vale 00:10:46
Entonces tenemos 00:10:46
Ya para jugar estos 5 operadores 00:10:48
¿Sí? 00:10:51
Y algo se puede hacer con estos 5 operadores 00:10:52
Ejercicios 00:10:56
A ver, me lo salto 00:10:59
Me salto los ejercicios porque así os doy salida básica, entrada básica 00:11:01
Y empezamos a hacer los ejercicios de verdad, ¿vale? 00:11:06
Entonces, aquí os pido dos ejercicios 00:11:08
De calcular la área del cuadrado y calcular la área del triángulo 00:11:10
¿Sí? 00:11:13
Luego los hacéis 00:11:15
Pero antes, dos cosas 00:11:16
Para un programa, si os acordáis 00:11:19
Había un algoritmo, un procedimiento, un proceso en el centro 00:11:22
Luego había entrada y salida 00:11:26
La idea es siempre esa 00:11:28
Pillo los datos, los machaco y saco el resultado 00:11:31
Ahora mismo, ¿cómo le damos nosotros la salida a los programas? 00:11:36
Con el System.Auto.Println 00:11:43
El System.Auto.Println recibe un string aquí 00:11:46
Si vosotros le ponéis un int 00:11:51
Él hace una conversión automática string 00:11:53
Pero lo que quiere aquí 00:11:55
Él es una cadena de caracteres 00:11:57
Y esas cadenas de caracteres te las imprime en pantalla 00:11:59
¿Sí? 00:12:01
Entonces 00:12:04
Si este punto es hola 00:12:05
Si tienes el nombre Lara 00:12:07
Y haces el nombre, escribe Lara 00:12:08
Nombre más otra cosa, nombre más cinco 00:12:11
Esto de aquí lo converte a un entero 00:12:13
Fijaos que también funciona 00:12:15
Si yo hago algo así 00:12:17
Op1 00:12:19
Esto en principio no le estoy dando un string 00:12:26
Le estoy dando 00:12:31
Un entero 00:12:34
Pero el por debajo 00:12:36
Es como si hiciera 00:12:38
Ah vale muy bien, así 00:12:39
Y eso porque 00:12:41
El System.out que es un 00:12:46
Un objeto de tipo print 00:12:49
Print algo 00:12:51
Print, print, print 00:12:52
No me acuerdo 00:12:55
Print writer 00:12:56
Tiene dentro 00:12:58
Métodos println 00:13:01
Que pueden aceptar un entero, un double 00:13:02
Un string, y todo lo que hacen 00:13:05
Es imprimirlo en pantalla 00:13:07
Ya está hecho, no lo tengo que hacer 00:13:08
Este es nuestro output básico 00:13:10
El output básico es cuando tengo un resultado 00:13:13
Y lo quiero hacer ver, pues lo imprimo 00:13:15
En pantalla y me lo escribo aquí en la consola 00:13:17
¿Si? 00:13:19
Vale 00:13:21
El procedimiento, hacer operaciones y cosas por estilo 00:13:21
Lo hemos dicho, lo hacemos con estos 00:13:25
Operadores de aquí que estaban ahí arriba 00:13:27
¿Qué nos falta? 00:13:29
Estos son los operadores para 00:13:34
Procesar los datos, ¿qué nos faltaría? 00:13:35
Exacto, la entrada 00:13:41
¿Cómo estamos dando ahora mismo la entrada? 00:13:42
Manualmente 00:13:47
¿Vale? Esto es una cosa fea 00:13:48
Porque 00:13:50
Requiere modificar 00:13:51
El código 00:13:54
Para poder cambiar 00:13:55
Las variables de entrada 00:13:58
Y esto no es un buen programa 00:14:01
Imaginaos que vosotros tenéis un programa que cada vez que tenéis que cambiar los datos iniciales 00:14:04
Tenéis que volver a compilar desde cero todo el programa 00:14:09
No, no funciona así 00:14:12
Yo voy a un programa que al arrancarlo me diga 00:14:14
Dame el lado del cuadrado 00:14:17
Yo le pongo 5 00:14:19
Y él me calcula el cuadrado del lado 5 00:14:21
Y luego arranco el mismo programa sin haberlo compilado 00:14:25
el mismo idéntico programa y me vuelve a decir 00:14:29
dame el lado del cuadrado, esta vez le pongo 7 00:14:32
y él me da la área del cuadrado 7 00:14:35
esto es una tontería 00:14:37
es algo sencillo, pero es 00:14:40
muy grande 00:14:44
porque estoy pasando de solucionar 00:14:46
un problema a solucionar una clase 00:14:50
de problemas, si yo le pongo 00:14:53
aquí 00:14:56
Int L es igual a 5 00:14:57
Int área es igual a L por L 00:15:01
Esta cosa de aquí, y la imprimo 00:15:10
Esta cosa de aquí está resolviendo el problema 00:15:13
Calcula la área del cuadrado del lado 5 00:15:16
Ese es mi problema 00:15:19
Si me han dado, calcula 00:15:22
Haz un programa que calcula la área del cuadrado 00:15:24
esta no es una solución 00:15:27
esto es un caso específico 00:15:29
vale solo para el cuadrado del lado 5 00:15:32
y los informáticos no funcionan así 00:15:35
no se soluciona un problema 00:15:41
se soluciona la clase de problemas relacionados 00:15:43
entonces necesito algo para que este numerito de aquí 00:15:48
no se lo pase a tiempo de compilación 00:15:52
En el código, cuando luego se compila 00:15:56
Sino a tiempo de ejecución 00:15:59
O sea, una vez ejecutado 00:16:01
Dame el valor 00:16:04
¿Y cómo se piden datos? 00:16:06
Os lo explico, luego hacemos la pausa 00:16:12
Pues la entrada básica que nosotros vamos a utilizar 00:16:14
Es esta, ¿vale? 00:16:18
Tenemos que poner unas palabras mágicas 00:16:20
Que no entenderemos hasta dentro de un rato 00:16:23
Y con estas palabras mágicas 00:16:25
ya podemos utilizar la lectura de teclado. 00:16:28
Puede ser. 00:16:41
Pero luego igualmente tienes que ir a buscar por algún lado el encoding. 00:16:43
O sea, esto te sacará las clases que posiblemente estará, 00:16:47
pero luego tienes que ir a buscarte por allí cómo aceptas el encoding 00:16:52
cada vez que escribes o lees o cosas por el estilo. 00:16:55
Entonces, por ahora no lo quiero usar. 00:16:57
¿Vale? 00:17:00
Entonces, estas son dos palabras mágicas que vosotros tenéis que aprender. 00:17:01
vale es arte arcana perdida nadie sabe qué quieren decir hasta al menos segundo trimestre vale y si 00:17:06
queréis leer de teclado pues tenéis que escribir las por algún lado donde vamos a escribir la 00:17:16
Primero esto, import java útil asterisco y se escribe aquí, antes del public class. 00:17:22
¿Sí? Aquí. Y luego, nosotros, porque somos así, en la primera línea del main escribimos que scanner.scan es igual a new scanner de system.in. 00:17:37
Vamos a mirar esta línea de código y ver si entendemos algo. 00:18:02
Primero, ¿qué estoy haciendo aquí? 00:18:18
Declarar una variable. 00:18:23
¿Cómo se llama la variable? 00:18:25
Scan. 00:18:27
¿De qué tipo es? 00:18:28
De tipo scanner. 00:18:32
¿Eh? 00:18:34
Pues es como cuando se hace un string. 00:18:36
¿Os acordáis de string? Es mayúscula. 00:18:38
Pues es lo mismo. 00:18:40
String algo... 00:18:44
No, no. 00:18:46
A es igual a... 00:18:46
Cuando hago esto, estoy usando tipos primitivos. 00:18:49
¿Esta es una palabra reservada como int o boolean o double? 00:18:52
¿Vale? 00:18:57
Esta es una clase 00:18:59
Este es una variable de tipo objeto 00:19:00
De objeto string 00:19:04
Pues estoy haciendo lo mismo 00:19:06
Todavía no sé qué es un objeto 00:19:08
Pero estoy haciendo lo mismo 00:19:10
Estoy creando un objeto scan 00:19:12
De tipo scanner 00:19:13
¿Qué es scanner? 00:19:15
Es una clase que alguien ha escrito y no me interesa 00:19:16
Y que está en un paquetito, en un package, que es el package java.util 00:19:21
Utilidades de Java 00:19:26
Que yo he importado aquí 00:19:28
Yo he importado desde fuera un paquete de clases que otros han escrito 00:19:30
Para utilizarlas directamente en mi programa 00:19:39
Porque para leer de teclado me debería hacer un programa grande así 00:19:42
Y no lo sé hacer 00:19:46
Y entonces lo que hago es importar un programa que alguien ya ha hecho 00:19:48
Y para utilizarlo, tengo que crear un objeto 00:19:53
¿Veis esta cosa aquí? 00:20:02
¿Lo veis que new es rojo? 00:20:05
¿Qué es rojo? 00:20:08
Una palabra reservada 00:20:12
Esta es la palabra reservada para crear objetos 00:20:14
Que nosotros todavía no sabemos qué son, lo utilizaremos más adelante 00:20:17
Pero estoy creando un nuevo objeto scanner 00:20:20
que está relacionado con qué. 00:20:23
¿Qué es esto? 00:20:26
¿De qué me suena esto? 00:20:28
Nosotros hemos usado System Out para la salida. 00:20:32
Y fijaos, usamos System In para la entrada. 00:20:38
Tiene sentido. 00:20:44
Esto es una conexión al teclado. 00:20:45
System In, por defecto, si no lo cambio, 00:20:49
Recibe los datos desde el teclado 00:20:52
¿Vale? 00:20:56
Entonces, esta cosa de aquí y esta cosa de aquí 00:20:57
No hacen nada, entre comillas 00:21:01
Simplemente me preparan a la posibilidad de leer de teclado 00:21:04
Si no están estas dos líneas, no puedo 00:21:08
Y ahora lo voy a usar 00:21:10
Voy a usar esta cosa de aquí 00:21:13
¿Cómo se hace? 00:21:15
Por ejemplo, si yo esto lo quiero leer de teclado 00:21:18
uso scan.nextint 00:21:21
esta cosa de aquí 00:21:26
vete al objeto scan 00:21:32
que tú has creado arriba 00:21:33
y usa una función 00:21:35
especial de scan 00:21:38
que es 00:21:40
pilla el nuevo entero 00:21:41
el siguiente entero 00:21:42
si yo ejecuto 00:21:45
a ver 00:21:47
dejadme antes que veáis una cosa 00:21:48
si yo ejecuto este programa 00:21:52
El programa 00:21:53
Espera que tiene errores 00:21:57
Ah, claro, porque 00:21:58
Quito esto también 00:22:03
Si ejecuto el programa de antes 00:22:04
Este se ejecuta 00:22:07
Y al final podéis mirar 00:22:10
Que este cuadradito de aquí 00:22:13
Está gris 00:22:15
Pero si vosotros 00:22:16
Lo lanzáis 00:22:21
Veréis que por un momento este cuadradito de aquí 00:22:22
Se vuelve rojo 00:22:25
¿Visto? 00:22:25
Otra vez, rojo 00:22:28
Si este cuadradito está rojo 00:22:30
Quiere decir que tu programa está funcionando 00:22:34
Si este cuadradito está gris 00:22:37
Quiere decir que el programa ha acabado 00:22:41
Si ahora pongo 00:22:43
Este comando de aquí nuevo 00:22:45
Que estamos viendo ahora 00:22:49
Mira que pasa 00:22:50
Que al lanzarlo 00:22:53
Mi cuadradito se queda rojo 00:22:57
O sea, ahora mismo aquí no pone nada, pero porque mi programa ha llegado a un momento en que se ha parado y está a la espera que tú pongas algo con el teclado. 00:23:01
Él cuando llega aquí 00:23:18
Como tú le estás diciendo 00:23:23
Lee algo de teclado 00:23:25
Él se va a parar 00:23:27
No ha completado todavía 00:23:28
Y esperará hasta que tú pongas algo con el teclado 00:23:30
Y le des al Enter 00:23:33
Cuando tú pongas algo 00:23:34
Seguirá adelante 00:23:37
Por ejemplo 00:23:39
Tres 00:23:41
Y no hace nada 00:23:42
¿Por qué no hace nada? 00:23:44
Porque no le he dicho de hacer nada 00:23:48
Habrá hecho esta operación 00:23:49
Pero no le he dicho que la escriba en pantalla 00:23:51
Entonces, vamos a hacer una cosa bien hecha 00:23:53
Primero, como aquí se va a parar 00:23:57
Antes de que se pare 00:24:00
Le voy a decir al usuario que usa mi programa 00:24:03
Que tiene que hacer 00:24:07
Porque si yo lanzo un programa y de repente me viene una pantalla en blanco 00:24:09
Y nadie me ha dicho que hacer, ¿qué pienso? 00:24:12
Pienso, se ha colgado, no está funcionando 00:24:16
Entonces, antes de leer algo, siempre una escritura en pantalla donde digo, dame el lado del cuadrado 00:24:18
Luego irá aquí, se parará a la espera que tú pongas el cuadro, más te lo he dicho 00:24:31
Luego ejecuto lo que tengo que ejecutar 00:24:41
Y finalmente, el área del cuadrado de lado más L, más S, más área. 00:24:45
¿Lo veis? 00:25:12
El área del cuadrado de lado L, ¿cuánto vale L? 00:25:15
Pues lo he leído de teclado. A tiempo de compilación aquí, yo no sé cuánto vale L. 00:25:18
Lo sabré sólo cuando ejecutaré el programa y el usuario me habrá pasado un 3, un 5 o un 27. 00:25:26
Pero sé que aquí dentro estará almacenado el lado. 00:25:33
Para calcular su área, hago lo que me has dado por lo que me has dado y lo guardo dentro de área. 00:25:38
y luego te diré que el cuadrado de lado, lo que me has dado tú, es lo que he calculado yo. 00:25:44
Esto ya es una pizca así, más complejo de lo que hemos visto hasta ahora. 00:25:53
Así. 00:25:59
Vamos a ver si funciona. 00:26:01
Lanzo el programa. 00:26:04
Dice, dame el lado del cuadrado. 00:26:08
¿Cuánto le queréis dar? 00:26:10
El gare del cuadrado del lado 5 es 25. 00:26:14
Fijaos, no toco nada, no vuelvo a compilar 00:26:17
Mismo programa, lo lanzo otra vez 00:26:23
Dame el lado del cuadrado 00:26:26
El área del cuadrado del lado de 7 es 49 00:26:30
He hecho un programa que no soluciona un problema 00:26:33
Soluciona todos los problemas de la categoría calcular el área de un cuadrado 00:26:40
¿Dudas? 00:26:45
¿Qué pasa si yo soy malvado y le digo 00:26:52
jajaja 7.5 00:26:56
explota 00:26:58
¿cómo explota? 00:27:01
con un input 00:27:03
mismatch exception 00:27:05
error de 00:27:07
correspondencia del input 00:27:10
tú le has dicho le un entero 00:27:13
y le has dado un 7.5 00:27:15
pues no es un entero, explota 00:27:17
¿qué pasa 00:27:19
si yo aquí le digo dame la del cuadrado 00:27:21
correcto ¿no? 00:27:25
Explota, porque le estoy dando la palabra 3 y el string no lo sabe gestionar. 00:27:27
Entonces, ¿qué podría hacer? En segundo trimestre, cuando veremos las excepciones, yo podré pillar este error, decir al usuario, oye, mira, el dato que me has dado no es válido y volver a pedirlo. 00:27:37
Y entonces en vez de explotarme 00:27:52
Conseguiré recuperarme del error y volver a pedir 00:27:55
Pero ahora mismo no lo se hace 00:27:59
Entonces exploto 00:28:01
Cuando veis esta cosa de aquí 00:28:02
Es que algo habéis hecho mal 00:28:05
Y aquí os intenta explicarlo 00:28:07
Y aquí os dice donde sale 00:28:10
En particular esto ha salido dentro de Scanner 00:28:12
Ha habido una parte de Scanner que ha explotado 00:28:17
Pero quien ha llamado eso 00:28:21
Ha sido tú 00:28:23
En el método main 00:28:24
En la línea 35 00:28:26
Aquí 00:28:28
Yo le he dicho next int 00:28:30
Next int 00:28:34
Lo que hace es leerme el siguiente entero 00:28:37
Un número entero 00:28:40
Depende de lo que te permite hacer 00:28:41
Creo que hay next double 00:28:46
Creo que hay next secas para palabras 00:28:48
Y por ahora son los que usamos nosotros 00:28:51
¿Vale? 00:28:53
Que serán aquí 00:28:55
¿Vale? 00:28:56
Cadena igual a scan.next 00:28:59
Lee una palabra 00:29:01
Scan.nextint 00:29:02
Lee un número entero 00:29:05
Scan.nextdouble 00:29:06
Lee un double 00:29:09
Y por ahora estos tres son los tres que queremos usar 00:29:10
Nosotros podemos leer 00:29:14
Una palabra, double o enteros 00:29:15
¿Si? 00:29:18
Cuidado no utilizar espacios en los datos tecleados 00:29:21
Porque explota 00:29:24
Esto lee una palabra, no una frase. 00:29:25
¿Dudas? 00:29:33
Autor/es:
Stefano Chiesa
Subido por:
Stefano C.
Licencia:
Reconocimiento - Sin obra derivada
Visualizaciones:
22
Fecha:
26 de septiembre de 2024 - 14:29
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
29′ 37″
Relación de aspecto:
16:10 El estándar usado por los portátiles de 15,4" y algunos otros, es ancho como el 16:9.
Resolución:
1152x720 píxeles
Tamaño:
74.99 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid