Saltar navegación

230920-3 Variables y tipos de datos - 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.

12 visualizaciones

Más información Transcripción

Descargar la transcripción

Voy a grabar esta clase, por lo tanto, si habláis es que me dais el permiso de ser grabados. 00:00:01
Vamos ahora a hablar de un tema bastante interesante. 00:00:09
Esto de las variables. 00:00:15
Alguno de vosotros ya lo habrá visto en programación anteriormente. 00:00:16
Si ha hecho alguna programación. 00:00:20
Alguno de vosotros habrá visto algún concepto parecido en bachillerato. 00:00:22
Si habéis hecho bachillerato, a veces se hace un poco de programación allí. 00:00:27
O a veces en matemática algunos conceptos pueden tener una relación con esto, ¿vale? 00:00:30
Es un concepto que por sí mismo no es tan complejo, ¿vale? 00:00:38
Pero es que hay que entenderlo muy bien 00:00:42
Porque a partir de ahora y por el resto de vuestra vida en informática vais a usar variables 00:00:44
Si esto lo tenéis bien entendido, pues perfecto 00:00:50
Si tenéis dudas sobre estos conceptos 00:00:54
Llegará un momento en que cuando las variables se complican un poco 00:00:57
Y cuando las variables en vez de variables simples son arrays 00:01:01
O son listas o son de objetos y cosas por el estilo 00:01:04
Y tienes un montón de tipos raros 00:01:08
Pues llega un momento en que dices 00:01:09
Oye, ¿qué estoy haciendo? 00:01:12
¿Sí? 00:01:14
Por lo tanto es bien que esto lo entendáis bien 00:01:14
Si tenéis dudas en cualquier momento levantáis la mano y me decís no lo entiendo 00:01:19
¿Sí? 00:01:22
Vale 00:01:23
¿Qué es una variable? 00:01:24
En programación 00:01:27
Una variable es una representación simbólica de un dato 00:01:28
¿Qué quiere decir esto? 00:01:34
Cuando yo antes hablaba del señor alumno 00:01:37
¿Vale? 00:01:39
Y le decía tú tienes una edad 00:01:41
¿Vale? 00:01:43
Esta edad del alumno 00:01:45
Es una representación simbólica de un dato 00:01:48
Es decir 00:01:51
¿El alumno qué edad tiene? 00:01:53
No lo sé 00:01:56
yo sé que tiene una edad 00:01:57
pero dependiendo de que alumno es 00:01:59
tendrá un valor 00:02:02
asociado distinto 00:02:04
habrá un alumno que tiene 00:02:06
17, un alumno que tiene 00:02:08
25 y un alumno que tiene 00:02:10
33, ¿estamos de acuerdo con esto? 00:02:11
ahora en mi 00:02:15
programa, cuando yo 00:02:16
programo, no puedo 00:02:18
saber si el alumno que voy 00:02:20
a trabajar 00:02:22
tiene 17, 22 00:02:23
o 33 00:02:26
No lo sé, porque dependerá cuando el usuario añadirá el alumno a mi sistema 00:02:26
A ese punto yo sabré que ese alumno tiene 22 o tiene 25 00:02:32
Pero yo tengo que programar, ¿vale? 00:02:37
Si yo quiero hacer un programa, un método 00:02:40
Que lo que hace es que me dice si el alumno es mayor de edad o menor de edad 00:02:44
¿Vale? ¿Cómo haríais vosotros, cómo implementaríais vosotros el método, dime si es mayor de edad? 00:02:51
¿Pilla la edad? 00:03:03
Si es mayor de 18, o sea 19 o más. 00:03:07
Entonces si es mayor o igual a 18, imprímeme, ¿es mayor de edad? 00:03:14
Y si no lo es. 00:03:22
Pues me imprimes es menor de edad 00:03:24
¿Están de acuerdo? Vale, ok 00:03:26
Pero esta edad 00:03:28
Cuando yo programo el método 00:03:30
No puedo usar 22 00:03:34
O 37 00:03:35
O 54 00:03:37
Tengo que usar edad 00:03:38
O sea una representación simbólica 00:03:42
De lo que será el dato 00:03:46
En el futuro 00:03:49
O sea que yo allí digo, si edad es mayor o igual a 18 00:03:52
¿Y cuánto es edad? No lo sé 00:03:57
Es una representación simbólica, es una representación extracta 00:04:00
Es cada alumno tendrá su edad con un valor concreto 00:04:05
Pero como yo estoy haciendo un método que tiene que valer para todos los alumnos 00:04:09
No puedo usar ni 17, ni 22, ni 53 00:04:12
Tendré que utilizar una palabra que representa ese dato 00:04:15
edad 00:04:20
y me basaré sobre esa edad 00:04:22
pues esa es una variable 00:04:24
¿se entiende? 00:04:26
en la realidad una variable es una zona de memoria 00:04:34
a la que asignamos 00:04:36
tres características 00:04:38
un nombre, un valor 00:04:40
y un tipo 00:04:42
¿vale? cuando creamos una variable 00:04:44
esta variable tiene que tener un nombre 00:04:46
en nuestro caso edad 00:04:48
un valor 00:04:50
en nuestro caso 17 por ejemplo para un alumno 00:04:51
O 24 por otro alumno 00:04:54
Y también lo que se llama un tipo 00:04:55
El tipo define 00:04:58
Lo veremos otra vez más adelante 00:05:00
Pero define que datos 00:05:02
Puedo meter en esa variable 00:05:04
Si mi variable 00:05:06
Es de tipo entero 00:05:08
No puedo poner gato 00:05:09
Dentro de esta variable 00:05:11
Puedo poner solo un número entero 00:05:13
Si mi variable es de tipo 00:05:15
Cadena de caracteres 00:05:18
Puedo poner gato 00:05:21
¿Sí? 00:05:22
Sígnica variables de tipo booleano 00:05:25
¿Vale? 00:05:27
Solo admite valor verdadero o falso 00:05:28
No puedo poner 7 00:05:31
No puedo poner gato 00:05:33
No puedo poner nada que no sea verdadero o falso 00:05:34
¿Sí? 00:05:38
Entonces, hay varios tipos 00:05:40
Nosotros estudiaremos unos cuantos 00:05:42
Hay boolean, float, int 00:05:43
Cada objeto será un tipo en un futuro 00:05:46
Lo veremos 00:05:50
String, etc 00:05:51
Son tipos estos de aquí 00:05:54
Y cuando yo creo una variable le tengo que decir 00:05:56
Vale, tú eres un trozo de memoria, vale, perfecto 00:05:58
¿Cómo te llamas? 00:06:01
Te llamas edad, vale, muy bien 00:06:02
Te llamas nombre, vale, te llamas dirección 00:06:04
Ese es su nombre 00:06:06
Es como yo simbólicamente te represento 00:06:07
Cuando te tengo que utilizar en mi programa 00:06:11
Te llamaré de esta forma 00:06:13
¿Vale? 00:06:15
Porque no sé qué valor tienes ahí dentro 00:06:16
En un determinado momento 00:06:18
Porque es variable ese valor 00:06:19
puede cambiar, y por lo tanto 00:06:21
yo siempre hablaré de edad 00:06:23
cada vez que quiero utilizar el valor 00:06:25
que tú tienes dentro, que podría ser 00:06:27
el mismo o podría cambiar 00:06:29
entonces su nombre 00:06:30
el valor actual 00:06:33
vale, si muy bien, y si yo te voy a buscar 00:06:35
este valor edad 00:06:37
que encuentro allí dentro, en este trozo 00:06:39
de memoria que se llama edad 00:06:41
que número está escrito 00:06:43
ese es su valor, y también 00:06:45
el tipo, de que puedo 00:06:47
poner dentro de ti, puedo poner 00:06:49
enteros, puedo poner 00:06:51
números con la coma, puedo poner 00:06:54
una frase, puedo poner 00:06:56
un verdadero o falso, puedo poner 00:06:58
un objeto, puedo poner 00:07:00
lo que sea, ¿se entienden estas 00:07:02
tres cosas? ¿dudas? 00:07:04
vale, para entenderlo 00:07:08
en cierto sentido, imagínate una 00:07:10
caja o un cajón o algo 00:07:12
que pueda contener algo, ¿vale? 00:07:14
marcamos una caja 00:07:15
en esta caja que está aquí 00:07:16
Yo le pongo una pegatina encima 00:07:19
Para identificar lo que va allí dentro 00:07:22
¿Vale? 00:07:24
Por ejemplo, le pongo 00:07:25
Edad, para nuestro ejemplo 00:07:27
O por ejemplo, le pongo nombre 00:07:30
¿Vale? Entonces asumo que dentro de esta caja 00:07:31
Lo que hay allí dentro sea 00:07:34
La edad de este 00:07:36
Usuario, de este alumno 00:07:38
Lo que sea 00:07:40
O dentro de esta caja hay el nombre 00:07:40
De este usuario, de este animal 00:07:43
De este lo que sea 00:07:46
¿Están de acuerdo con eso? 00:07:47
que es 00:07:48
el valor 00:07:51
el valor es lo que pongo dentro de la caja 00:07:53
si yo abro la caja y miro dentro 00:07:55
encontraré Estefano, porque el nombre 00:07:57
de este alumno es Estefano 00:07:59
o si yo abro la caja 00:08:01
encontraré 37, porque la edad 00:08:03
de este alumno es 37 00:08:05
y luego veremos que esta cosa 00:08:06
se puede cambiar, si yo cumplo los años 00:08:09
quito el 37, lo tiro 00:08:11
pillo 38 y lo vuelvo a poner ahí 00:08:13
¿Sí? Tengo más de 38 años 00:08:15
Y también el tipo define qué puede caber en esta caja 00:08:18
¿Vale? 00:08:28
Si esta caja está hecha para números 00:08:29
Y aquí dentro puedo poner solo números 00:08:32
No le puedo poner una tira que ponga hola 00:08:34
Porque ¿Quién lo va a abrir? 00:08:37
Se encuentra hola y dice 00:08:38
¿Y qué es hola? 00:08:40
¿Qué es hola por 5? 00:08:41
Si yo quiero hacer una operación 00:08:43
Y me pillo la edad de la multiplico por 5 00:08:44
Por alguna razón 00:08:47
Y me encuentro dentro hola 00:08:48
¿Qué operación es hacer hola por 5? 00:08:50
¿La sabéis hacer vosotros la operación hola por 5? 00:08:53
No, porque no es definida 00:08:57
¿Me explico lo que estoy diciendo? 00:08:59
Es muy complejo 00:09:02
¿Queréis que lo repita? 00:09:04
Sigo adelante y luego volvemos atrás 00:09:06
Sigo y volvemos eventualmente 00:09:08
¿Vale? 00:09:11
Por ejemplo 00:09:12
La caja edad 00:09:13
Aquí 00:09:17
Contiene 18 00:09:17
Y solo puede contener enteros 00:09:20
¿Vale? 00:09:22
¿Cómo defino en Java esta cosa? 00:09:24
O sea, quiero una caja 00:09:27
Que se llame edad 00:09:28
Que pueda contener solo números enteros 00:09:30
Y que dentro tenga 18 00:09:33
Pues así 00:09:35
Int 00:09:36
Esta es una palabra reservada que me dice 00:09:39
Estamos hablando de enteros 00:09:42
Edad, nombre de la variable 00:09:44
Es igual a 18 00:09:47
Punto y coma 00:09:50
Esta sentencia de aquí 00:09:51
Lo que me dice es 00:09:54
Estoy declarando una variable 00:09:55
Estoy creando una nueva variable 00:09:57
Un nuevo cajón, un nuevo espacio de memoria 00:09:59
Al que a partir de ahora 00:10:01
Si tú escribes edad 00:10:04
Yo sé que tengo que ir a ese espacio de memoria 00:10:06
Dentro le guardo 18 00:10:09
y que sepas que solo puedo guardar enteros allí dentro 00:10:12
si yo voy allí dentro encontraré un número 00:10:16
si alguien intenta poner algo que no es un número 00:10:18
o es un número con la coma 00:10:21
o es una palabra 00:10:23
pues yo le diré, no, aquí no puede ir 00:10:24
porque tú me has dicho que en este espacio de memoria 00:10:26
solo van enteros 00:10:29
en Java no funciona 00:10:30
en Java tienes que definir el tipo 00:10:37
Java es un lenguaje tipado 00:10:40
si no defines el tipo te dice 00:10:42
El compilador 00:10:46
Llegará aquí y te dirá 00:10:49
No puede empezar una sentencia 00:10:50
Con un identificador 00:10:52
Me falta algo 00:10:55
Si yo quiero que una palabra 00:10:56
En vez que ent 00:10:59
Tendré que poner aquí 00:11:01
El tipo que representa las palabras 00:11:02
No está 00:11:05
Está más adelante 00:11:06
Entonces, si yo he hecho 00:11:07
Int edades igual a 18 00:11:09
He creado esta nueva variable 00:11:11
Con las tres características de la variable 00:11:13
Nombre, tipo, valor 00:11:16
¿Dudas? 00:11:18
Ese valor se puede cambiar luego 00:11:22
Siendo una variable 00:11:23
Se puede cambiar 00:11:26
¿Cómo? 00:11:27
A continuación yo puedo hacer 00:11:33
Edad es igual a 19 punto y coma 00:11:34
Fijaos, no está ahí 00:11:36
No estoy declarando una nueva variable 00:11:38
Te estoy diciendo 00:11:41
Es la variable que has creado aquí 00:11:43
Que se llama edad 00:11:45
Ahora tú 00:11:46
Vete allí dentro 00:11:47
Y colocas 19 00:11:49
Le estoy cambiando el valor 00:11:51
Estoy machacando el valor que estaba antes 00:11:53
¿Vale? Si en este trozo de memoria 00:11:56
Estaba escrito 18, ese 18 lo he perdido 00:11:57
No lo puedo recuperar 00:12:00
Y he sobrescrito ese 18 00:12:01
Con un 19 00:12:04
Si pongo int, ¿qué me haría? 00:12:05
Error 00:12:11
¿Por qué error? 00:12:12
Porque me dice 00:12:12
Ya has creado un trozo de memoria 00:12:15
Que se llama edad 00:12:17
Si tú empiezas a llamar varios trozos de memoria 00:12:18
Edad, y luego me dices, pilla edad 00:12:21
¿Cuál pillo de los 10 que has identificado? 00:12:23
La estás declarando y no te estás dándole un valor 00:12:25
Cuando yo le doy el tipo también delante 00:12:27
La primera vez que la uso 00:12:30
Y es para crearla 00:12:31
Esto crea una variable 00:12:33
Ahora lo veremos también otra vez 00:12:35
Esto modifica una variable ya existente 00:12:36
Si yo aquí vuelvo a poner int 00:12:40
Se enfada, me dice, no, mira, existe ya 00:12:42
Una variable que se llama edad 00:12:44
Si yo aquí no pongo int 00:12:45
Se enfada, porque dice, en ningún lado 00:12:47
Has creado una variable, un trozo de memoria 00:12:50
Que se llama edad, por lo tanto, ¿qué tengo que hacer yo? 00:12:52
¿Sí? 00:12:56
Por aquí puede haber dos problemas 00:12:56
Puedo crear, puedo usar 00:12:58
Una variable que no he creado 00:13:00
Antes, error 00:13:02
O puedo intentar 00:13:03
Crear otra vez una variable 00:13:05
Que ya está creada, error 00:13:08
Ahora, si yo intento hacer que edad es igual a salmón 00:13:09
Pues error 00:13:18
Me dice, no 00:13:20
Porque esto no es un número 00:13:22
Y tú me has dicho que en esta caja solo van enteros 00:13:24
Y esto, por cuanto me esfuerce, no es un entero 00:13:27
Dudas? 00:13:31
Preguntas? 00:13:35
Otra variable que puede tener palabras 00:13:43
Que sea tipo de pescado 00:13:46
String, que es la palabra 00:13:49
Tipo de salmón de pescado 00:13:51
Igual salmón 00:13:54
Perfecto, ahora lo veremos 00:13:55
Pero por ahora 00:13:57
Nosotros, tipo int 00:13:59
Enteros, numeritos 00:14:01
Float 00:14:03
Double, admite el número con coma 00:14:08
¿Cuánto puedo almacenar en una variable? 00:14:13
Depende del tipo de variable 00:14:16
¿Vale? 00:14:17
Ahora veremos los tipos 00:14:18
Cada tipo tiene un rank 00:14:19
Un int hasta 2 a la 32 00:14:20
4.000 millones 00:14:24
Desde menos 2.000 millones hasta más 2.000 millones 00:14:27
No me acuerdo exactamente, pero un rango de ese estilo 00:14:34
Si no me equivoco son 32 bits un int 00:14:36
A lo mejor son 16, no lo sé, no me acuerdo 00:14:41
Va después la diapositiva que lo dice 00:14:44
Pero cada tipo tiene asociado un número de dígitos binarios que lo representan 00:14:46
Cuánta memoria tiene 00:14:51
Entonces hay algunos que pueden contener solo 8 bits 00:14:53
Entonces son 256 posibles valores 00:14:58
Hay algunos que pueden tener 16 bits 00:15:01
Entonces son 65.536 posibles valores 00:15:04
Hay uno que está a 32 bits 00:15:08
El double es doble precisión porque tiene 64 bits 00:15:10
Hasta 2 a la 64 00:15:15
Que es un número bastante grande 00:15:17
Valores posibles 00:15:18
Y así es 00:15:20
Ahora hablaremos también de esto 00:15:22
Cuando hablamos de tipos de variables 00:15:25
Hablaremos de esto 00:15:27
Por ahora me interesa entender 00:15:28
¿Qué es una variable? 00:15:30
Pues eso, un cajón donde guardo los datos 00:15:32
En el que tengo que definir 00:15:34
Su nombre, el valor 00:15:36
El tipo 00:15:39
¿Vale? 00:15:42
Entonces, ¿cuándo defino el nombre de una variable? 00:15:43
¿Cómo puedo? O sea, ¿puedo elegir cualquier nombre? 00:15:50
Primero sabemos perfectamente que no puedo usar palabras reservadas 00:15:54
No puedo hacer int static es igual a 3 00:16:00
Porque static es una palabra reservada del sistema 00:16:05
No puedo utilizarla como nombre 00:16:09
Intvoid 00:16:12
Intpublic 00:16:14
Letras que puedo utilizar 00:16:17
Todas de la A a la Z 00:16:24
Mayúsculas y minúsculas 00:16:25
¿Puedo usar números? 00:16:27
Sí, puedo usar números 00:16:29
También puedo usar guión bajo o dólar 00:16:30
Para los nombres de variables 00:16:33
Estos 00:16:36
No se suelen utilizar en Java 00:16:37
En otros lenguajes de programación 00:16:40
Todas las variables empiezan por 00:16:43
Por dólar, por ejemplo 00:16:44
O en otros 00:16:46
Hay formas 00:16:48
De llamar las variables de varios tipos 00:16:51
Hay algunos 00:16:53
Algunos métodos que te dicen 00:16:53
Que cuando tú creas una variable 00:16:56
El nombre de la variable tiene que incluir el tipo 00:16:58
O sea, tú dices int 00:17:00
Int guión bajo edad 00:17:02
Es igual a 3 00:17:05
Para que cuando tú uses esa variable 00:17:06
Siempre sepas su tipo 00:17:09
Hasta si no está escrito, porque si os fijáis aquí 00:17:10
La primera vez 00:17:12
Que vosotros 00:17:15
Creáis una variable 00:17:17
Estáis diciendo el tipo 00:17:18
Pero si ahora aquí hay un millón de líneas de código 00:17:20
Y luego uso edad 00:17:22
La segunda vez que uso edad 00:17:24
Nos está diciendo que tipo es 00:17:25
¿Vale? 00:17:27
Si yo aquí en el nombre le he puesto 00:17:29
Int-bajo edad 00:17:31
Sé que cuando voy a reutilizar el nombre 00:17:33
Int-bajo edad sé que es un int 00:17:35
¿Vale? 00:17:37
Pero bueno, eso 00:17:39
Luego se complica porque es un 00:17:40
Rollo siempre escribir 00:17:43
Int guión bajo o string guión bajo 00:17:45
Y todas las variables se llaman iguales 00:17:47
Porque empieza con int guión bajo 00:17:49
¿Vale? Por ahora 00:17:50
Entonces, esto es olvidáoslo 00:17:52
Cuando yo tengo que elegir 00:17:55
Un nombre, ¿vale? 00:17:57
Uso letras y números 00:17:59
No puede ser 00:18:01
Una palabra reservada 00:18:03
¿Vale? 00:18:06
No puede comenzar por número 00:18:07
O sea, int edad 1 00:18:09
Igual a 19 00:18:12
Perfecto, int apellido 1 00:18:14
Es igual, no, int no 00:18:17
String apellido 1 es igual a no sé qué 00:18:18
String apellido 2 es igual a no sé qué 00:18:21
Vale 00:18:23
Pero 1 apellido no 00:18:23
Siempre la primera 00:18:26
Tiene que ser una letra 00:18:30
No puede ser un número 00:18:32
No puede ser una palabra reservada 00:18:33
son case sensitive 00:18:38
no es lo mismo 00:18:41
edad minúscula 00:18:43
que edad con la E mayúscula 00:18:44
que edad con la D mayúscula 00:18:47
al final 00:18:49
que edad todo mayúsculo 00:18:49
son nombres distintos 00:18:52
y que cuando es una variable 00:18:53
la primera letra 00:18:57
de la variable va en minúscula 00:18:59
¿se acordáis? 00:19:01
nombre de clase 00:19:03
primera letra mayúscula 00:19:04
nombre de 00:19:06
variable, primera letra 00:19:08
minúscula, así cuando yo veo un nombre 00:19:10
ya tengo una idea de si es 00:19:12
una clase o una variable 00:19:14
y finalmente 00:19:16
lo que hemos dicho antes, cuando 00:19:20
tengo que 00:19:22
juntar varias 00:19:24
palabras para hacer 00:19:26
un nombre, hago una cosa de ese estilo 00:19:28
fecha de nacimiento 00:19:30
pongo fecha, empiezo en minúscula 00:19:32
Y cada palabra siguiente le pongo una mayúscula 00:19:34
Otra opción podría ser esta 00:19:38
Que Java lo reconoce 00:19:40
Pero el estilo de Java no es esto 00:19:45
No se suele hacer esto 00:19:48
¿Lo podéis hacer? 00:19:50
Sí 00:19:51
¿Funciona? 00:19:51
Sí 00:19:52
¿Se aconseja hacerlo? 00:19:52
¿Dudas? 00:19:55
Sin caracteres demoníacos 00:20:10
Sin usar palabras reservadas 00:20:13
estas las tenéis aquí, tanto 00:20:16
os pasará alguna vez que pondréis 00:20:17
un número raro 00:20:20
y luego cuando me lo enseñáis, yo os diré 00:20:21
mira, esto mejor que no lo pongas, este de aquí 00:20:24
mira, se ha hecho esta variable, pero las cuesta mayúsculas 00:20:26
debería ser minúsculas, y con el 00:20:28
tiempo y con el pasar del tiempo, pues 00:20:30
empezaréis a recordaros 00:20:32
estas cosas, ¿vale? tampoco 00:20:34
son tan complejas, es solo que 00:20:35
lo oyes la primera vez y dices 00:20:38
que me cuentas 00:20:40
a la quinta vez que programáis, pues ya está 00:20:41
¿vale? 00:20:44
Entonces, el nombre es 00:20:45
Concepto de literal 00:20:46
Cuando se habla de literal 00:20:49
Se habla de un valor concreto 00:20:52
¿Vale? 00:20:55
No una variable 00:20:57
Sino uno de los posibles valores 00:20:58
Que puedo guardar en una variable 00:21:01
Por ejemplo 00:21:03
Tres 00:21:04
Entendido como el número tres 00:21:06
El entero tres 00:21:09
Es un literal de tipo int 00:21:10
¿Eh? 00:21:13
Tres así 00:21:19
¿Entendido? 00:21:23
Como el número entero tres 00:21:25
No es un literal de tipo string 00:21:27
Es un literal de tipo int 00:21:29
La cadena gato 00:21:31
Es un literal 00:21:38
Es un valor concreto 00:21:44
Pero no de tipo int 00:21:47
Será de tipo string 00:21:49
El carácter A 00:21:51
Fijaos 00:21:59
No doble comillas 00:22:00
Sino comillas 00:22:02
Es un literal 00:22:04
De tipo char 00:22:06
Carácter 00:22:08
Porque es de tipo char 00:22:10
No de tipo string 00:22:15
Si pusiera doble comillas 00:22:16
Sería un literal 00:22:18
De tipo string 00:22:20
9,993 00:22:21
Es un literal 00:22:27
Pero no de tipo int 00:22:30
Tampoco de tipo char 00:22:32
Tampoco de tipo string 00:22:34
De tipo 00:22:36
Double 00:22:39
O float 00:22:40
Cada tipo 00:22:41
Tiene su conjunto de literales 00:22:45
Los literales son 00:22:49
Aquellos valores que yo puedo poner 00:22:50
En un determinado tipo 00:22:53
Si yo estoy hablando de enteros 00:22:54
Todos los enteros son literales 00:22:58
Para tipo entero 00:22:59
Si yo estoy hablando de string 00:23:00
Los literales de tipo string son todas las palabras 00:23:03
Los literales 00:23:05
Se pueden guardar en variables 00:23:09
Cuyo tipo lo permita 00:23:11
Para pensar 00:23:13
Si yo quiero guardarla 00:23:17
En una variable 00:23:30
Esta variable, ¿qué tipo tiene que tener? 00:23:31
Int 00:23:33
¿Todos de acuerdo? 00:23:35
String 00:23:41
Pregunta 00:23:46
¿Este es el número 3? 00:23:51
Esta es la palabra 00:23:55
Formada por el símbolo 3 00:23:58
Este es el carácter 3 00:24:01
Es una letra 00:24:19
Los string es una secuencia de char 00:24:33
Sin complicarnos demasiado 00:24:36
¿Esto qué es? 00:24:40
¿Esto qué es? 00:24:48
String 00:24:50
¿Y esto qué es? 00:24:50
Error 00:24:55
No existe el carácter 32 00:24:56
Existe el carácter 3 00:24:59
Existe el carácter 2 00:25:01
Ya veremos 00:25:02
Esto yo tendría 00:25:10
El carácter 3 00:25:13
Y el carácter 2 00:25:15
Y si quiero los puedo juntar 00:25:17
Y el resultado sería esta cosa allí 00:25:19
Un string 00:25:22
Pero no 00:25:23
Por ahora me interesan los literales 00:25:24
Estamos viendo los literales 00:25:27
¿Se entienden los literales? 00:25:28
Entonces dependiendo de los tipos 00:25:30
Que tenga, ¿Qué tipos hay? 00:25:33
Lo veremos. Por ahora estamos trabajando con enteros, palabras y una letrerita. 00:25:34
Bueno, no es una letra porque esto también es un char, y no es una letra, un símbolo. 00:25:42
Estos se van de la mano porque esto es una secuencia de esto. 00:25:51
Vale, fenomenal. 00:25:59
Esto tiene también sentido 00:26:04
Porque 00:26:08
A que estos 00:26:08
No sabéis hacer 00:26:13
Estos 00:26:15
No sabéis hacer 00:26:20
¿Esto qué es? 00:26:23
Un resto 00:26:31
¿Cuánto vale? 00:26:31
Uno 00:26:33
Porque es el número tres 00:26:34
Al que resto 00:26:36
El número dos 00:26:38
Resultado uno 00:26:39
Es matemática, son números 00:26:41
Esto es la palabra 3 menos la palabra 2 00:26:43
Es como si os dijera gato menos cocodrilo 00:26:50
No está definida la función menos, la operación menos entre palabras 00:26:53
Por lo tanto, no 00:27:04
Mismo dividido 00:27:06
Casa dividido 00:27:10
Coche 00:27:14
¿Cuánto hace? 00:27:17
No sé, no existe 00:27:19
No, me aventuro en el más 00:27:21
Porque el más sí existe 00:27:25
Pero lo veremos más adelante 00:27:26
¿Dudas? 00:27:28
¿Dudas? 00:27:42
¿Se entiende que es un literal? 00:27:44
Los literales me sirven para 00:27:46
Escoger los valores correctos 00:27:47
Para ponerlo dentro de las variables 00:27:49
Una vez que he definido el tipo de una variable 00:27:51
Dentro podrán ir solo literales 00:27:53
De ese tipo 00:27:56
¿Justo? 00:27:56
¿Dudas? 00:28:01
Entonces, variables 00:28:03
¿Qué tipos hay? 00:28:04
Vamos a ver 00:28:08
Así 00:28:09
Boolean 00:28:11
¿Vale? 00:28:15
Que será Boolean 00:28:17
En Java 00:28:19
Si yo creo una variable boolean 00:28:20
Dentro pueden ir solo dos valores posibles 00:28:24
Verdadero o falso 00:28:28
Luego como se define un verdadero o falso 00:28:31
Depende del lenguaje de programación 00:28:36
En C por ejemplo falso es cero 00:28:38
Y cualquier otro número es verdadero 00:28:40
Pero eso no me interesa 00:28:42
Yo cuando voy a trabajar aquí 00:28:44
Solo usaré dos literales que son true 00:28:46
o false 00:28:50
esos son los únicos dos literales 00:28:51
que puedo utilizar 00:28:54
si yo creo una variable 00:28:55
boolean 00:28:59
en java 00:29:01
¿cuánta memoria me ocupa? 00:29:03
un byte 00:29:06
¿vale? 00:29:07
8 bits 00:29:09
cada vez que yo hago boolean x es igual a true 00:29:10
estoy ocupando 8 bits 00:29:14
¿lo das? 00:29:16
Está claro que esto puede ser más complejo. El booleano viene del álgebra de Boole, que es toda la álgebra que tiene que ver con condiciones, con sentencias que sean verdaderas o falsas. 00:29:20
Por ejemplo, tres menores que siete, este señor de aquí, ¿qué es? 00:29:39
El resultado de esta cosa aquí, ¿qué es? 00:29:48
True. 00:29:52
O sea, que esta es una expresión booleana. 00:29:56
El resultado de, mientras esta de aquí es una operación algébrica, tres más siete, ¿vale? 00:30:00
3 menor que 7 00:30:10
es booleana 00:30:12
esto devuelve un entero 00:30:15
una operación 00:30:17
este de aquí devuelve si es verdadero o falso 00:30:18
si 3 es menor que 7 00:30:21
será true 00:30:23
si 3 no es menor que 7 00:30:24
será false 00:30:26
entonces 00:30:27
en las variables booleanas 00:30:30
yo podré guardar 00:30:33
cualquiera 00:30:35
que sea una expresión booleana 00:30:36
Cuyo resultado sea true o false 00:30:38
No solo true o false como literal 00:30:40
Pero esto más adelante 00:30:43
Por ahora estamos viendo los tipos 00:30:45
Vamos pasito a pasito 00:30:48
Entonces está el tipo booleano 00:30:50
Todos de acuerdo con el tipo booleano 00:30:52
Idea de donde se puede utilizar 00:30:54
El tipo booleano 00:30:57
¿Os acordáis todas las veces que 00:30:58
En nuestros pseudocódigos o en nuestros algoritmos 00:31:03
Hemos dicho si 00:31:05
Esto es verdadero 00:31:07
y entonces salgo 00:31:09
y está aquí lo que va dentro 00:31:11
del sí 00:31:13
que será 00:31:14
pero lo veremos 00:31:15
tipo booleano, verdadero o falso 00:31:20
tipo carácter 00:31:25
es un carácter 00:31:27
singolo, una letra, un número, un símbolo 00:31:29
o cualquier cosa de ese tipo 00:31:31
en Java 00:31:33
es char 00:31:35
vale, y ocupa 00:31:36
dos bytes 00:31:39
16 bits, es decir 00:31:40
que se pueden 00:31:43
tratar 00:31:44
se pueden trabajar con máximo 00:31:47
2 elevado a la 16 00:31:49
posibles caracteres 00:31:51
distintos 00:31:53
yo tendré tiras 00:31:54
de 16 bits 00:31:57
secuencias de 16 bits 00:31:58
que interpretados por el 00:32:00
ordenador me darán 00:32:03
un determinado carácter 00:32:05
por ejemplo 00:32:07
no es verdad, me lo invento 00:32:08
el número, la secuencia 00:32:10
1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, es la letra A mayúscula, ¿sí?, y no hay un máximo, vale, estos, cuando yo estoy, los booleanos hemos dicho True Force, los carácteres son estos que hago con la comilla simple, con el apóstrofe, apóstrofe, apóstrofe, ¿vale?, 00:32:13
Luego 00:32:42
Tipos 00:32:45
Otro tipo, byte 00:32:47
Un byte 00:32:49
Es un número de 8 bits 00:32:51
Los bytes, este tipo de aquí 00:32:54
Nosotros lo veremos muy poco 00:33:00
Hasta final de curso quizás 00:33:02
Salen 00:33:04
Cuando yo empiezo a tener que hacer cosas 00:33:05
Como leer ficheros 00:33:08
Entonces lo voy leyendo byte por byte 00:33:10
O leer cosas que llegan desde internet 00:33:13
Por la tarjeta de red 00:33:16
Entonces voy leyendo byte por byte 00:33:18
Pero nosotros lo utilizaremos recientemente 00:33:20
Sepáis que los bytes son grupos de 8 bits 00:33:25
Y que tienen una representación numérica 00:33:28
Yo puedo pillar estos 8 bits y decir 00:33:31
Pero ¿cuánto vales tú? 00:33:33
El discurso es que con 8 bits 00:33:35
Puedes hacer máximo 256 valores 00:33:37
Desde menos 128 hasta más 127 00:33:39
Por ejemplo, un byte podría ser un tipo de dato que utilizo para una edad 00:33:45
Porque gente que supera los 127 años, pues son pocos 00:33:55
Si os fijáis, son 8 bits 00:34:00
Serían 2 elevado a la 8 00:34:07
2, 3, 4, 5, 6, 7 00:34:12
4 y 4, 8 bits 00:34:15
Aquí van ceros y unos 00:34:18
Son 2 elevado a la 8 00:34:20
Que es 256 posibles números 00:34:23
Pero el primer bit este de aquí 00:34:27
Me dice si es positivo o negativo 00:34:29
Si este es 1, es positivo 00:34:32
Si es de 0 es negativo 00:34:35
Por lo tanto 00:34:37
Los números que puede hacer 00:34:40
En realidad son solo 7 bits 00:34:42
Son 7 bits de números 00:34:44
Más si es positivo o negativo 00:34:46
Y por lo tanto 00:34:48
2 a la 7 son 00:34:49
128 00:34:51
De 0 a 127 00:34:52
Números positivos 00:34:56
Y de menos 1 a menos 128 00:34:58
Números negativos 00:35:01
Y si este rango es demasiado pequeño 00:35:01
Y necesito algo un poquito más grande 00:35:13
Pues tengo los tipos short 00:35:16
Que son números un poquito más grandes 00:35:18
Porque en vez de ocupar un solo byte 00:35:21
Ocupan dos bytes 00:35:23
En memoria 00:35:25
En vez de tener 8 bits 00:35:26
Tengo 16 bits 00:35:28
Del que el primero 00:35:30
Es el que me dice si es positivo o negativo 00:35:31
Y todos los demás 15 00:35:34
O sea, 2 a la 15 son los posibles valores 00:35:36
Por lo tanto, ahora voy de 00:35:38
Menos 32.768 00:35:40
Hasta 32.767 00:35:43
Este es el rango 00:35:46
De números 00:35:48
En serio, si hago dos bytes 00:35:49
Un byte más otro byte 00:36:02
Y uno es 127 y otro es 127 00:36:04
¿Qué pasa? 00:36:06
Porque si tú marcas 00:36:11
Un 1 aquí 00:36:14
Porque el 0 00:36:15
Es considerado como positivo 00:36:18
Entonces vas de 0 00:36:20
A 127, son 128 00:36:22
Todos son 256 00:36:24
La mitad serían 128 valores 00:36:26
¿Vale? 00:36:28
En positivo tienes de 0 a 127 00:36:29
Porque son 128 valores 00:36:32
Si tú contas 00:36:34
0, 1, 2, 3, 4 00:36:35
Cuando llegas a 127 has contado 128 valores posibles 00:36:37
En negativo 00:36:41
No empieza de 0 00:36:42
Empieza de menos 1 00:36:43
Entonces acaba en menos 127 00:36:44
Como es implementado 00:36:46
No lo sé 00:36:53
Pero el discurso es que un bit 00:36:53
Te está diciendo si es positivo o negativo 00:36:57
Probablemente el 0 00:36:59
Imagínate, me lo invento 00:37:01
El 0 son todos 0 00:37:03
Este es 0 00:37:04
¿Quieres hacer 127? 00:37:07
Esto 00:37:10
127 00:37:11
¿Quieres hacer menos 1? 00:37:13
o será 00:37:17
así, será menos 1 00:37:23
no sé 00:37:25
y entonces con esto puedes llegar a 00:37:26
que será menos 128 00:37:29
porque no se corresponde esto con el 0 00:37:31
con este de aquí le restas 1 00:37:34
no sé si lo ves 00:37:35
así 00:37:36
o al revés, da igual, al fin y al cabo son 00:37:37
fáciles 00:37:41
son binarios, si esto 1 y este 0 00:37:41
los cambias y dices que el 0 00:37:46
lo haces así, o sea, como lo decía 00:37:48
yo antes, no lo sé cómo está implementado, me da igual 00:37:50
¿vale? el rango es este 00:37:52
¿sí? 00:37:54
entonces, necesito un rango 00:37:56
un pollo más grande, voy al short 00:37:58
necesito un rango todavía más grande 00:37:59
porque estos números son demasiado pequeños 00:38:02
por ejemplo, estoy hablando de mi sueldo 00:38:04
entonces, 32.768 euros 00:38:06
al mes se me quedan 00:38:09
cortos, pues entonces voy al 00:38:10
int 00:38:12
¿vale? porque menos de un millón al mes 00:38:12
rechazáis el trabajo 00:38:15
Aquí está 00:38:17
¿Vale? 00:38:20
Puntito, puntito, puntito 00:38:21
Dos mil millones 00:38:23
Desde menos dos mil millones 00:38:24
A más dos mil millones 00:38:27
Dos a la treinta y dos 00:38:28
¿Vale? 00:38:31
Del que el primero es positivo y negativo 00:38:32
Y dos a la treinta y uno 00:38:34
Es este número de aquí 00:38:36
¿Dudas? 00:38:38
Y que esto se me queda 00:38:44
Se me queda pequeño porque ya son 00:38:46
Un par de años que trabajo 00:38:48
Entonces dos mil millones de euros al mes 00:38:50
Es poco 00:38:52
Pues voy a long 00:38:53
Long son siempre enteros 00:38:55
Estamos siempre hablando de enteros 00:38:58
Pero ahora son enteros de ocho bits 00:39:00
Ocho bytes, perdón 00:39:02
O sea, ocho por ocho 00:39:04
Sesenta y cuatro bits 00:39:06
Dos elevado a sesenta y cuatro 00:39:08
Números bastante grandes 00:39:10
Oye, ¿por qué todo esto? 00:39:12
Nosotros 00:39:21
Normalmente usamos los bits 00:39:21
En determinados casos 00:39:23
En que vamos a números muy grandes 00:39:26
Imaginaos que tenéis que contar 00:39:28
Milisegundos o nanosegundos 00:39:30
De una operación y cosas por el estilo 00:39:33
Entonces salen números muy grandes 00:39:34
Pues entonces puede llegar a un long 00:39:36
¿Sí? Ahora 00:39:38
¿Por qué uso int, short, byte 00:39:40
O otras cosas? 00:39:42
Pues tenéis que tener en cuenta que en algunas 00:39:43
Situaciones, a lo mejor 00:39:46
Lo que ocupo en memoria 00:39:48
Es relevante, en un ordenador 00:39:49
A lo mejor no, pero si estoy en un cacharro wearable que tiene muy poca memoria y cualquier memoria que uso tiene que ser optimizada al máximo y solo uso números de este rango, por alguna razón, no tiene sentido que ponga un int y ocupe 4 bytes por cada variable que uso cuando solo necesito un byte. 00:39:52
En una variable de tipo int 00:40:14
Cabrían hasta 4 variables de tipo val 00:40:19
2 a la 63 son 00:40:22
2 a la 64 posibles valores 00:40:40
Pero van de menos a más 00:40:42
Si tú contas desde menos este número 00:40:45
A más este número 00:40:48
Te encuentras 2 a la 64 valores distintos 00:40:50
Pero lo que se usa 00:40:53
Es el primer bit 00:40:55
Se usa para saber si es positivo o negativo 00:40:57
Entonces en vez de llegar al extremo máximo 00:40:59
Lo que estás haciendo es este número 00:41:01
Trasladarlo y pillar un poco negativo 00:41:03
Un poco positivo 00:41:05
¿Dudas? 00:41:06
Todo esto son enteros 00:41:10
¿Si? 00:41:12
Y si quiero con la goma 00:41:15
Pues tengo 00:41:17
Estos dos señores de aquí 00:41:18
Float y double 00:41:21
Float 00:41:23
Va de menos 3.4 por 10 a la 38 00:41:24
Hasta 3.4 por 10 a la 38 00:41:30
¿Vale? 00:41:33
Mientras que el double 00:41:35
Double significa doble precisión 00:41:36
¿Vale? 00:41:39
Son números más precisos 00:41:40
Puedo tener más decimales 00:41:41
Va a esta cosa de aquí 00:41:44
Y esta cosa de aquí 00:41:46
El discurso es que 00:41:47
Mientras con los enteros 00:41:49
Más o menos lo podemos entender 00:41:52
Si pensamos en binario 00:41:54
Con esto 00:41:55
Es un poco distinto 00:41:57
Porque esto se divide 00:42:00
Una parte de byte que son un exponente 00:42:01
Y otra parte de byte que son 00:42:04
La base 00:42:06
Y entonces 00:42:08
Estos números en realidad por dentro 00:42:09
Son representados como un número 00:42:12
Elevado a no se cuanto 00:42:13
Entonces me permite hacer 00:42:15
Más combinaciones pero es más complejo 00:42:17
De entender como funciona 00:42:19
Pero me da igual, lo hace Java 00:42:20
A mí me da igual, yo escribo 3.7 00:42:23
Y le digo que es un float 00:42:26
Y yo lo único que me tengo que encargar 00:42:27
Es que no puedo poner un 3.7 dentro de un long 00:42:29
Si yo creo una variable long 00:42:32
Y le pongo dentro 3.7 00:42:35
Me dice no 00:42:36
Dudas 00:42:37
Preguntas 00:42:41
Estos de aquí 00:42:44
Y posiblemente algunos más 00:42:48
No lo sé, diría que no 00:42:50
Pero puede ser que algunos se me hayan colado 00:42:51
Son lo que se llaman tipos de datos primitivos 00:42:53
Todas estas son palabras reservadas 00:42:58
Byte, boolean, int, long 00:43:06
No lo puedo utilizar como nombres 00:43:09
Ni de variable, ni de método, ni de nada 00:43:12
Y se llaman tipos de datos primitivos porque no son objetos 00:43:15
Son tipos de datos básicos 00:43:22
Veremos en un futuro que yo puedo crear variables de tipo objeto 00:43:24
Entonces eso no son tipos de datos primitivos 00:43:30
Por ahora, olvidaos esto 00:43:33
Y mantenéos sobre el concepto que estos son los tipos de datos primitivos 00:43:35
Los tengo que conocer 00:43:39
El viernes más 00:43:40
Autor/es:
Stefano Chiesa
Subido por:
Stefano C.
Licencia:
Reconocimiento
Visualizaciones:
12
Fecha:
26 de septiembre de 2023 - 20:20
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
43′ 50″
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:
73.70 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid