Saltar navegación

Activa JavaScript para disfrutar de los vídeos de la Mediateca.

Clase 22-09-23 - 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 25 de septiembre de 2023 por Raquel G.

16 visualizaciones

Más información Transcripción

Descargar la transcripción

Pues a ver, esos son los tipos de datos. 00:00:05
Pues vamos ya a declararlos. 00:00:11
Vale, pues vamos a suponer que mi programa necesita un número entero, ¿vale? 00:00:30
Y me va a mostrar ese número entero multiplicado por 3. 00:00:36
Cualquier tontería de las pocas que podemos hacer ahora sin conocer más entero. 00:00:43
Bueno, pues entonces una vez que yo he entendido lo que tiene que hacer el programa, 00:00:48
ya decido a ver qué variables voy a necesitar. 00:00:50
Pues si mi programa va a coger 00:00:52
Un número entero 00:00:54
Como dato de partida 00:00:56
Y con ese número entero va a hacer cosas 00:00:57
Sea lo que sea 00:00:59
Necesito una variable para guardarlo 00:01:00
Si, necesito una variable 00:01:03
Entonces, una vez que se ha dado cuenta de eso 00:01:04
Pues procede a 00:01:08
Declarar la variable 00:01:10
¿Y qué es declarar una variable? 00:01:11
Pues declarar una variable es 00:01:23
Crear 00:01:25
Una variable en memoria RAM 00:01:29
darle un nombre 00:01:31
y decir de qué tipo es 00:01:32
todo eso es declarar una variable 00:01:35
es crear el espacio 00:01:38
en RAM 00:01:41
para una variable 00:01:43
entonces, para que la máquina virtual 00:01:44
de Java, que es la que está ejecutando todo esto 00:01:58
pueda crear un espacio 00:02:00
acorde con el dato 00:02:01
declarar una variable 00:02:03
crear el espacio 00:02:05
implicará 00:02:06
que digamos 00:02:08
Diciendo el tipo de dato que va a contener 00:02:12
Imprescindible que lo indiquemos 00:02:16
¿Vale? 00:02:19
Imprescindible que lo indiquemos 00:02:20
Y dándole también un nombre a esa variable 00:02:22
Importantísimo lo del nombre 00:02:39
Entonces declarar la variable implica 00:02:55
Que automáticamente aparece el espacio en memoria RAM 00:02:58
Eso implica, con la sentencia que pongamos ahí 00:03:01
Con la sentencia que pongamos ahí 00:03:04
Implica que aparece el espacio 00:03:06
Ese espacio aparece 00:03:07
¿De qué tamaño? 00:03:09
Del tamaño que me diga el tipo 00:03:11
Ya sabemos cada tipo de dato 00:03:13
Cuántos bytes ocupa 00:03:15
Pues cuando declaremos la variable 00:03:16
Y pongamos ahí la sentencia que la declara 00:03:20
Aparece el espacio en memoria 00:03:22
Como parte de magia 00:03:24
La máquina virtual ya se encarga de eso 00:03:25
Que aparezca el espacio en memoria 00:03:27
Del tipo correspondiente 00:03:28
Del tamaño correspondiente 00:03:31
Y además 00:03:32
a partir de ese momento esa variable recibe un nombre 00:03:34
el que le hayamos indicado 00:03:38
que esta variable por ejemplo 00:03:39
su uso va a ser guardar un número 00:03:42
pues yo decido el nombre que a mí me dé la gana 00:03:45
la caja que se crea no tiene nombre 00:03:47
claro, se lo doy yo en mi programa 00:03:49
para hacer referencia a ella 00:03:51
porque si no, ¿cómo hago referencia yo a este espacio? 00:03:53
al espacio en memoria creado 00:03:56
tengo que darle un nombre 00:03:58
para poder referenciarlo desde cualquier punto del programa 00:03:59
Pues si yo decido que mi variable se llame, por ejemplo, número 00:04:02
Porque voy a guardar un número ahí 00:04:08
Pues ya está, le pongo ese nombre, ahora vemos cómo 00:04:10
Entonces las variables tienen un espacio en memoria asociado 00:04:14
Como ya sabemos, del tamaño correspondiente al tipo 00:04:19
Pero tienen que tener un nombre 00:04:21
Porque si no, ¿cómo le digo yo al programa? 00:04:23
Es en esta variable que tienes que guardar el 7 y no en cualquier otra 00:04:27
porque un programa puede tener muchas variables 00:04:31
habilitadas, declaradas 00:04:34
muchas, pero es importante 00:04:36
que la variable reciba un nombre 00:04:38
el que a mí me dé la gana como programador 00:04:39
lo ideal es que lo elija bien 00:04:41
claro, que elija un nombre 00:04:43
que esté en relación con el concepto que va aquí dentro 00:04:45
con el concepto que va aquí dentro 00:04:48
bueno, pues entonces 00:04:50
en fase de diseño 00:04:52
en la que todavía no estoy programando 00:04:55
en fase de diseño yo he decidido 00:04:56
que entre una variable entera 00:04:58
que la voy a llamar número 00:05:00
pues ahora ya 00:05:02
en la fase de codificación escribimos 00:05:04
la sentencia que lo hace 00:05:06
pero claro, la fase de diseño previa 00:05:07
es la que a mí me ha permitido estudiando el enunciado 00:05:10
decir, ah, espérate, que vas a necesitar 00:05:12
una variable entera, la vas a necesitar 00:05:15
vale, dale un nombre 00:05:16
¿qué nombre le vas a dar para que sea claro? 00:05:18
la vas a llamar así, vale, en fase de diseño 00:05:20
yo tomo esas decisiones 00:05:22
y me hago mi croquis y mis historias 00:05:24
y una vez que tengo esas decisiones claras y tomadas 00:05:26
logramos, bueno pues hemos decidido 00:05:29
que vamos a crear un espacio en memoria 00:05:32
para guardar números enteros 00:05:33
y a ese espacio le vamos a llamar número 00:05:36
¿cómo declaro yo ahora ya 00:05:38
una variable 00:05:39
en Java? pues primero 00:05:40
pongo el tipo de dato 00:05:43
en mi caso si he decidido 00:05:45
que es entero, pues sí, ¿vale? 00:05:48
eso es lo primero de todo 00:05:52
pongo el tipo de dato que yo he decidido 00:05:53
por eso Java se dice que es un lenguaje tipado 00:05:55
porque hay que decir, oye, que es ese tipo 00:05:58
vale, el tipo de dato 00:06:00
y luego pongo el nombre 00:06:02
que a mí me ha dado la gana ponerle 00:06:04
a ese espacio en memoria, el que yo decido 00:06:06
el que a mí me ha dado la gana 00:06:08
¿qué decido llamar la número a la variable? 00:06:09
pues pongo número 00:06:12
¿qué decido llamarla x? 00:06:13
pues pongo x 00:06:23
pero jolines, que mal elegido 00:06:24
por favor 00:06:26
olvidémonos de programas cuyas variables 00:06:27
se llaman a veces x y j 00:06:30
¿qué significan esas variables? 00:06:32
¿Qué significa X, Y, J, Z? 00:06:33
No, yo quiero un programa que sea 00:06:36
Número de facturas 00:06:38
Que las variables tengan nombres largos 00:06:42
Y que expliquen bien y que cuenten toda su vida 00:06:44
Número de facturas 00:06:46
Cantidad de clientes 00:06:47
Quiero variables con nombres largotes 00:06:49
Que lo expliquen bien, no cuesta tanto escribirlo 00:06:51
Si luego además los entornos de desarrollo 00:06:53
Te hacen un autocompletado muy fácil 00:06:56
No tienes que estar haciendo todo el rato 00:06:58
Nada de programas 00:07:00
Hablo en general 00:07:01
en general cuando ya están viendo aplicaciones de envergadura 00:07:02
claro, en un programa de prueba para probar 00:07:05
pues venga, lo llamo xy, ya está 00:07:07
pero principio básico 00:07:09
para el buen desarrollador 00:07:11
nombres de variables con sentido 00:07:13
con sentido 00:07:15
que son largotes, estupendo 00:07:17
mejor voy a entender para qué usaste 00:07:19
esa variable, si le has dado un nombre largo 00:07:21
bueno, pues ya está 00:07:23
esa es la sentencia de cada una variable 00:07:27
y terminada en punto y coma 00:07:29
como todas las sentencias en la mayoría 00:07:31
de los lenguajes de pronunciación, terminadas en punto y codo 00:07:33
primera sentencia 00:07:35
que ya podemos 00:07:37
ejecutar y poner en nuestro programa 00:07:38
entonces, esta sentencia 00:07:41
aunque parezca muy sencilla 00:07:43
tiene muchas implicaciones 00:07:44
a la máquina virtual cuando se la encuentra 00:07:47
cuando la máquina virtual 00:07:49
se encuentra esto, pasan un montón de cosas 00:07:51
pasan, que de repente 00:07:53
en la RAM, paz, por arte 00:07:55
de magia, se habilitan 32 bits 00:07:57
ahí, ala, se habilita 00:07:59
32 bits 00:08:03
y luego además pasa 00:08:05
que en toda la memoria 00:08:07
de proceso de mi programa 00:08:09
toda esa especie de bolsa que habilita la máquina 00:08:11
virtual para tener información 00:08:13
que le ayuda para cada programa 00:08:15
en toda esa bolsa, pues ya automáticamente 00:08:17
asocia este nombre 00:08:19
lo asocia a este espacio 00:08:21
de memoria 00:08:23
y ahora, en cualquier otro punto del programa 00:08:24
que yo use 00:08:27
número, use ese término 00:08:29
use número, pues ya sabrá 00:08:32
la máquina virtual a qué espacio 00:08:34
estamos refiriendo, estamos refiriendo a este 00:08:36
porque tiene su nombre 00:08:37
pues los nombres de variables tienen que ser únicos, obviamente 00:08:38
no puedo repetir nombres de variables 00:08:41
porque cada nombre de variable 00:08:43
hace referencia a un espacio 00:08:45
en memoria, donde va a ir un dato 00:08:48
¿vale? 00:08:49
a ver, luego ya, a partir de aquí ya son 00:08:56
matices, variables y cosas 00:08:58
pero bueno, esto ya uno según va programando 00:09:01
ah mira, si puedo hacer esto, ah que bien 00:09:03
ya son matices sobre la idea 00:09:05
la idea es de una variable 00:09:07
que implica poner el tipo de dato 00:09:09
el nombre que yo he elegido 00:09:11
y punto y coma 00:09:13
vale, no podemos 00:09:14
poner nombres de variables 00:09:17
nombres de variables que sean palabras 00:09:19
reservadas del lenguaje 00:09:21
a una variable no la puedo llamar int 00:09:22
por ejemplo, porque int 00:09:24
o byte, o short, o long 00:09:26
tienen ya un significado 00:09:29
concreto dentro del lenguaje Java, que es el tipo 00:09:31
de dato, entonces claro 00:09:33
tengo que elegir un nombre de variable 00:09:35
que no sea una palabra reservada 00:09:37
ya para la sintaxis de Java 00:09:39
pero bueno, eso 00:09:41
si lo usamos ya no sabéis 00:09:42
saber el compilador, no, este niño no puede 00:09:45
entonces, nombres lo más 00:09:47
explicativos posibles, se pueden 00:09:49
usar 00:09:51
caracteres, letras 00:09:52
el subrayado 00:09:55
el dólar juraría que también 00:09:56
Lo probamos ahora, pero bueno, nombres de variables con ese término, a menos que expliquen un concepto concreto que es concatenar y eso, no vais a ver mucho. 00:09:59
Empezando por letra, ¿vale? Hay pequeñas restricciones. A partir de aquí ya, en cada cosa puede haber un montón de matices que vosotros ya con vuestra curiosidad personal podéis ver. 00:10:12
Lo normal es que uno ponga un nombre de variable 00:10:22
lo más explicativo posible, lo menos confuso posible. 00:10:24
¿Vale? 00:10:30
¿Que luego queréis hacer virguería? 00:10:30
Pues, pues, ¿qué caracteres están permitidos para hacer, 00:10:31
para nombrar variables en Java? 00:10:35
Pues poneros a cotillear. 00:10:37
Pero que yo sepa, son números, letras, el subrayado bajo y este. 00:10:39
Pero bueno, combinaciones con sentido, siempre. 00:10:44
¿Vale? 00:10:46
¿Que queréis declarar varias variables del mismo tipo a la vez? 00:10:48
Bueno, pues Java te permite ponerlas separadas por comas. 00:10:51
¿Que mi programa va a trabajar con dos números? 00:10:54
Pues venga, número uno, número dos. 00:10:56
Me permite declararlas, si son del mismo tipo, todas seguiditas detrás del int. 00:10:59
Todas seguidas separadas por comas. 00:11:06
Me deja, todas seguiditas. 00:11:08
Vale. 00:11:10
Entonces, como consecuencia de esa sentencia, pues tengo aquí. 00:11:12
Automáticamente aparecen, plan, dos espacios en memoria RAM. 00:11:16
número 1 y número 2 00:11:19
aparecerán dos 00:11:23
para la variable número 1 y la variable número 2 00:11:23
y ahora ya estas variables 00:11:26
el programa las puede usar 00:11:30
¿las puede usar para qué? 00:11:31
pues lo primero que tendrá que hacer es 00:11:33
darles valor, obviamente 00:11:36
¿para qué quiere uno una variable? 00:11:37
para darle un valor 00:11:40
y una vez que la variable tiene valor 00:11:41
ya puede usarlo 00:11:44
para operar con él, pero lo primero que tiene que hacer 00:11:46
es darle un valor, para poder usarlo 00:11:48
entonces, de partida 00:11:50
cuando el espacio se crease automáticamente 00:11:54
¿qué tiene esto? 00:11:56
no podemos decir no tiene nada 00:11:58
porque es imposible 00:12:00
en los condensadores, en los transistores 00:12:01
en los dispositivos 00:12:04
que forman la memoria RAM 00:12:05
en cada bit 00:12:08
hay un 0 y hay un 1, no hay una nada 00:12:10
eso es imposible, ahí siempre tiene que haber 00:12:12
o un 0 o un 1 00:12:14
entonces cuando este espacio sea creado automáticamente 00:12:15
en memoria 00:12:18
¿qué hay por defecto? 00:12:19
bueno, pues es otra cosa que no se podría poner a curiosear 00:12:21
por defecto lo que hace la máquina virtual 00:12:23
de Java es ponértelo todo a cero 00:12:25
ponértelo todo a cero 00:12:27
pero luego el programa no tiene en cuenta 00:12:29
no tiene en cuenta esto que te había puesto a cero 00:12:31
si luego tú aquí quieres operar 00:12:33
con esta variable sin haberle dado valor antes 00:12:35
te va a decir, no, no, no 00:12:37
no puedes operar con esta variable 00:12:39
porque no le has dado ningún valor 00:12:41
¿vale? pero a ver, físicamente 00:12:42
tiene que tener algo 00:12:45
porque en la RAM 00:12:46
o hay ceros o hay unos, no puede haber 00:12:47
vacío, no puede haber un espacio ahí 00:12:50
un hueco vacío 00:12:52
bueno, pues entonces 00:12:53
si queremos usar esas variables 00:12:56
lo natural sería darles un valor 00:12:58
claro, para luego usarlas 00:13:00
bueno, pues entonces ahora 00:13:02
llegaríamos al siguiente 00:13:04
concepto clave, después de declarar 00:13:06
que declarar es este 00:13:08
que de nuevo tenemos grabado 00:13:10
en la cabeza, lo tenemos muy claro con todos sus matices 00:13:12
que quiero declarar un short, un char, un lo que sea 00:13:14
igual, pero cambiando 00:13:16
aquí el tipo, exactamente igual 00:13:18
pero cambiando el tipo 00:13:21
bueno, pues ahora 00:13:22
siguiente cosa importante, dar valor a variables 00:13:24
¿cómo hacemos eso? 00:13:27
eso es lo que llamamos asignación 00:13:29
de variables, ¿vale? 00:13:31
bueno, pues asignar 00:14:00
valor a variable, ahora ya, esto ya es otro 00:14:01
tema 00:14:03
entonces, para asignar un valor a una variable, la variable 00:14:04
tiene que estar declarada previamente 00:14:11
condición imprescindible 00:14:13
Si no está declarada previamente, no podemos asignarle un valor. 00:14:15
Tiene que estar declarada. 00:14:18
Bueno, en este caso aquí tenemos declaradas dos. 00:14:20
Pues, ¿cómo asignamos un valor a una variable? 00:14:23
Pues con la sentencia de asignación. 00:14:26
La sentencia de asignación que es simplemente nombre de la variable en el extremo izquierdo, 00:14:30
igual y valor que yo le quiera dar a la variable. 00:14:40
entonces a la izquierda nombre de la variable 00:14:45
a la que yo le quiero asignar valor 00:14:48
el operador igual 00:14:52
al que se le llama por razones obvias 00:14:54
operador de asignación 00:14:58
y a la derecha el valor que yo le quiero dar 00:14:59
a la variable 00:15:03
claro, tiene que ser un valor 00:15:05
compatible con el tipo de datos 00:15:10
fundamental 00:15:12
como no le dio un valor compatible 00:15:13
con el tipo de dato con el que se ha declarado 00:15:16
primer error de compilación 00:15:18
que nos encontramos 00:15:20
el valor no es compatible con el tipo de dato 00:15:21
bueno, pues un valor 00:15:23
compatible con el tipo de dato int 00:15:34
está claro cuál es 00:15:35
los números enteros 00:15:37
entonces una asignación 00:15:38
válida para la variable número 1 00:15:42
sería poner ahí un número entero 00:15:43
cualquiera, que yo pongo menos 3 00:15:45
ya está, es una asignación 00:15:47
válida y 00:15:50
terminado con punto y coma 00:15:50
porque todas las sentencias tienen que acabar con punto y coma 00:15:53
ala, esta es una sentencia de asignación 00:15:56
perfectamente válida, cumple todos los requisitos 00:15:58
a la izquierda 00:16:00
el nombre de la variable 00:16:02
operador de asignación igual 00:16:03
y a la derecha 00:16:06
el valor, que tiene que ser compatible 00:16:08
en el caso de los números 00:16:10
está muy claro, de los números enteros 00:16:11
está muy claro los valores compatibles 00:16:14
el número positivo o negativo 00:16:16
si es positivo 00:16:18
no se le pone el signo 00:16:20
si es negativo, sí 00:16:21
¿vale? 00:16:23
entonces esta es una sentencia de asignación válida 00:16:25
esta también 00:16:27
es válida 00:16:31
todas estas son válidas 00:16:33
bueno, son dos sentencias diferentes 00:16:34
esta sentencia 00:16:42
es una sentencia de asignación que asigna menos 3 a este 00:16:43
ahora con esta ya hemos acabado, punto y coma 00:16:46
ahora tendríamos otra sentencia distinta 00:16:47
o sea, la he puesto aquí porque aquí no se ve 00:16:50
para que el programa fuera bonito 00:16:52
lo iría a la gestión de abajo 00:16:53
pero son secuencias 00:16:54
o sea, una se ejecuta después de la otra 00:16:56
cuando está terminado se ejecuta esta 00:16:58
o sea, que tú el tipo sí lo puedes poner seguido 00:17:00
sí, a la hora de declararla 00:17:02
tú puedes ponerlo separado por coma los nombres 00:17:04
para asignar, tú asignas una por una 00:17:06
tú asignas una por una, no puedes asignar el mismo valor 00:17:08
a dos a la vez 00:17:10
vale, entonces 00:17:11
aquí ya empiezan a contar 00:17:16
pequeñas prácticas 00:17:18
a la hora de escribir código 00:17:20
que hacen que los códigos sean más legibles 00:17:22
más claros 00:17:24
que se vayáis incorporando mejor 00:17:25
porque de ver un código que esto un chorizo no se entiende nada 00:17:27
a ver un código claro 00:17:30
la diferencia es grande 00:17:31
por supuesto que pueden poner las sentencias todas en la misma línea 00:17:32
pero no entiendo nada 00:17:35
lo normal es que cada sentencia 00:17:37
se ponga una línea distinta 00:17:38
esta que es una sentencia diferente a esa 00:17:40
la pongo aquí debajo 00:17:43
entonces primero se ejecuta esta asignación 00:17:45
la máquina virtual ya ha terminado con ella 00:17:47
ahora se ejecuta la siguiente 00:17:49
la máquina virtual ya ha terminado con ella 00:17:51
luego la que venga después 00:17:52
si es que hay alguna en las que vengas a pasar 00:17:54
eso por un lado 00:17:55
pero eso es más evidente 00:17:58
que los programas mejor una 00:18:00
y otra 00:18:01
es bastante recomendable poner un espacio 00:18:03
antes y después del igual 00:18:06
que vais a ver a lo mejor 00:18:08
en función de las costumbres y de los usos 00:18:12
que en algunos casos no están incluidos 00:18:13
pero hombre se agradece 00:18:16
cuando se revisa un código 00:18:18
que esté todo apiñado 00:18:19
a que estén estos espacios 00:18:22
se agradece bastante 00:18:24
para clarificar luego 00:18:26
el conjunto de acciones que hay que hacer 00:18:27
bueno, pues por ejemplo 00:18:29
para verlo escrito ya en 00:18:38
la pantalla 00:18:40
que es más agradable 00:18:42
que 00:18:46
vale, aquí 00:18:47
adiós 00:18:52
vale 00:19:08
bueno 00:19:17
bueno, llevo aquí una pedazo de letra 00:19:33
para los de atrás 00:19:43
luego así no me cabe nada 00:19:44
en el este, pero bueno 00:19:46
vale, ahí 00:19:47
vale, pues venga, vamos a hacernos esta clase 00:19:53
ya de saludar del otro día afuera 00:20:00
vamos a hacernos 00:20:02
otra clase diferente 00:20:05
new class 00:20:07
por ahora asociar 00:20:09
cada clase a un programa distinto 00:20:12
¿vale? 00:20:14
y luego el concepto de clase en realidad 00:20:16
se asocia a otra cosa 00:20:17
pero ahora mismo cada clase es un poco distinto 00:20:22
a ver 00:20:24
truco para que no tengáis que escribir 00:20:25
el public static 00:20:28
lo in main que ya habréis visto 00:20:30
pero eso no significa que no lo vayáis a aprender 00:20:32
de memoria 00:20:34
cuando creéis una clase 00:20:35
como vimos el otro día aparte de la 00:20:38
del nombre que hay que ponerlo 00:20:40
podéis marcar aquí si queréis 00:20:42
que os incluya esto directamente 00:20:44
entonces si lo marcáis 00:20:46
os pone ya eso 00:20:48
Pero lo tenéis que saber de memoria 00:20:49
Como prácticamente todo 00:20:53
De hecho, de lo que he dicho hoy 00:20:56
Lo único que no tenéis que saber de memoria 00:20:57
Es que eso de que la programación estructurada 00:20:59
Se basa solo en tres tipos de estructuras 00:21:02
Y no se va a tener la estructura 00:21:04
Sería a lo mejor lo único 00:21:05
Que todo lo demás 00:21:06
Venga, pues, ala, le incluimos 00:21:08
Venga, ejemplos variables 00:21:10
Le vamos a llamar ejemplos variables 00:21:15
vale, quitamos esto 00:21:19
bueno y aquí cuando escribimos es cuando ya empiezo 00:21:24
equivocarme y escribir las cosas mal 00:21:26
pues venga, vamos a 00:21:29
declarar una variable entera, pues ya está 00:21:31
lo mismo que hemos escrito ahí 00:21:33
número 1, número 2 00:21:35
a ver, esta sería 00:21:37
la forma bonita 00:21:39
ir tabulando las cosas 00:21:41
veis que el public static boi main 00:21:44
lo ha tabulado 00:21:46
respecto a este, le voy a quitar el public 00:21:47
Que no me gusta 00:21:49
¿Vale? ¿Veis que lo ha tabulado? 00:21:52
Claro 00:21:57
Ahora, todo lo que va aquí 00:21:58
Entre estas llaves, todo lo que va aquí 00:22:00
Es ya mi código, mis sentencias 00:22:02
Pues para que quede muy claro 00:22:04
Este tabulador también, ahí mejor 00:22:06
Y todas las sentencias que yo escriba 00:22:09
Pues todas ahí, todas tabuladitas 00:22:10
Aquí en medio 00:22:13
Todas tabuladitas ahí 00:22:14
Para que se vea claro 00:22:17
¿Es obligatorio? 00:22:17
hombre, obviamente no 00:22:20
yo puedo hacerme un programa 00:22:21
así 00:22:23
ala, que programa tan divino 00:22:25
perfectamente, no tiene errores de compilación 00:22:35
no tiene nada 00:22:38
y así hasta una línea infinita 00:22:39
¿para qué sirve esto? 00:22:42
si te funciona la primera, estupendo 00:22:44
pero cuando tengas que revisar el código 00:22:46
olvídate, no 00:22:47
hacer códigos claros y elegantes 00:22:49
y para eso los tabuladores son importantes 00:22:52
Esto iría por aquí, esto iría por aquí, esto iría por aquí y esto iría por aquí 00:22:54
Como veis ya empiezan a aparecer algunas llaves 00:23:04
Ahora mismo solo vamos a coexistir con estas llaves 00:23:07
Solo con estas 00:23:12
Más adelante tendremos que crear nuestras propias llaves para nuestros propios bloques 00:23:13
Pero ir acostumbrándoos 00:23:18
Cada llave se cierra a la altura donde arranca la línea en la que se abrió. 00:23:21
Eso hace que quede todo más claro. 00:23:28
¿Veis? Esta llave cierra esta y se cierra a la misma altura de tabulación de la línea donde empezó. 00:23:30
Esta llave que cierra esto, se cierra a la misma altura de tabulación de la línea donde empezó. 00:23:36
¿Vale? Esas cosas, hacedlas desde ya. 00:23:42
La última, la que está aquí en el número 10, me he perdido. 00:23:45
me he perdido, o sea, esta llave 00:23:54
arranca esta línea, entonces la llave que la cierra 00:23:57
a la misma altura de donde arranca la línea escrita 00:23:59
o sea, esta llave 00:24:01
pertenece a esta línea 00:24:05
este corchete 00:24:07
está asociado a esta línea 00:24:11
con lo cual la que la cierra, que es esta 00:24:12
tiene que estar 00:24:15
a la misma altura que donde arrancaba 00:24:17
la línea en la que empezó 00:24:19
eso 00:24:20
efectivamente 00:24:21
o sea, class es la 00:24:27
¿eh? 00:24:28
¿cómo queda igual donde lo abra? 00:24:34
sí, dices que podría ponerlo yo aquí 00:24:39
podría ponerlo ahí, pero queda feo también 00:24:41
o sea, la costumbre es que tú abras la llave 00:24:43
en la misma línea 00:24:45
donde arrancaría ese bloque, aunque no lo entendemos 00:24:47
lo abras en esa misma línea 00:24:49
y el cierre sea la misma altura 00:24:50
donde empieza la línea en la que la abriste 00:24:53
¿vale? 00:24:55
Es lo que debemos acostumbrarnos, a verlo así, 00:24:57
porque luego lo vamos a hacer así también nosotros en nuestras propias... 00:25:00
¿Que podría hacerse de otra manera? 00:25:05
Claro que podría, pero normalmente hay ciertos convenios 00:25:06
que siguen todos los desarrolladores, ciertos convenios, 00:25:10
para entender más o menos y ser legibles unos para otros. 00:25:14
Aquí lo mismo, este espacio después de la coma, 00:25:19
es como cuando... 00:25:22
Esto es una regla ortográfica de toda la vida. 00:25:23
cuando escribís 00:25:25
después de una coma siempre hay un espacio 00:25:26
¿no? es una regla de autografía 00:25:29
pues aquí también se sigue, si yo me lo pongo 00:25:31
aquí todo pegadito, también puedo 00:25:33
y esto lo vais a ver más 00:25:35
pero el acuñamiento 00:25:37
pues nunca viene mal 00:25:39
vale, entonces de hecho 00:25:41
este ya, el entorno de desarrollo 00:25:42
que ya pretende ayudarme 00:25:45
ya me está 00:25:47
diciendo cosas, porque como veis 00:25:49
me está subrayando en amarillo 00:25:51
en rojo no 00:25:53
Porque no hay ningún error de compilación 00:25:54
Está perfectamente escrito 00:25:57
No hay ningún error de compilación 00:25:58
Otra cosa es que yo me hubiera equivocado 00:26:00
Y me hubiera dado por hacer esto 00:26:02
Ostras, aquí ya, claro, aquí ya la he cagado 00:26:03
Aquí he metido un error de compilación 00:26:06
Porque el tipo de dato no se llama IN con I mayúscula 00:26:08
Recordad que es sensible mayúscula y minúscula 00:26:11
Se llama IN con minúscula 00:26:13
Entonces aquí si habría escrito yo algo mal de la sintaxis 00:26:14
Y me daría rojo error de compilación 00:26:17
Aquí ya sí que no hay nada que avanzar 00:26:20
Entonces yo diría 00:26:21
Uy, error de compilación 00:26:23
¿Qué pasa? 00:26:24
Vamos por curiosidad a ver si el aviso que me da 00:26:26
En este caso tiene sentido o no 00:26:28
Debería tenerlo, pero es que esto ya 00:26:29
Y me dice 00:26:31
A ver, me dice 00:26:32
Oye, int con mayúsculas 00:26:35
Esto no lo puedo resolver a un tipo de dato 00:26:38
Pues efectivamente, es que int con mayúsculas no existe 00:26:41
No es un tipo de dato 00:26:45
Vale, entonces 00:26:47
Lo cambio 00:26:49
Y efectivamente ahora ya no hay errores de compilación 00:26:52
pero me sigue subrayando algo en amarillo 00:26:54
las cosas en amarillo no son las de compilación 00:26:57
esto compila y ejecuta 00:26:59
ahora mismo lo ejecuto y no va a pasar nada 00:27:01
se va a abrir unos espacios en memoria 00:27:03
y cuando el programa termine, ¡pam! va a desaparecer 00:27:05
eso es lo que va a pasar instantáneamente 00:27:07
se abre en RAM y se cierra en RAM 00:27:09
eso es lo que pasaría, que no llegamos a verlo, claro 00:27:10
entonces, errores de compilación no hay 00:27:13
pero el aviso amarillo 00:27:15
son avisos 00:27:18
de que, oye, te aviso 00:27:19
te aviso de cosas 00:27:20
para que las tengas en cuenta 00:27:22
que es que no le hace ninguna falta avisarnos 00:27:24
y ya la sabemos 00:27:25
¿de qué me está avisando aquí? 00:27:26
vamos a ver de qué me avisa 00:27:30
me está avisando 00:27:31
de que 00:27:34
esta variable 00:27:36
que tienes declarada no la usas para nada 00:27:37
es que tontería, un programa en el que declaras 00:27:39
una variable que no usas 00:27:42
es un aviso que bueno, tiene sentido 00:27:43
entonces las cositas, los avisos amarillos 00:27:46
está bien 00:27:48
tenerlos en cuenta y mirarlos 00:27:49
porque hay veces que te hacen darte cuenta 00:27:51
de algunas cositas 00:27:53
pero siempre de nuevo 00:27:54
para saber si lo que te dice tiene sentido o no 00:27:56
aquí te está diciendo, vaya programa más tonto 00:27:59
que declaras una variable 00:28:01
que no usas 00:28:03
y tú dices, pues sí, efectivamente 00:28:04
a lo mejor te das cuenta, tú tienes ya un programa 00:28:07
enorme hecho, que has cambiado 00:28:09
lo has arreglado, le has preparado de todo 00:28:11
y ya ves una cosa 00:28:13
amarilla arriba, dices, a ver 00:28:15
ah, coño, claro, que esta variable 00:28:17
al final la abandone y la sigo teniendo 00:28:18
aquí arriba, ah, pues bueno 00:28:21
y te quedas mojado del programa 00:28:23
entonces a veces tiene su utilidad 00:28:24
bueno, vamos a usarlas, pues nada, vamos a usarlas para 00:28:26
asignarle un valor 00:28:29
número 1 igual a 5 00:28:31
muy bien 00:28:33
número 2 igual a 00:28:33
menos 27 00:28:36
estupendo 00:28:38
muy bien, vale 00:28:40
ahora 00:28:42
vamos a mostrar el valor de las variables 00:28:45
vamos a mostrarlo 00:28:46
teníamos una sentencia 00:28:48
que ya conocemos 00:28:50
que la metemos desde el principio 00:28:53
no nos llama remedio, pero es básica 00:28:54
que sirve para mostrar 00:28:56
por pantalla 00:28:59
ya la conocemos 00:29:00
vale, entonces 00:29:01
esta sentencia 00:29:03
su uso original 00:29:06
como ya hemos visto es una cadena 00:29:08
tú le das una cadena y te la muestra 00:29:10
antes lo usamos con el hola 00:29:12
pero si le damos 00:29:14
un nombre de variable 00:29:16
si le damos un nombre 00:29:18
de variable 00:29:20
lo que hace es 00:29:21
coger ese valor 00:29:25
coge ese valor 00:29:27
te lo convierte a la cadena 00:29:29
de datos, la cadena de caracteres 00:29:32
que lo represente te la muestra 00:29:34
o sea, el sistema de octetel es muy listo 00:29:35
es muy listo, ya entenderemos 00:29:38
por qué es capaz de hacerlo más adelante 00:29:40
cuando sepamos manejar métodos ya lo entenderemos 00:29:42
pero como tenemos que utilizarlo desde ya 00:29:44
porque es que si no hacemos nada 00:29:46
ahora mismo que nos quedemos con la idea 00:29:47
de que este es un método muy listo 00:29:50
y que le des lo que le des 00:29:51
se las apaña para convertirlo en una cadena de caracteres 00:29:53
y mostrártelo por consola 00:29:56
cuando yo le dé esto 00:29:57
él no me va a mostrar por consola 00:29:59
la cadena de texto número 1 00:30:01
no me va a mostrar eso 00:30:04
esa es la que me mostraría si yo le digo esto 00:30:04
¿vale? 00:30:07
es decir, daos cuenta de esta diferencia importante 00:30:10
con esto 00:30:12
me estaría mostrando 00:30:14
por consola la cadena 00:30:16
de caracteres número 1 00:30:18
tal cual 00:30:20
vamos a ponerlo aquí en un comentario 00:30:21
la cadena de caracteres número 1 00:30:25
vale, pero System.out es muy listo 00:30:41
insisto, y es capaz de hacer 00:30:43
más cosas, además de mostrar 00:30:45
una cadena de texto tal cual, entrecomillada 00:30:47
y que es capaz de hacer, si yo le doy 00:30:49
un nombre de variable 00:30:52
y gracias a Dios que le he puesto nombres a variables 00:30:53
porque si no le ponemos nombres a variables 00:30:55
es imposible 00:30:58
acceder a los datos que están guardados en ellas 00:30:59
es imposible 00:31:01
entonces como les hemos dado un nombre a las variables 00:31:02
pues podemos referirnos 00:31:05
a ellas en cualquier punto del programa 00:31:07
pues yo me quiero referir a ellas aquí 00:31:10
y decir, oye 00:31:11
muestra por consola 00:31:13
lo que haya en esta variable 00:31:15
entonces esto 00:31:17
es una cosa 00:31:19
porque está entrecomillado 00:31:21
y esto es otra 00:31:23
esto es la cadena de caracteres 00:31:24
Número 1, tal cual, clavada 00:31:28
Esa cadena de caracteres 00:31:29
Que si se la paso al System.out lo muestra 00:31:30
Y esto es 00:31:33
La variable que se llama número 1 00:31:35
Pues si yo se la paso al System.out 00:31:38
Él es muy listo y sabe hacer muchas cosas 00:31:42
Entre ellos sabe 00:31:43
Coger el contenido de esa variable 00:31:44
Porque le estoy dando su nombre 00:31:47
Coger el contenido 00:31:48
Convertirlo en una cadena de caracteres 00:31:49
Para que yo lo vea por consola 00:31:52
¿Vale? Entonces 00:31:53
Variable 00:31:55
Que se llama 00:32:07
Número 00:32:09
Uno 00:32:14
¿Vale? 00:32:15
Pues son dos cosas muy distintas 00:32:16
Estas dos sentencias 00:32:18
¿De acuerdo? 00:32:19
¿Vale? 00:32:25
Si esta variable no existiera 00:32:26
De nuevo error de compilación 00:32:28
Imaginaos que me he equivocado 00:32:31
Porque estoy escribiendo muy rápido 00:32:33
Y he escrito los oes 00:32:34
Paz, automáticamente error de compilación 00:32:36
Está claro 00:32:39
Y el compilador, si yo me voy aquí al aviso, me diría, uy, número 1, no sé de qué me hablas. 00:32:40
Claro, error de compilación. 00:32:50
Es decir, cuando se usa una variable, esa variable tiene que estar declarada previamente. 00:32:52
Si no, no se puede usar. 00:32:58
Si no, no se puede usar. 00:33:01
Entonces, esta variable, la máquina virtual busca y no ve ninguna que se llame número 1. 00:33:02
Pues lo siento, pero no 00:33:09
Error de compilación, no podemos pasar de ahí 00:33:10
Entonces yo lo miro y digo 00:33:12
Ah, es que me he equivocado, he puesto una vez más 00:33:15
Vale, ahora sí 00:33:16
Esta variable sí existe, está declarada 00:33:18
Y no solo está declarada 00:33:21
Sino que la he usado 00:33:23
Ya una vez antes 00:33:24
Esta vez para asignarle un valor 00:33:26
Vale, esta vez para asignarle un valor 00:33:28
Vale, aquí como veis estoy poniendo comentarios 00:33:30
Ya vimos el otro día que para poner comentarios en un código 00:33:33
Podemos hacerlo de esta manera 00:33:35
Entonces si ejecutamos este código 00:33:37
Pues claro, nos saldrá 00:33:41
Lo que nos podemos imaginar 00:33:43
Primero, muestra la cadena número uno 00:33:47
Esta cadena de texto 00:33:51
Esto es lo que está mostrando 00:33:52
Ha hecho esta sentencia 00:33:54
Bueno, primero ha hecho estas dos 00:33:56
Bueno, ha hecho todas 00:33:58
Es decir, este programa ha hecho un montón de cosas 00:33:59
Ha creado un espacio memoria 00:34:02
con 32 bits para el número 1 00:34:04
que da otro espacio en memoria, con 32 bits para el número 2 00:34:07
luego a ese espacio en memoria 00:34:09
le ha metido la codificación binaria en un 5 00:34:11
al otro espacio en memoria le ha metido la codificación binaria 00:34:13
en 27, y un menos 27 00:34:15
luego una vez que ha hecho eso 00:34:17
una tras de otra, una vez que ha hecho eso 00:34:18
ha mostrado por consola 00:34:21
la cadena de texto número 1 00:34:23
aquí la tenemos 00:34:25
una vez que ha hecho eso, ha mostrado por consola 00:34:26
el contenido de la variable 00:34:29
número 1, porque aquí no se la estoy dando en recomiñada 00:34:31
Número 1 00:34:33
Vale, aquí lo ha mostrado 00:34:35
5, justo, perfecto 00:34:37
Pues, estupendo 00:34:39
Otro error de compilación típico 00:34:40
Imaginaos que 00:34:46
Vale, se me ha olvidado a mí 00:34:48
He declarado esta variable 00:34:54
He declarado esta variable 00:34:56
Y se me ha olvidado asignarle valor 00:34:59
No tiene valor 00:35:02
Eso es lo que se llama 00:35:03
Está sin inicializar 00:35:05
Es una variable que está sin 00:35:07
inicializar 00:35:09
está declarada, el espacio de memoria existe 00:35:10
pero no tiene nada dentro 00:35:13
vale, se me ha olvidado hacer esta línea 00:35:14
la he comentado, que comentarla es como 00:35:17
decirle a la máquina virtual 00:35:19
ignora, esto no es código, esto son palabrerías 00:35:21
automáticamente 00:35:23
me aparece el error de compilación típico 00:35:25
que es, cuando yo trato de usar 00:35:27
una variable 00:35:30
que no tiene valor 00:35:32
la máquina virtual me dice 00:35:33
perdona, no me pidas 00:35:35
que use esta variable, es decir, no me pidas 00:35:37
que coja su contenido para hacer algo 00:35:39
lo que sea, en este caso mostrarlo 00:35:41
por consón no me pidas porque no tiene nada 00:35:43
y es lo que nos está diciendo 00:35:45
¿vale? pues error 00:35:47
típico de compilación 00:35:50
tratar de acceder al valor de una 00:35:51
variable para hacer algo con ella, como es 00:35:53
aquí el caso, sin que tenga valor 00:35:55
sin que esté inicializada 00:35:57
y entonces va y me lo dice 00:35:58
y me dice 00:36:00
la variable número uno podría no estar 00:36:02
inicializada, tanto que 00:36:05
no está inicializada, es lo que me dice 00:36:07
y tanto que no está 00:36:09
en realidad sí que tiene algo 00:36:10
ya lo he dicho antes, tiene un montón de ceros 00:36:13
la memoria no puede tener un hueco ahí vacío 00:36:14
tiene un montón de ceros, pero eso a la máquina virtual 00:36:17
no le vale, la máquina virtual 00:36:19
quiere que tú la inicialices 00:36:21
¿vale? y ya no 00:36:22
ya con esto nos vamos 00:36:27
de hecho, el primer valor 00:36:29
que recibe una variable, hay veces 00:36:31
que ya se le da en el mismo momento de declarar 00:36:33
por comodidad, en el mismo momento 00:36:35
entonces yo esto mismo que he hecho, que es declarar 00:36:37
y luego dar valor, se permite hacer en la misma línea de la declaración de esta manera. 00:36:39
A la vez que declaras, ya de paso le asignas. 00:36:45
Luego, con esta sentencia, a la variable número 1, primero la declaro, la hago aparecer en memoria, 00:36:49
y ya de paso le asigno un valor. 00:36:55
Y lo mismo podría hacer con número 2, ya si quiero. 00:36:58
Si quiero. 00:37:03
Entonces, a la vez que se declara, se puede dar un primer valor, 00:37:04
que es lo que se llama inicializar 00:37:08
a la vez que se declara 00:37:10
si uno quiere 00:37:13
y así nos ahorraríamos esto 00:37:13
que luego quiero yo que cambie de valor y tenga otro 00:37:15
no pasa nada, se lo vuelvo a cambiar 00:37:18
le di inicialmente el 5 00:37:20
pero ahora le asigno el 15 00:37:22
bueno, pues el 5 desapareció 00:37:24
ahora tiene el 15 00:37:25
bueno, y ahora ya sí que lo 00:37:26
vamos a dejar aquí 00:37:30
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
16
Fecha:
25 de septiembre de 2023 - 12:50
Visibilidad:
Público
Centro:
IES ROSA CHACEL
Duración:
37′ 34″
Relación de aspecto:
1.78:1
Resolución:
1280x720 píxeles
Tamaño:
716.98 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid