Saltar navegación

230925-1 Variables 2 - 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 2023 por Stefano C.

9 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, estoy grabando, por lo tanto, todo lo que decís en automático me estáis autorizando que se pueda grabar, ¿vale? 00:00:00
Entonces, estamos viendo lo que son el concepto de variable y cómo se declara una variable, cómo se usa una variable en Java, ¿vale? 00:00:07
Entonces, ahora aquí vamos a ver unos esquemas de algunos ejemplos y cómo se pueden declarar variables 00:00:20
Y sobre todo también cómo se pueden declarar múltiples variables de golpe 00:00:26
¿Vale? 00:00:32
Entonces, esta de aquí es declaración de variable 00:00:33
Esta ya la conocemos 00:00:36
Esta 00:00:38
Más o menos 00:00:43
Hemos visto antes 00:00:45
Fijaos que para declarar una variable 00:00:46
No necesito ponerle el valor 00:00:50
¿Vale? 00:00:53
Es lo que decíamos antes 00:00:55
Yo estoy declarando la existencia de una variable 00:00:56
Estoy reservando memoria dentro de la RAM para esta misma variable 00:00:59
Pero no la estoy todavía utilizando 00:01:04
En algunos casos, pues esto es necesario 00:01:06
Pensad a nuestro ejemplo típico de la clase alumno 00:01:10
La clase alumno, yo sé que un alumno tiene que tener una edad 00:01:14
Pero ¿qué edad le doy? 00:01:17
En el momento en que de forma abstracta vosotros estáis modelizando un alumno 00:01:22
¿Vale? Estáis pensando, vale, es una escuela 00:01:27
Por lo tanto, dentro de las clases tiene que haber alumnos 00:01:30
Por lo tanto, tengo que poner datos del alumno 00:01:33
¿Vale? Me interesa su edad, me interesa su nombre, me interesa su DNI 00:01:36
¿Vale? Fenomenal 00:01:40
Pero, ¿sé cuál es la edad del alumno? 00:01:41
¿Hay un alumno solo? 00:01:44
Por lo tanto, yo sé que tiene que haber la variable edad 00:01:46
Y la declaro, int edad 00:01:49
¿Quién me la inicializa? 00:01:51
Pues no lo sé 00:01:54
Cuando alguien en un futuro creará un alumno 00:01:55
Y dirá, oye, mira, existe este alumno de aquí 00:01:59
Que se llama no sé cuánto, que tiene edad 00:02:02
Pues entonces entrará en este espacio de memoria que yo he reservado 00:02:03
Y me pondrá la edad de ese alumno 00:02:07
Pero por ahora no, ¿vale? 00:02:09
Además esta cosa típicamente la usaremos cuando veremos 00:02:12
Programación orientada a objetos, ¿vale? 00:02:15
Cada alumno será un objeto que pertenece a la clase alumno 00:02:18
La clase alumno define todos los posibles alumnos 00:02:23
Y luego cada alumno tendrá su edad 00:02:26
Cada alumno tendrá su nombre 00:02:29
Cada alumno tendrá su DNI 00:02:30
Más adelante volveremos sobre esto 00:02:32
Entonces, ejemplos de declaración de variables 00:02:35
Intedat 00:02:38
Me crea un trozo de memoria 00:02:39
O sea, me reserva un espacio de memoria 00:02:41
De cuantos bytes 00:02:43
4 bytes 00:02:44
Porque int son 4 bytes 00:02:50
Por lo tanto, por algún lado 00:02:53
En mi RAM 00:02:54
Yo, en el heap de Java 00:02:55
Lo que se llama heap de Java 00:02:57
Voy a meter un espacio 00:02:59
Que digo, este espacio de estos 4 bytes 00:03:02
No los toques 00:03:05
Porque son míos 00:03:06
Son reservados para poner dentro literales 00:03:07
De tipo 00:03:10
Entero 00:03:11
O sea, que aquí irán números 00:03:15
¿Vale? 00:03:16
Y este espacio de memoria 00:03:17
Será referenciado como edad 00:03:18
Cada vez que yo usaré edad 00:03:20
Me está refiriendo a lo que he escrito 00:03:22
Dentro de estos 4 bytes 00:03:24
Actualmente, ahí dentro no hay nada 00:03:26
Pues sé que puede ir solo números 00:03:29
Pero no hay nada 00:03:31
Segundo, double resultado punto y coma 00:03:32
¿Qué estoy haciendo aquí? 00:03:35
Píllame un espacio de memoria 00:03:37
¿De cuántos bytes? 00:03:40
8 bytes 00:03:45
¿Vale? Más grande que el anterior 00:03:46
Lo llamas resultado 00:03:47
Es decir que cada vez que yo hablaré de resultado en mi programa 00:03:49
Quiero que tú accedas a estos 8 bytes que te he reservado 00:03:52
Y ponme dentro, no lo sé 00:03:56
Porque todavía no he puesto un literal 00:03:58
Pero sé que aquí dentro irán literales 00:03:59
Con un formato que representa números con coma 00:04:02
¿Sí? 00:04:05
Boolean hay espacio libre punto y coma 00:04:08
Es una variable, un trozo de memoria 00:04:10
Que se llama hay espacio libre por algún lado dentro de mi memoria 00:04:15
Que contendrá solo o verdadero o falso 00:04:18
¿Sí? 00:04:21
Y aquí más o menos os explico 00:04:24
Ahora nosotros hemos visto, fijaos que la declaración simple 00:04:26
Tiene esta sintaxis 00:04:30
Tipo 00:04:33
Nombre 00:04:34
Punto y coma 00:04:36
Donde tipo es uno de los tipos que nosotros hemos visto 00:04:37
Por ahora solo usamos los tipos primitivos 00:04:41
Char, int, double, float, etc, etc 00:04:43
El nombre es un identificador 00:04:47
Que tiene todas las características que hemos visto anteriormente 00:04:49
O sea, tiene que empezar con minúscula 00:04:52
Puede utilizar solo letras y números 00:04:54
No puede empezar por número 00:04:56
No puede ser una palabra reservada 00:04:59
Etcétera, etcétera 00:05:01
Otra opción 00:05:01
Es declaración 00:05:04
E inicialización a la vez 00:05:06
¿Vale? En vez de decir 00:05:09
Créame el espacio y luego alguien lo 00:05:10
Inicializará en un futuro 00:05:12
Lo que va a hacer es en una única instrucción 00:05:14
Te va a decir créame el espacio 00:05:17
De memoria y ponme ya un valor allí dentro 00:05:19
Que es 00:05:21
Tipo espacio nombre 00:05:22
Es igual 00:05:24
A literal punto y coma 00:05:26
Este literal tiene que ser del tipo definido al principio 00:05:28
Entonces, por ejemplo 00:05:33
Int numpaginas igual 200 punto y coma me está diciendo 00:05:35
Créame un espacio de memoria 00:05:40
Que sea solo para enteros 00:05:42
Puede contener solo enteros 00:05:44
Este espacio de memoria se llama numpaginas 00:05:46
Y en este momento, allí dentro está el literal 200 00:05:48
Que, fijaos, 200 es de tipo int 00:05:53
Una declaración de una variable booleana sería 00:05:56
Acabado, vale, este de aquí, esta variable que se llama acabado 00:06:03
Es de tipo booleano, entonces booleano acabado 00:06:07
Y en este momento vale false 00:06:10
Esto podría ser una variable que me dice que mientras booleano 00:06:13
Mientras acabado es false, haz algo 00:06:17
Y cuando acabado se vuelve true 00:06:20
Quiere decir que has acabado con tu trabajo 00:06:22
Y por lo tanto sales del programa y se apagas 00:06:25
No lo sé, ¿vale? 00:06:27
Algo significará esta variable 00:06:29
Pero es una variable que solo puede ir 00:06:30
True o false 00:06:33
Y aquí más o menos lo explico 00:06:34
Entonces 00:06:37
Declaración de variables 00:06:39
Solo hay, o declaro 00:06:41
De una variable sola 00:06:43
O declaro sin darle el valor 00:06:44
O declaro inicializándola 00:06:47
Si la declaro sin darle el valor 00:06:49
Quiere decir que esta variable 00:06:51
No está inicializada 00:06:53
Si la variable no está inicializada 00:06:55
No la puedo utilizar 00:06:58
No puedo escribir el contenido de esa variable 00:07:00
¿Vale? 00:07:03
Lo que sí puedo hacer es inicializarla 00:07:05
¿Y cómo la inicializo? 00:07:08
Pues por ejemplo poniendo edad igual a 7 punto y coma 00:07:10
Sin el int 00:07:12
Creo que viene después 00:07:14
Viene después, después 00:07:16
De todas formas 00:07:20
Si la variable no la he inicializado 00:07:21
He utilizado la declaración de arriba 00:07:25
No puedo leerla 00:07:27
¿Vale? 00:07:29
Porque no sé que está escrito allí dentro 00:07:29
Todavía no le he asignado ningún valor 00:07:32
¿Dudas? 00:07:33
Vale 00:07:38
Declaración múltiple 00:07:39
Yo puedo declarar 00:07:41
Varias variables de golpe 00:07:44
Por ejemplo así 00:07:46
Pongo un tipo 00:07:48
Luego un nombre 00:07:49
Coma otro nombre 00:07:52
Coma otro nombre 00:07:53
Coma otro nombre 00:07:55
Punto y coma 00:07:56
Entonces he creado todas estas variables con todos estos nombres del tipo puesto al principio 00:07:57
Por ejemplo, con esta instrucción de aquí yo creo dos variables 00:08:05
Una variable que se llama base, una variable que se llama altura 00:08:12
Las dos serán de 4 bytes, serán enteros 00:08:16
Y ninguna de las dos está inicializada 00:08:21
¿Tiene sentido? 00:08:24
Char, inicial, nombre, inicial, apellido 00:08:27
He creado dos variables 00:08:34
Una inicial, nombre, una inicial, apellido 00:08:36
Las dos son caracteres 00:08:38
Char 00:08:41
No los ha inicializado 00:08:41
Todavía no tienen un valor dentro 00:08:44
El equivalente de la declaración e inicialización a la vez 00:08:47
Que hemos visto antes con varias variables 00:08:54
Se hace así 00:08:56
Entonces yo digo, voy a declarar variables de tipo entero 00:08:57
Sí, ¿qué variables son? 00:09:01
Está, la variable en un páginas 00:09:02
La que se llama en un páginas, que dentro tiene 200 00:09:04
Coma 00:09:07
Y la variable leídas 00:09:08
Que dentro tiene 100 00:09:11
Punto y coma 00:09:12
¿Cuántas variables creo? 00:09:13
Dos 00:09:16
¿Qué tipo tienen? 00:09:17
Las dos el mismo tipo, entero 00:09:19
¿Cuánto vale en un páginas? 00:09:21
200 00:09:25
¿Cuánto vale leídas? 00:09:25
Las puedo utilizar, puedo leerlas así 00:09:27
Porque ya están inicializadas 00:09:29
Boolean error es igual a false 00:09:31
Alarma es igual a false 00:09:34
Puerta abierta es igual a true 00:09:37
¿Veis? 00:09:39
Tres variables de golpe 00:09:42
Cada una con su valor 00:09:43
Las tres son booleanas 00:09:45
Tened en cuenta que este tipo de declaración 00:09:47
Solo se puede hacer con un tipo solo 00:09:49
No puedo aquí dentro de la misma 00:09:51
Crear booleanos enteros 00:09:54
Eso necesita hacerlo en dos instrucciones distintas. 00:09:56
¿Sí? 00:10:01
¿Dudas? 00:10:01
¿Preguntas? 00:10:03
Sí. 00:10:06
Si es así, no es inicializada. 00:10:08
Si es así, es inicializada con su valor. 00:10:17
Si le pongo un literal que no es del tipo que he indicado, me da un error. 00:10:20
Me dice, no puedo poner true dentro de un intervalo. 00:10:25
¿Sí? 00:10:29
También, esta es una forma 00:10:29
Esta página aquí es una forma de hacerlo más rápido 00:10:34
Si vosotros solo sabéis 00:10:36
Esta forma de hacer las cosas 00:10:39
Podéis igualmente declarar 00:10:41
Siete variables, ¿vale? 00:10:43
Declaráis una por línea 00:10:44
Y ya está, ningún problema 00:10:46
O sea que, si esto no lo sabéis 00:10:48
Podéis igualmente ser programadores 00:10:51
¿Cómo se cambia el valor a una variable? 00:10:53
La cosa interesante de la variable es que varía 00:10:59
¿Vale? 00:11:02
Que se puede cambiar 00:11:03
Entonces, la idea es que no puedo modificar una variable que no haya declarado antes 00:11:04
O sea, antes tengo que crear esa variable 00:11:11
Pero la variable se declara una sola vez 00:11:13
Se crea una sola vez 00:11:16
Una vez creada la variable 00:11:17
Entonces lo que puedo hacer es modificarla 00:11:19
¿Y cómo puedo modificarla? 00:11:23
Pues vamos a verlo 00:11:24
la sintaxis para modificar una variable es 00:11:25
el nombre de la variable que quiero modificar 00:11:30
igual un valor 00:11:32
¿vale? punto y coma 00:11:35
este valor puede ser o un literal 00:11:37
o una expresión 00:11:40
que una vez que se haya evaluado 00:11:43
una vez que se haya calculado el valor de esa expresión 00:11:47
el valor final sea del mismo tipo 00:11:51
De la variable 00:11:55
Es decir, que si yo pongo 00:11:57
Por ejemplo 00:12:00
Viene más adelante 00:12:00
Por ejemplo, lo hacemos más adelante 00:12:02
Aquí, por ejemplo, yo tengo 00:12:04
Intedad igual a 18 00:12:07
¿Qué es esta? ¿Una declaración de variable? 00:12:09
¿O una modificación de variable? 00:12:11
Declaración 00:12:15
La estoy creando nueva 00:12:16
¿Vale? 00:12:17
Y después 00:12:18
Puedo modificarla con edades igual a 19 00:12:19
Sin dudas 00:12:22
Lo que decía con la expresión 00:12:25
Es que yo aquí podría hacer 00:12:28
Edades igual a 18 más 1 00:12:30
18 más 1 00:12:32
¿Qué tipo tiene esta expresión? 00:12:34
18 más 1 00:12:37
¿Qué tipo tiene? 00:12:39
Int 00:12:42
Porque si yo hago la operación 00:12:43
18 más 1 es 19 00:12:45
Y 19 es un entero 00:12:46
¿Verdad? 00:12:48
Sí 00:12:51
Se enfada porque has declarado dos variables 00:12:52
Que se amanedan 00:13:04
que dice este este identificador ya ha sido utilizado que puedes poner ese 00:13:04
integrado 1 igual 18 y el coma edad 2 19 luego me tiene que explicar qué quiere 00:13:10
decir el alumno de los dos 00:13:16
edad según un calendario edad según un calendario distinto 00:13:20
había alguna algún estado en el mundo donde tienen calculando la edad de la 00:13:25
fecha de nacimiento sino el año en que has nacido, ¿me equivoco? 00:13:32
Hay gente por todo tipo de sentimientos. 00:13:38
Boolean tiende a igual a true, tiende a igual a false, ¿vale? Lo mismo. 00:13:42
La creo, la uso. Si yo aquí, en vez de poner false, pusiera 00:13:47
una condición booleana, una expresión booleana, que una vez resuelta me da true 00:13:54
o false, como por ejemplo 3 menor que 7 00:14:00
esto me vale 00:14:02
ahora, tienda abierta 00:14:04
igual 3 menor que 7 00:14:06
es una cosa muy rara 00:14:07
pero funcionaría 00:14:09
aquí Java no se mete 00:14:12
dice, me has dado un true o un false, a mi me vale 00:14:13
luego sabrás tu que querías decir 00:14:16
este 3 menor que 7 00:14:18
si cambio el valor a variable que no es 00:14:19
declarado antes 00:14:24
error 00:14:25
Si uso una variable que no ha sido declarada anteriormente 00:14:27
Pues me va a dar un error de no consigo entender este identificador 00:14:33
Tú me has dicho usa edad 00:14:39
Por ningún lado me has dicho de crear un espacio de memoria que sea medad 00:14:41
Por lo tanto lo he buscado pero no lo encuentro 00:14:45
Dudas 00:14:47
Vale 00:14:49
Además de los tipos que hemos visto ahora 00:14:57
¿Vale? Que son tipos numéricos, booleano y char 00:15:00
Que se llaman tipos primitivos 00:15:04
Y si os habéis fijado, todos estos tipos empiezan por minúscula 00:15:06
Intes minúscula, charres minúscula, booleanes minúsculas 00:15:12
Y son palabras reservadas 00:15:16
Existe otro tipo que entenderemos en un futuro mejor 00:15:18
Cuando ya sabremos que son los objetos 00:15:22
Que pero es un tipo tan utilizado, tan necesario 00:15:25
Que lo necesitamos utilizar desde ya 00:15:28
Sin saber que es 00:15:30
Que es el tipo string 00:15:32
Que ya hemos utilizado 00:15:33
Hemos hablado de ellos en episodios anteriores 00:15:36
El tipo string 00:15:41
Representa palabras 00:15:42
¿Vale? 00:15:44
Por ejemplo 00:15:47
Hola 00:15:49
Gato 00:15:52
En el medio del camino de nuestra vida 00:15:53
Me he encontrado en una selva oscura 00:15:55
Que la trinta vía era esmarrita 00:15:56
Y a decir cual era la cosa dura de esta selva 00:15:58
Pues estas cosas son todas string 00:15:59
¿Qué es un string? 00:16:05
Un conjunto de letras 00:16:08
Un conjunto de char 00:16:10
Uno tras otro 00:16:12
Una secuencia de char 00:16:13
¿Sí? 00:16:14
¿Qué son estos? 00:16:17
Y serían 00:16:23
Del tipo char 00:16:24
Del tipo char 00:16:26
Del tipo string, perdón 00:16:27
Son 00:16:29
literales son posibles valores cualquier cadena de caracteres es una posible literal la de destino 00:16:30
vale entonces lo hago aquí porque bloc notas se lee formato fuente más grande hola esto es un 00:16:47
¿Esto es un literal de tipo string? 00:17:02
Sí. 00:17:04
¿Esto es un literal de tipo string? 00:17:06
Sí. 00:17:08
¿Y no puedo hacer una cadena de un solo carácter? 00:17:17
Sí. 00:17:19
¿No? 00:17:21
¿Esto es un literal de tipo string? 00:17:23
Cuidado. 00:17:25
Nos confundáis con esto. 00:17:27
Esto no es un string. 00:17:29
Esto es un chat. 00:17:31
Esto 00:17:33
es un string. 00:17:38
Pero si es lo mismo 00:17:40
No, no es lo mismo 00:17:42
Se utilizan las comillas para indicar 00:17:42
Que lo que hay aquí dentro es un string 00:17:45
Y la apóstrofe para indicar que es un char 00:17:47
Esto es un literal de tipo string 00:17:51
Una cadena de cero caracteres 00:17:56
Pues es un literal de tipo string 00:18:02
La cadena vacía 00:18:04
¿Esto es la cadena vacía? 00:18:05
Esto es una secuencia de caracteres 00:18:12
Espacio 00:18:16
Larga uno 00:18:17
¿Se entiende? 00:18:19
O sea, cualquier combinación 00:18:23
Esto es un string 00:18:25
Sí 00:18:27
Cualquier combinación de carácteres 00:18:28
Largo desde cero hasta infinito 00:18:31
Es un posible string 00:18:34
¿Vale? 00:18:36
Y me sirve para trabajar 00:18:37
Con carácteres alfanuméricos 00:18:39
Con palabras, con frases 00:18:41
Con códigos que no sean 00:18:42
Estrictamente numéricos 00:18:45
Etcétera, etcétera 00:18:47
Tened en cuenta que cuando es un string 00:18:48
Es una palabra 00:18:51
O sea, que esto 00:18:52
¿Tiene sentido? 00:18:54
¿Qué es? ¿Qué tipo tiene esto? 00:18:59
El símbolo 3 00:19:01
¿Es el símbolo 3? ¿Puede hacer esto? 00:19:02
¿Vale? Porque esto no es un entero 00:19:07
Esto es el símbolo 3 00:19:11
Esto 00:19:14
No es el entero 33 00:19:16
O 34, venga 00:19:18
Es el carácter 3 00:19:20
Seguido del carácter 4 00:19:23
¿Entiende? 00:19:26
¿Cuál es un carácter? 00:19:30
Una secuencia de carácter 00:19:35
Porque esto es un carácter 00:19:36
Y este es un carácter 00:19:38
Este es un char 00:19:39
Y este es un char 00:19:41
Pero cuando lo considero como string 00:19:42
Es una secuencia de char 00:19:44
Son varios char juntos 00:19:46
¿Sí? 00:19:49
¿Tiene sentido hacer esto? 00:19:50
¿Tiene sentido hacer esto? 00:20:00
Sí 00:20:05
¿Tiene sentido hacer esto? 00:20:07
No lo digamos, lo veremos 00:20:12
¿Vale? 00:20:14
Por ahora mantengámonos así 00:20:15
¿Se entiende un poco esta cosa de los tipos? 00:20:17
Que hay tipos distintos 00:20:20
Vosotros tenéis que aprender 00:20:22
No solo a saber los tipos de literales 00:20:23
Sino también, con calma 00:20:26
Aprender los tipos 00:20:28
De todas las expresiones 00:20:30
Que tengáis 00:20:33
Si yo tengo 34 dividido 2 00:20:34
El tipo de esta expresión 00:20:36
Entera, ¿cómo es? 00:20:39
El tipo de toda esta expresión 00:20:40
¿Cómo es? 00:20:43
Int 00:20:46
Dudoso, lo veremos 00:20:46
¿Vale? Veremos que pasa 00:20:55
En un caso como este, ¿vale? 00:20:56
Seguramente, ¿qué tipo tiene esta expresión aquí? 00:20:59
Vamos a sentir 00:21:02
Error 00:21:03
Porque no está definido 00:21:07
Esta operación 00:21:09
Entre una palabra 00:21:11
Y un número 00:21:13
¿Qué quiere decir? 00:21:15
Dividir por dos una palabra 00:21:16
No está definido 00:21:18
¿Esto vale algo? 00:21:20
¿Y esto vale algo? 00:21:25
Esto sí, pero veremos que es una excepción 00:21:28
Y veremos por qué 00:21:31
Por ahora, bueno no esto en concreto 00:21:32
Con int aquí no 00:21:35
Pero así si 00:21:36
Esto me va al tree 00:21:37
Lo veremos 00:21:41
En 10 minutos 00:21:44
Si, vale 00:21:46
Entonces este tipo string 00:21:48
Vale, me permite 00:21:51
Declarar variables de tipo string 00:21:53
Como declaro variables de tipo string 00:21:55
Exactamente 00:21:57
Como la 00:21:59
Declaraba antes 00:22:00
Tipo 00:22:02
nombre 00:22:03
valor 00:22:05
literal 00:22:07
de ese 00:22:09
tipo, o expresión 00:22:11
cuyo resultado da un literal 00:22:14
de ese tipo 00:22:16
entonces string nombre 00:22:16
es igual a Juan 00:22:20
pues me hace que dentro 00:22:21
del espacio de memoria 00:22:24
nombre, que puede 00:22:25
solo tener cadenas 00:22:27
o secuencias de char 00:22:29
Pues pones la secuencia de char 00:22:31
J-U-A-N 00:22:34
¿Dudas? 00:22:36
Sí 00:22:40
Aquí podrías poner 00:22:40
Coma ciudad igual Toledo 00:22:48
Coma trampa igual a 3 00:22:50
Como antes 00:22:52
Lo mismo que podías hacer antes 00:22:54
Lo puedes hacer ahora 00:22:55
¿Vale? 00:22:56
Como también puedes hacer 00:22:57
String nombre punto y coma 00:22:58
He creado string 00:23:00
He creado nombre 00:23:02
Sé que puede venir solo string 00:23:03
Pero todavía no lo he inicializado 00:23:05
¿Vale? 00:23:07
Las variables, todo lo que hemos dicho 00:23:07
Para las variables, vale también para esto 00:23:09
Lo único que hemos añadido aquí es un tipo nuevo 00:23:11
Que admite 00:23:14
Literal, es nuevo 00:23:15
¿Dudas? 00:23:16
Esto se llama trampa 00:23:25
Pero la trampa 00:23:26
Ya nosotros ya hemos hecho antes, ¿vale? 00:23:28
Porque esto parece un int 00:23:30
No, no es un int, es un string 00:23:31
Vale 00:23:34
Entonces esto es más 00:23:38
De lo mismo, ¿vale? Un poquito gráfico 00:23:40
Para que veáis bonito 00:23:43
Mira aquí 00:23:44
Grandísima tecnología 00:23:45
Int da igual a 16 00:23:47
Quiere decir un trozo de memoria 00:23:49
Donde dentro le pongo 16 00:23:51
Que se me da de solo 100 enteros 00:23:52
Esto se entiende también 00:23:54
Int dia es igual a 22 00:23:57
Aquí he utilizado un carácter demoníaco 00:23:59
No se usan los carácter demoníacos 00:24:01
Hay que usar esto 00:24:03
Dia int 22 00:24:04
Si miramos los strings 00:24:06
Pues lo mismo 00:24:10
Solo que ahora en vez de poder contener enteros 00:24:11
Contiene string y lo que tiene dentro 00:24:14
Estefano 00:24:16
¿Dudas? 00:24:16
Vale 00:24:22
Entonces vamos a analizar 00:24:22
Estos programitas 00:24:24
Así 00:24:25
Int resultado es igual a 22 00:24:29
¿Qué quiere decir? 00:24:34
Que creo la variable 00:24:35
Que se llama resultado 00:24:37
Que tiene dentro enteros 00:24:38
Que dentro tiene el valor 22 00:24:39
Fenómeno 00:24:41
Resultado es igual a 17 00:24:42
¿Qué quiere decir? 00:24:44
Que decir, vete a este sitio 00:24:45
No me crees una nueva variable 00:24:47
Y donde se escribe el valor 00:24:50
Sostituyes lo que había antes 00:24:53
Que se pierde 00:24:56
Ahora ya no lo puedo volver a leer 00:24:57
Y me pones dentro el nuevo valor 00:24:59
He actualizado el resultado 00:25:03
Desde 22 a 17 00:25:05
¿Puedo recuperar el 22? 00:25:07
No, si no me lo he guardado antes de alguna forma 00:25:09
Como por ejemplo en otra variable 00:25:12
¿Sí? De momento hay que 00:25:13
Ejecuto esto, no puedo decirle 00:25:16
Pero no, vuelve atrás 00:25:18
Pues no, a menos que yo no haya implementado el modo de volver atrás 00:25:19
¿Sí? 00:25:22
Resultado es igual a 5 más 400 00:25:25
Lo que decía antes 00:25:27
Una expresión, vale, muy bien 00:25:28
Pilla 5 00:25:30
Súmale 400 00:25:32
Operación aritmética, lo sabemos hacer 00:25:34
Es 405 00:25:36
El resultado de esta expresión 00:25:37
Lo guardas dentro del resultado 00:25:40
405, fenomenal 00:25:42
Operación un poco más compleja 00:25:44
Resultado 00:25:49
Es igual a 10 00:25:52
Multiplícalo por 10 00:25:54
Y quítale 200 00:25:55
Que pongo dentro del resultado 00:25:57
Menos 100 00:25:59
Porque los enteros 00:26:02
Admiten también números negativos 00:26:05
¿Cómo no? 00:26:08
¿Dudas? 00:26:10
Hasta aquí todo bien 00:26:12
Vamos a sufrir un poquito 00:26:14
Venga 00:26:17
Interés 00:26:19
Es igual a cero 00:26:23
¿Quién me dice que hace esta cosa? 00:26:24
La he repetido solo 15 veces 00:26:32
En los últimos 10 minutos 00:26:34
No siempre los mismos dos 00:26:35
Ya me he cansado los otros dos 00:26:38
No, los mismos tres 00:26:40
Oír la voz de alguien más 00:26:43
Ok, crea la variable 00:26:48
Res 00:26:55
Que tiene dentro 00:26:57
Vale 00:27:00
Y puede tener dentro 00:27:03
Solo 00:27:05
Los tres datos de una variable 00:27:09
¿Todos de acuerdo con esto? 00:27:12
Vale 00:27:14
Siguiente 00:27:15
qué hace esto crea una variable nueva que se llama 00:27:17
que puede contener 00:27:29
y contiene 2 todo de acuerdo hasta aquí estamos todos se ha perdido a alguien 00:27:34
Error, uno lo intenta. 00:27:53
¿Entra en la mano quién sabe? 00:27:55
Cuéntamelo. 00:28:02
No hay resultado. 00:28:09
Muy bien, me actualiza la variable res y ¿qué le pone esto? 00:28:11
Gracias. 00:28:24
¿Se entiende? 00:28:27
¿Qué dice esta operación? 00:28:29
Dentro de res, porque res es a la izquierda, es como todo lo que está a la derecha se pone a la izquierda. 00:28:35
¿Vale? Entonces, dentro de res 00:28:41
Vete a ponerme 00:28:44
El resultado 00:28:46
De esta operación 00:28:47
¿Y cuál es la operación? 00:28:49
La operación es, accede al espacio 00:28:51
De memoria que se llama op 00:28:54
Por lo tanto, accede al espacio 00:28:56
De memoria que se llama op 00:28:58
Que tiene dentro un 2 00:28:59
¿Vale? Por lo tanto, este señor de aquí 00:29:01
En este momento 00:29:04
Es como si valiera 2 00:29:05
Le sumas 1 00:29:07
Haces la operación 00:29:10
2 más 1 es 3 00:29:12
Y este 3 es el valor que vas a poner dentro de res 00:29:14
Fijaos, aquí hemos hecho un salto 00:29:18
Hasta ahora las variables solo aparecían a la izquierda 00:29:25
Siempre decíamos 00:29:29
X es igual a no sé qué 00:29:32
Edad es igual a 37 00:29:34
El lado es igual a 48 00:29:37
Esa es la primera vez 00:29:39
Bueno, ya lo hemos hablado antes 00:29:41
Pero 00:29:44
Primera vez que nos fijamos 00:29:44
En que las variables pueden aparecer también a la derecha 00:29:47
Pregunta para vosotros 00:29:50
¿A OP le pasa algo? 00:29:51
OP no se actualiza 00:29:55
Yo aquí OP la leo 00:29:56
Pero no la escribo 00:29:58
RES la escribo 00:30:00
Duda 00:30:02
Imagínate que ahora cambias el OP 00:30:04
¿Se cambiará automáticamente el RES? 00:30:07
¿O tiene que volver a...? 00:30:10
Imaginamos ahora aquí ejecutar la operación op es igual a 7 00:30:11
Entonces, ¿qué haría? 00:30:20
Me iría a op, a la espacia de memoria op 00:30:23
Me cambiaría el 2 por un 7 00:30:27
¿Cambiaría res? 00:30:30
No, porque aquí en ningún lado hay actualizadores 00:30:33
Esta operación ya se ha ejecutado 00:30:36
Ahora, si yo hago esta operación 00:30:39
Antes de la operación 00:30:42
Res igual a op más uno 00:30:44
Pues entonces sí, porque op ahora vale siete 00:30:45
No vale dos 00:30:48
Pero como la he hecho después 00:30:49
De esta de aquí en la pizarra 00:30:51
Pues entonces quiere decir 00:30:53
Que no 00:30:55
Que res se quedaría tres 00:30:56
Más dudas 00:30:58
Sí 00:31:02
Con string 00:31:03
Lo veremos dentro de un rato 00:31:15
Pero ahora estamos en int 00:31:16
Hemos declarado como índice 00:31:17
Tanto O como R 00:31:20
Entonces estamos haciendo operaciones entre 00:31:21
Entre tipos numéricos 00:31:23
Todos, y ahora veremos 00:31:37
Hay operaciones que podemos hacer 00:31:38
Por ahora me estoy fijando solo en la suma por ejemplo 00:31:39
O resta, pocas cosas 00:31:42
Y después vemos que podemos hacer 00:31:43
Y que es la suma entre enteros 00:31:45
Que es la división entre enteros 00:31:47
Que es la división 00:31:49
Lo veremos, vale 00:31:50
Más dudas, si 00:31:52
El 2S 00:31:54
Sería el resultado 00:31:56
Del IN 00:31:58
Y el 00:32:00
2S lo he puesto yo directamente 00:32:01
El 3 este 00:32:03
El 3 que va en RES 00:32:05
Es el resultado de haber pillado el 2 que está dentro de OP 00:32:07
Haberle sumado 1 00:32:10
Entonces es 3 00:32:11
Y este 3 se lo escribo dentro de RES 00:32:12
Vale, entonces 2 es el número que 00:32:14
Estás poniendo 00:32:19
El 2 es porque he ejecutado esto 00:32:20
Y esto es crear una nueva 00:32:22
Variable 00:32:25
Que se llama op de tipo entero 00:32:27
Que dentro le pones un 2 00:32:29
El valor 2, el literal 2 00:32:30
Se lo he puesto yo 00:32:34
Sin hacer ninguna operación 00:32:34
¿Dudas hasta aquí? 00:32:36
Sí 00:32:40
No es un método 00:32:40
Porque no hay un nombre de método y no hay la paréntesis 00:32:50
Esta es una expresión 00:32:53
Esta toda 00:32:57
Es una instrucción 00:32:59
De asignación 00:33:01
Esta de aquí op más uno 00:33:02
Es una expresión aritmética 00:33:05
Pero no hay métodos 00:33:07
Si ahora esto te pusiera 00:33:09
Res es igual a 00:33:14
Suma uno 00:33:16
De op 00:33:18
Que es un método 00:33:20
Que te pilla op y te suma uno 00:33:22
Y te devuelve el número op más uno 00:33:24
Pues esto sería un método 00:33:26
Pero aquí no lo estamos usando 00:33:28
Y nos lo usaremos por un buen rato 00:33:30
¿Dudas? 00:33:32
Sí 00:33:38
Pillando lo que hay dentro de OP 00:33:38
Sumándole uno 00:33:45
Dentro de OP hay dos 00:33:46
Por lo tanto dos más uno es tres 00:33:48
Pues este tres es el que guardo dentro de 00:33:50
Tres 00:33:52
¿Todos estamos de acuerdo hasta aquí? 00:33:54
¿Queremos sufrir más? 00:34:00
¡Hala! 00:34:04
No lo digáis 00:34:07
Pensadlo 00:34:08
Y decidme 00:34:10
lo que va a pasar aquí 00:34:12
este es un nuevo paso adelante 00:34:14
¿vale? 00:34:36
antes teníamos solo variables 00:34:38
solo a la izquierda, que bien 00:34:39
luego hemos tenido variables distintas 00:34:40
a la izquierda y a la derecha, que bien 00:34:43
ahora tenemos la misma 00:34:45
variable por un lado 00:34:47
y por el otro 00:34:49
y esto ya 00:34:50
es un pasito más adelante 00:34:53
en el mundo de la programación 00:34:56
¿se me da cuenta? 00:34:57
¿cuál es el resultado 00:35:03
según vosotros? 00:35:05
¿uno solo se atreve? 00:35:11
¿dos se atreven? 00:35:13
¿alguien más se atreve? 00:35:20
siempre los mismos 00:35:21
siempre los mismos 00:35:22
No lo sé 00:35:31
Con las paréntesis el problema no se pone 00:35:39
Eh, llámelo cualquiera 00:35:43
Venga, uno cualquiera 00:35:47
Cuéntame, a ver, explícame 00:35:48
¿Qué hago? 00:35:51
¿Y qué hago con este 12? 00:35:55
Cuando estoy en estas situaciones 00:36:08
De ese estilo, siempre 00:36:10
Antes se resuelve la parte 00:36:12
Derecha, hasta que 00:36:14
No sepa cuál es el valor 00:36:16
Que voy a poner en la variable 00:36:18
No puede hacer nada 00:36:20
Entonces, primero 00:36:21
Soluciono res más res por op 00:36:24
¿En qué orden? Pues como hay paréntesis 00:36:26
Aquí no hay duda, ¿vale? 00:36:28
Es res más res 00:36:30
Y lo que sale de res más res lo multiplico por op 00:36:31
¿Vale? 00:36:34
Una vez que tenga un valor 00:36:36
Evaluado de esta expresión 00:36:38
Ese valor 00:36:40
Lo vuelvo a poner dentro de OP 00:36:41
Que fijaos lo he usado aquí 00:36:44
En esta expresión la cosa interesante 00:36:45
La cosa informática 00:36:48
Es que tanto a la izquierda 00:36:50
Como a la derecha tengo OP 00:36:52
Y en un cierto sentido 00:36:53
Valen distintos 00:36:56
Porque el OP de la derecha 00:36:57
Es el OP antes 00:36:59
De actualizarlo 00:37:02
Y el OP a la izquierda 00:37:04
Es el op después de actualizarlo 00:37:06
En un cierto sentido 00:37:09
¿Sí? 00:37:10
Entonces, ¿qué hago aquí? 00:37:12
3 más 3 es 6 00:37:13
Por 2, porque op vale 2 00:37:15
En este momento 00:37:18
Y este valor 12 00:37:21
Ahora lo pongo dentro de op 00:37:23
¿Eso es por o elevado a? 00:37:26
Por 00:37:34
Pero asterisco 00:37:35
Es por barra es dividir 00:37:40
En job 00:37:42
Sí, sí, el por 00:37:43
En los lenguajes de programación 00:37:46
La multiplicación se escribe con el asterisco 00:37:49
La división se escribe con la barra 00:37:51
Así, no así 00:37:54
Las que están en el teclado numérico 00:37:55
La parte numérica del teclado 00:37:58
Pues allí los cuatro operaciones de 00:38:00
Sum, aresta, multiplicación y división 00:38:02
Y si os fijáis está el asterisco 00:38:04
¿Dudas? 00:38:06
Claro, pero el ordenador no colapsa 00:38:09
Porque dice, me estás diciendo de actualizar una variable 00:38:21
Vale, voy a calcular esto 00:38:23
Y cuando calcula esto 00:38:26
No se dice, oh no, me la estás actualizando 00:38:27
No, yo voy a leer 00:38:29
Voy a leer lo que está aquí dentro 00:38:30
6, voy a leer lo que está aquí dentro 00:38:32
3, voy a leer lo que está aquí dentro 00:38:35
3 también 00:38:37
Y luego hago 3 más 3 por 6 00:38:37
Y a este punto voy a acceder a este trozo de memoria 00:38:41
Y voy a cambiarlo 00:38:45
Desde 2 a 12 00:38:46
¿O por 3 más 3? 00:38:47
¿O qué? 00:38:57
No puedes 00:38:58
No puedes porque las expresiones 00:39:04
No van a la izquierda del igual 00:39:07
Van a la derecha del igual 00:39:08
A la izquierda del igual es donde tú lo vas a meter 00:39:10
Y un literal es como si yo te digo 00:39:12
12 es igual 00:39:15
A 5 más 3 00:39:17
Esta cosa aquí no tiene sentido 00:39:19
¿Vale? 00:39:22
No es ni siquiera booleano 00:39:24
Porque para ser booleano debería ser 00:39:25
¿Vale? Y lo veremos 00:39:28
O sea, esto es 00:39:30
Haz 5 más 3, 8 00:39:31
Y ahora ponlo dentro del literal 12 00:39:33
Pues no, literal 12 no es un espacio de memoria 00:39:36
Esto te da error 00:39:39
¿Dudas? 00:39:41
La operación esta de aquí 00:39:45
Con el igual simple 00:39:47
Como está en la pizarra ahora 00:39:49
Es una operación de asignación 00:39:50
Donde asigno el valor de la derecha 00:39:52
A la variable de la izquierda 00:39:56
Está claro que en la izquierda de esta operación 00:39:59
Tiene que haber algo variable 00:40:01
Que puede ser una variable 00:40:04
Puede ser un array 00:40:06
Puede ser un objeto 00:40:08
Puede ser varias cosas 00:40:09
Lo que no puede ser es un literal 00:40:11
O una constante 00:40:13
Esta es una operación de asignación 00:40:15
Donde a la derecha va una expresión 00:40:21
Evaluable 00:40:24
Que dará un valor 00:40:25
Y a la izquierda irá 00:40:26
Un algo 00:40:29
En el que yo puedo 00:40:31
Guardar ese valor 00:40:32
Por ejemplo una variable 00:40:34
Nosotros estamos viendo las variables 00:40:36
Habrá otras cosas que pero son siempre variables 00:40:37
Por favor me equivoque 00:40:39
Hay alguna cosa en la variable 00:40:42
Pero creo que no 00:40:43
¿Si? 00:40:45
Y fijaos que es un igual solo 00:40:48
¿Vale? 00:40:50
Porque luego habrá otra operación que será 00:40:51
Igual, igual, con dos iguales 00:40:52
Que ya no es una operación de asignación 00:40:54
Eso es otra cosa 00:40:56
¿Sí? 00:40:57
Y esto es lo que pasa 00:41:00
Poner 0, poner 2 00:41:04
Cuando actualizo res 00:41:06
Se me actualiza res 00:41:08
Y cuando actualizo op, se me actualiza op a 12 00:41:09
¿Dudas? 00:41:12
Seguimos adelante 00:41:16
Esto 00:41:17
¿Qué hace esto? 00:41:22
Venga rápidamente 00:41:35
Sí 00:41:36
Creas una variable 00:41:37
String 00:41:40
Y le llamas palabra 00:41:42
¿Qué quiere decir variable string? 00:41:43
¿Variable? 00:41:45
De tipo string 00:41:48
No, no, es porque podría llamarse string 00:41:49
Ah, no, no, no 00:41:52
Una variable de tipo string 00:41:53
De nombre palabra 00:41:54
Y dentro pues 00:41:56
Y dentro pongo 00:41:58
Como cadena 00:42:00
¿Vale? 00:42:03
La diferencia 00:42:05
Como cadena de caracteres 00:42:06
Vale, fenomenal, muy bien 00:42:08
Siguiente 00:42:10
Pase de la variable 00:42:11
Palabra 00:42:22
Que es de tipo string 00:42:24
Porque lo había creado antes 00:42:26
Fijaos que no la crea nueva, es la misma 00:42:27
Y quita lo que hay allí dentro 00:42:29
Y pone la palabra 00:42:32
Bord 00:42:34
¿Estamos de acuerdo? 00:42:35
Venga 00:42:41
Por lo que hemos dicho hasta ahora 00:42:43
Esto no tiene sentido 00:43:01
En el sentido 00:43:03
Palabra más palabra 00:43:04
No existe 00:43:06
3 más 3, sí, 6 00:43:07
3 más 7, sí, 10 00:43:10
Pero 00:43:12
No existe 00:43:13
Aritméticamente 00:43:16
¿Vale? 00:43:22
Pero Java, solo para el carácter más, sobrescribe la operación suma, ¿vale? 00:43:23
Y crea también la suma entre palabras. 00:43:35
O sea que existe la suma entre enteros, que es la que conocemos nosotros, 00:43:41
Pero existe también la suma entre palabras 00:43:46
Que no es la que conocemos nosotros 00:43:50
Sino es la operación de concatenación 00:43:53
Es decir, que píllame esta secuencia de aquí 00:43:57
Y pégale de atrás, atrás 00:44:01
Esta secuencia de aquí 00:44:03
Creando, ¿cuántas palabras? 00:44:05
Una 00:44:09
Todo junto 00:44:10
Que es 00:44:12
Aquí está mal 00:44:13
Necesitaría un espacio 00:44:15
Esto sería ELOWORD todo junto 00:44:18
¿Vale? 00:44:20
Si yo aquí hubiese preso ELO 00:44:21
Espacio y luego WORD 00:44:23
Pues entonces sería correcto 00:44:26
Pero la idea es esa 00:44:27
Está pegando las dos cosas 00:44:28
Y es siempre una sola secuencia 00:44:30
Es solo una secuencia 00:44:33
Que es el carácter H 00:44:35
Seguido del carácter E 00:44:36
Seguido del carácter L 00:44:37
Seguido del carácter O 00:44:38
Seguido del carácter O 00:44:39
Seguido del carácter DOVERDO 00:44:41
¿Sí? 00:44:42
Vale 00:44:45
Lo veremos 00:44:45
Eso lo usarás constantemente 00:44:52
Siempre 00:44:54
Lo veremos 00:44:55
Para hacer esto un ejemplo muy básico 00:44:56
Imagínate que tu alumno 00:45:00
Tiene nombre 00:45:02
Apellido 1 y apellido 2 00:45:03
En tres variables distintas 00:45:06
Y tú quieres escribir el nombre completo del alumno 00:45:08
Nombre más apellido 1 más apellido 2 00:45:11
Nombre completo del alumno 00:45:15
Y... ¿Qué es esto? 00:45:17
Dentro palabra es igual a esta cosa monstruosa aquí 00:45:26
¿Funciona? 00:45:37
Porque falta el punto y coma 00:45:41
¿Y si hubiese el punto y coma? 00:45:44
Sí 00:45:46
¿Y qué sale? 00:45:48
Hola a todos, con espacios esta vez 00:45:50
O le pego detrás esta A, espacio A, espacio T, y le pego detrás TO, O2. 00:45:53
Entonces sale hola a todos. 00:46:01
Falta el punto y coma, ¿eh? 00:46:08
Taipo. 00:46:11
¿Dudas? 00:46:13
No. 00:46:16
No es primitivo. 00:46:22
¿Qué te hace pensar que lees ese mayúsculo? 00:46:31
El hecho que sea 00:46:34
String 00:46:38
En vez de ser minúscula 00:46:40
¿Qué me hace pensar? 00:46:44
¿Qué es esto? 00:46:46
Una clase 00:46:47
Los string no son tipos primitivos 00:46:48
Son objetos 00:46:53
Pero como nosotros no sabemos que es un objeto 00:46:54
Pues lo dejamos ahí 00:46:56
¿Dudas? 00:46:57
Te daría un error 00:47:02
Lo hemos visto la otra vez 00:47:06
Te diría 00:47:07
Yo parche 00:47:08
Cuando he mirado la sintaxis 00:47:09
Me faltaba un punto y coma aquí 00:47:11
Ponlo 00:47:13
Pero entonces va junto 00:47:13
Y luego la 2 sin espacio 00:47:14
Está en el espacio 00:47:16
Ah, vale 00:47:21
La anterior 00:47:22
Como no he puesto espacio 00:47:24
Debería ir todo junto 00:47:25
En esta transparencia 00:47:26
Hay no uno 00:47:27
Sino dos errores 00:47:28
Vale 00:47:29
Sigamos 00:47:31
Lo estáis pillando 00:47:33
Vamos a verlo 00:47:34
¿Qué es esto? 00:47:36
Venga, quien no ha hablado nunca, es su ocasión para hablar, puesto que esto es muy fácil 00:47:39
Venga, uno que nunca ha hablado 00:47:45
¿En serio? 00:47:48
Es para vosotros 00:47:54
Venga, ¿qué hace esta instrucción? 00:47:55
Es una variable de tipo string 00:48:03
Vale, sea una variable de tipo string 00:48:05
Con nombre p1 00:48:09
Que se llama p1 00:48:11
Pregunto, ¿está inicializada? 00:48:12
Todos queréis participar 00:48:18
Todos no queréis participar 00:48:27
Cuando uno participe le hago una pregunta 00:48:29
Todos debajo, si, si, no, si, no 00:48:31
Deja jugar también a los otros niños 00:48:33
Este señor está inicializado 00:48:35
He utilizado la forma que crea 00:48:47
Y a la vez inicializa 00:48:50
Lo que pasa es que he inicializado 00:48:52
Con un string vacío 00:48:54
Un string sin caracteres 00:48:57
Una cadena de caracteres de cero caracteres 00:48:59
Pero eso es válido 00:49:01
Si yo ahora voy a leer P1 00:49:02
P1 existe 00:49:04
Si no pusiera la parte de igual comillas 00:49:06
Y pusiera solo string P1 punto y coma 00:49:09
Y voy a leer P1 00:49:12
Allí me da un error, me dice P1 no existe 00:49:13
P1 no lo has inicializado 00:49:15
¿Se entiende? 00:49:19
Vale 00:49:23
Perfecto 00:49:23
Entonces dentro hay algo 00:49:25
que es nada 00:49:27
otra variable de tipo 00:49:29
tri 00:49:43
pedos 00:49:43
esta cuerda está aquí 00:49:48
se ve 00:49:53
un poco 00:50:02
que no quiero pasarme al siguiente 00:50:05
hasta aquí 00:50:07
llevo cuenta 00:50:09
no todos a la vez 00:50:14
tengo ganas de participar 00:50:16
no hay que sacar con sacagorchos 00:50:18
Es una variable 00:50:21
Bueno, P1 00:50:25
Es igual a 00:50:26
All 00:50:29
Más la variable 00:50:29
Del principio 00:50:33
Más 00:50:35
Por lo tanto sería 00:50:35
Es espacio 00:50:42
Esto sería concatenar 00:50:45
Con cateno 00:50:51
A nada 00:50:55
Con cateno 00:50:56
A la 00:50:59
Por lo tanto el resultado es 00:51:00
Ola 00:51:05
Y esta cosa de aquí 00:51:07
Una vez que la he evaluado 00:51:13
Y he salido ola 00:51:15
La guardo donde 00:51:16
Dentro P1 00:51:18
Entonces 00:51:21
P1 ya no contiene lo que contenía antes 00:51:21
Y contiene ahora 00:51:25
Hola 00:51:26
¿Dudas o no? 00:51:28
Y ahora todo lo que hagas a partir de P1 00:51:31
Lo va a empezar en base a hola 00:51:33
Si ahora tú reutilizas P1 00:51:35
Allí dentro hay hola, en este momento 00:51:37
¿Vale? 00:51:39
Antes de haber ejecutado esto, hay nada 00:51:40
Después de haber ejecutado esto, ya hay algo 00:51:42
¿Sí? O sea 00:51:45
Había algo antes también 00:51:46
Pero algo representante de él 00:51:48
Nada, ni un espacio 00:51:50
¿Está de acuerdo? 00:51:51
Ahora máxima atención 00:51:54
Quien habla suspende programación 00:51:56
Está grabado además 00:52:00
¿Qué resultado da esto? 00:52:02
Quien habla suspende 00:52:09
Cuando lo sepáis 00:52:11
Levantáis la mano 00:52:13
Y os indico 00:52:15
Y a lo mejor 00:52:16
A lo mejor 00:52:18
Contestáis 00:52:19
Dos personas lo saben, tres personas lo saben, cuatro, cinco personas lo saben, solo de esa pantalla, aquí nadie lo sabe. 00:52:21
¿Hay alguien por aquí que me cuente? 00:52:52
No sé vuestros nombres, jugáis con que no sé vuestros nombres y entonces no os voy a llamar. 00:52:58
Ahora pues me voy a leer nombres. 00:53:02
Jorge, ¿tú qué crees que hace esto? 00:53:07
Entonces sale 00:53:11
Hola mundo 00:53:31
¿Quién está de acuerdo? 00:53:32
Entonces de los que no están de acuerdo 00:53:40
¿Quién me quiere decir según el que pasa? 00:53:42
Nadie está de acuerdo 00:53:49
Pero nadie se atreve a decir por qué 00:53:50
¿Cómo te llamas? 00:53:52
No, antes 00:53:56
Tú no has levantado la mano cuando he dicho 00:53:57
¿Estás de acuerdo que pone el mundo? 00:54:06
Por lo tanto no estabas de acuerdo 00:54:07
Entonces para ti que pone 00:54:08
¿Sí? 00:54:10
¿Entonces estás de acuerdo con él? 00:54:20
Estás de acuerdo 00:54:22
Perfecto 00:54:23
¿Otro que no sea de acuerdo? 00:54:25
Venga 00:54:28
Exactamente 00:54:29
Mundo 00:54:34
No tiene comillas 00:54:36
Al no tener comillas 00:54:37
¿Qué pasa? 00:54:39
¿Qué es mundo? 00:54:42
Quiero una respuesta que es 00:54:43
Mundo es 00:54:47
Y no 00:54:48
Pero ahí quiero una respuesta que es 00:54:50
Mundo es 00:54:56
Y no 00:54:58
Muy bien 00:54:59
Mundo en este caso 00:55:04
Es una variable 00:55:06
No es un literal 00:55:08
Al no haberle puesto las comillas 00:55:10
Es como si aquí hubiese usado P1 otra vez 00:55:14
Es una variable 00:55:16
Solo que 00:55:18
¿Cómo no he definido esta variable en ningún lado? 00:55:19
Entonces cuando él va a leer mundo 00:55:22
Va a buscar una zona de memoria 00:55:25
Que se llame mundo 00:55:27
No la va a encontrar 00:55:28
Y al no encontrarla me da un error 00:55:30
Que me dice 00:55:32
No consigo encontrar 00:55:38
Ese literal 00:55:41
O sea, ese identificador 00:55:44
Porque no existe, no lo has creado 00:55:45
Si yo antes de todo esto 00:55:47
Hubiese creado aquí arriba 00:55:49
Un string mundo es igual a mundo 00:55:52
Entre comillas 00:55:54
Entonces esto funciona ya perfectamente 00:55:55
Las comillas están al revés 00:55:57
Da igual porque 00:55:59
Es Windows 00:56:01
En Windows para hacértelo bonito 00:56:02
Te pone así y luego te lo pone así 00:56:06
Porque va a salir más bonito 00:56:08
Pero en realidad no 00:56:09
Paréntesis, me viene bien este comentario 00:56:11
No copiéis 00:56:14
Desde mis transparencias 00:56:16
Los ejercicios 00:56:18
Porque esto es Windows 00:56:20
Es Office, tiene detrás 00:56:21
Cosas raras 00:56:24
Que añade office 00:56:26
Para hacer la cosa más bonita 00:56:28
O sea que comillas no son las comillas 00:56:29
Son un símbolo raro que utiliza él 00:56:32
Si copiáis y pegáis 00:56:34
Os lleváis también un montón 00:56:36
De caracteres escondidos 00:56:38
Que luego en Java os hacen caos 00:56:39
Entonces no copiéis 00:56:41
Con control c, control u 00:56:44
Mis apuntes porque no os va a funcionar 00:56:46
No, porque aquí explota 00:56:49
Aquí este no se puede ejecutar 00:56:57
Este de aquí en fase de compilación 00:57:01
El compilador te diría 00:57:03
He buscado mundo 00:57:05
Pero como mundo no lo has declarado 00:57:06
Este identificador no lo ha encontrado 00:57:08
Por lo tanto no te permite ni siquiera ejecutar 00:57:10
Si queréis solo lo probamos 00:57:12
¿Dudas? 00:57:16
Ahora hacemos una pausa, ¿eh? 00:57:24
Hagamos esto. 00:57:25
Literales, ¿vale? 00:57:28
Estamos siempre hablando de literales en general, ¿vale? 00:57:29
El literal 3. 00:57:33
Si os preguntara el tipo 3, el número 3, el literal 3, ¿qué tipo tiene? 00:57:35
¿Qué me contestáis? 00:57:44
Porque no es un número con coma. 00:57:48
3 no es 3,0. 00:57:52
3 no es el carácter 3. 00:57:55
Para diferenciar 00:57:57
Que literal estoy utilizando 00:58:02
¿Vale? 00:58:05
Java utiliza este mecanismo 00:58:06
3 por sí mismo 00:58:08
Es un entero 00:58:11
Este punto 00:58:12
Si quiero esto, 3 00:58:14
Pero como float 00:58:16
O sea, 3,0 00:58:18
Le pongo una f 00:58:20
Es el número 3 00:58:24
Entendido como float 00:58:26
Número 3 00:58:31
Entendido como double 00:58:33
Comilla 3 comilla 00:58:35
El símbolo 3 00:58:38
Entendido como cadena 00:58:40
Como string 00:58:42
Apóstrofe 3 apóstrofe 00:58:45
Es el char 3 00:58:48
Entonces puedo forzar 00:58:51
Estos varios tipos 00:58:54
Porque lo veremos aquí 00:58:56
en unos 5 minutos 00:58:58
Autor/es:
Stefano Chiesa
Subido por:
Stefano C.
Licencia:
Reconocimiento
Visualizaciones:
9
Fecha:
26 de septiembre de 2023 - 20:21
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
59′ 05″
Relación de aspecto:
4:3 Hasta 2009 fue el estándar utilizado en la televisión PAL; muchas pantallas de ordenador y televisores usan este estándar, erróneamente llamado cuadrado, cuando en la realidad es rectangular o wide.
Resolución:
960x720 píxeles
Tamaño:
88.69 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid