Saltar navegación

Java Básico 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 22 de septiembre de 2025 por Stefano C.

7 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, entonces, voy a grabar esta clase, por lo tanto, si habláis, me dais el consentimiento a grabar vuestra voz. 00:00:00
Dicho esto, vamos a ver hoy un concepto muy importante de la programación. 00:00:08
Este concepto es relativamente sencillo, ¿vale? No es un concepto muy complejo. 00:00:15
Pero, para aquellos de vosotros que no han programado nunca, puede que sea un poco novedoso. 00:00:21
Y la forma básica, así, cuando esto se complica un poquito y se empiezan a hacer un uso un poquito más avanzado de variables, o se empiezan a poner, spoiler del futuro, objetos dentro de las variables, vosotros empezáis a sufrir y perder el concepto de variable, ¿vale? 00:00:28
Entonces, intentad escuchar y aprender. 00:00:49
Y en cualquier momento, por favor, si no entendéis o no es claro lo que se está diciendo, 00:00:53
paradme y yo, encantado, me invento otro ejemplo o intento deciros lo de atrás. 00:00:58
Entonces, ¿qué es una variable? 00:01:05
La variable son representaciones simbólicas de los datos. 00:01:08
Son una zona de memoria a la que asignamos un nombre, un valor y un tipo. 00:01:13
Es decir que en vez de tener el número 5 o el número 72, yo tendré una representación simbólica de este número. 00:01:17
Que no sé exactamente qué número es porque puede variar. 00:01:33
Imaginaos un programa que pide al usuario cuántos años tienes y el usuario pone un número. 00:01:38
yo no sé qué número va a poner 00:01:45
yo como programador 00:01:48
sé que me dará un número 00:01:49
pero no sé qué número me va a poner 00:01:51
entonces, para poder usar 00:01:53
ese número después 00:01:55
y imprimir, muy bien, tienes 00:01:57
tu número, años 00:01:59
pues yo necesito este número 00:02:01
llamarlo de alguna forma 00:02:03
porque no es el número 7, no es el número 24 00:02:05
no es 00:02:08
es un número 00:02:09
entonces le tengo que dar un nombre 00:02:10
una representación simbólica. Entonces, por ejemplo, lo llamaré edad. A este punto yo le diré al usuario 00:02:13
dame tu número, dame tu edad, el valor que me da él, veremos cómo, de alguna forma mágica, lo guardaré 00:02:21
en esta variable, en esta zona de memoria, en esta representación de este dato, y a partir de ahora 00:02:28
en mi programa, cada vez que yo usaré 00:02:37
la palabra, o sea, 00:02:39
el identificador, edad, 00:02:40
no me estoy refiriendo a un número concreto, 00:02:43
pero sí me estoy refiriendo a aquel número 00:02:45
que el usuario me ha dado. 00:02:47
¿Sí? Es, 00:02:51
en un cierto sentido, sí parecido 00:02:52
a la X 00:02:54
de las funciones que habéis visto 00:02:55
alguna vez en matemática, 00:02:58
en bachillerato, barra, no sé si cuarta es la S, 00:03:00
cuando haces F de X es igual 00:03:02
a X más 5. 00:03:04
¿Vale? ¿Cuánto vale X? 00:03:06
lo sé 00:03:08
es un valor 00:03:10
que luego ya asociaré 00:03:12
y por x es igual a 1 00:03:14
pues mi función vale 6 00:03:16
porque 1 más 5 es 6 00:03:17
por x es 3 00:03:19
mi función valdrá 8 00:03:20
porque 5 más 3 es 8 00:03:22
pero como yo no sé 00:03:24
qué número me vas a pedir 00:03:26
pues entonces pongo x 00:03:27
x es una representación simbólica 00:03:28
de ese dato 00:03:31
¿se entiende? 00:03:31
vale 00:03:35
ahora 00:03:35
más informáticamente 00:03:36
la variable es un trozo de memoria nosotros tenemos la ram vale tenemos dos memorias en 00:03:38
el ordenador la rama y el disco duro disco duro sirve para almacenar las cosas que cuando apagó 00:03:46
el ordenador el orden siendo sigan allí mientras la rama es una cosa que cuando apago el ordenador 00:03:51
se borra entera y cuando la diciendo copio allí los datos porque la rama es más rápida entonces 00:03:56
cuando voy a utilizar la RAM, mi ordenador 00:04:02
funciona mejor. 00:04:04
Entonces, nosotros 00:04:06
hasta 00:04:08
mayo 00:04:08
no vamos a usar la memoria secundaria, 00:04:10
no vamos a usar la memoria 00:04:14
de disco. 00:04:16
Aparte que para guardar los puntos Java. 00:04:18
No accederemos a fiches. 00:04:20
Sin embargo, sí vamos a usar la memoria 00:04:24
principal, la memoria RAM, que es 00:04:26
donde se guardan 00:04:28
estas variables. Cuando yo arranco 00:04:29
el programa y le doy el botón verde del eclipse el eclipse me hace dos cosas primero me lanza una 00:04:32
instancia de la java virtual machine intérprete que será un proceso que funciona y luego a este 00:04:38
proceso le pasa como parámetro mi clase vale mi punto clas para que se ejecute si este proceso 00:04:45
tendrá un espacio de memoria y en esta memoria es donde yo creo mis variables dudas hasta aquí 00:04:53
entonces una variable es un trocito de memoria grande lo que tiene que ser grande dependiendo 00:05:02
del tipo de variable que es será más grande o más pequeño hay variables que ocupan muy poco 00:05:09
y variables que ocupan mucho ahora yo tengo la memoria quiero crear una variable entonces el 00:05:15
sistema lo que me hace es este trocito de memoria un trocito vale lo voy a reservar para ti para que 00:05:23
sea para que tú puedas escribir allí dentro valores ahora pero para ello poder identificar 00:05:31
para poder usar este trozo de memoria le tengo que dar un nombre entonces tengo que elegir un 00:05:40
identificador mal para decir cada vez que yo utilizaré este identificador me estoy refiriendo 00:05:46
a lo que está dentro de ese trocito de memoria que tú me has reservado en nuestro caso de la 00:05:53
por ejemplo, ya lo he dicho antes, edad, ¿vale? 00:06:00
Si yo he llamado este trozo de memoria edad, cada vez que usaré edad, 00:06:03
lo que te estoy diciendo es vete a un trozo de memoria que se llame edad, 00:06:07
que yo haya llamado edad o que yo haya definido como identificador edad, 00:06:11
y mírame qué hay allí dentro. 00:06:15
¿Y qué hay allí dentro? 00:06:17
Pues habrá un valor, ¿sí? 00:06:18
Un valor actual de esa variable, que increíblemente puede variar. 00:06:21
Por eso se llama variable. 00:06:29
Si yo tengo mi edad y de repente cumplo años, el valor que se contenía allí se le puede sumar uno y volver a guardarlo en ese trozo de memoria. 00:06:31
A partir de ahora, cada vez que yo voy a buscar esta edad, esta inferioridad, voy a ese trocito de memoria y encontraré un valor distinto. 00:06:44
La tercera cosa que caracteriza una variable es el tipo. 00:06:56
Cuando yo digo, oye, mira, resérvame un trozo de memoria, y este trozo de memoria lo voy a llamar edad, le tengo que decir también al sistema qué puedo guardar allí dentro. 00:07:01
No sólo lo que guardo, sino qué puedo guardar. 00:07:15
Por ejemplo, si es una edad, le diré que este trozo de memoria puede contener enteros, porque la edad es un entero. 00:07:20
Si fuera la circunferencia de un círculo, pues entonces a lo mejor en vez de enterros le diría puedes guardar números decimales, o sea que puedan tener la coma. 00:07:29
Si en vez de eso fuera un trozo de memoria donde le voy a poner una palabra, le voy a poner mi nombre, por ejemplo, pues le diría, oye, mira, aquí dentro se guardarán carácteres, se guardarán palabras, no se guardarán números. 00:07:44
Pero en cualquier caso, cuando creo una variable, le tengo que decir estas tres cosas. 00:07:59
Cómo se llama esta variable, su nombre, su identificador, 00:08:05
qué tipo de datos puedo tener en esta variable, 00:08:09
si son enteros, si son con comas, si son strings, si son caracteres, si son lo que sea. 00:08:13
Ahora veremos los tipos de datos. 00:08:21
y después le puedo poner dentro un valor que tiene que ser del tipo que he declarado. 00:08:22
No puedo decir, mira, aquí dentro voy a poner números y ahora ¿qué me puedo poner dentro? 00:08:34
Pues pongo un gato. 00:08:39
Pues no, gato no es un número. 00:08:40
Me enfado si tú intentas poner una palabra donde van solo números. 00:08:42
¿Dudas? 00:08:48
Entonces una variable es un cajón. 00:08:49
con una etiqueta delante 00:08:51
que me dice 00:08:54
cómo se llama ese cajón 00:08:55
que sólo puede 00:08:57
contener un tipo de 00:09:00
elemento 00:09:01
y con dentro uno de estos elementos 00:09:03
es un cajón 00:09:06
con escrito fuera edad 00:09:07
que si yo lo abro, sólo dentro puedo poner números 00:09:09
y dentro habrá un número 00:09:12
siete 00:09:13
¿verdad? 00:09:14
¿dudas? 00:09:17
vale, siempre hemos entendido el concepto 00:09:20
que imagina una caja con escrito un intuidor para diferenciarla de otra caja, 00:09:22
el nombre, que contiene algo, el valor, 00:09:26
y que solo puede contener un cierto tipo de cosas, que es el tipo. 00:09:29
Si yo tengo la caja para bolígrafos, no puedo poner dentro un teclado, 00:09:33
solo puedo poner un bolígrafo. 00:09:40
La caja tendrá un nombre, que será mi bolígrafo, 00:09:43
y yo cuando lo abro, dentro guardo mi bolígrafo 1, 00:09:47
vale un valor de eso y lo cierro solo porque es una caja pequeña no cabe ni un teclado ni 00:09:50
un ratón ni un ordenador pero tendré otra caja que se llama la caja ordenador o mi ordenador 00:09:58
se llama que puede contener ordenadores por dentro poder poner un ordenador se entiende 00:10:04
¿Cómo se hace esto en Java? 00:10:10
¿Vale? 00:10:14
Aquí lo tenéis. 00:10:15
int edad es igual a 18.com 00:10:18
¿Vale? 00:10:22
¿Qué es esto? 00:10:23
Sí. 00:10:24
¿En qué apartado? 00:10:26
Nosotros lo hemos visto. 00:10:30
Donde están los atributos, allí lo puede declarar. 00:10:34
Pero nosotros ahora hacemos todo dentro del mail. 00:10:36
Por ahora. 00:10:40
¿Vale? 00:10:41
Porque estamos en programación falsamente 00:10:42
estructurada, ¿vale? 00:10:44
Entonces, es como si todo el resto me lo olvido, 00:10:46
no sé, no existe, 00:10:48
y obtengo la llave del 00:10:50
main que acaba aquí, 00:10:52
pues allí dentro es donde hago todo. 00:10:54
¿Quiero declarar una variable? La declaro allí dentro. 00:10:56
¿Sí? 00:10:59
Entonces, int edad es igual a 00:11:00
18.coma me está diciendo, 00:11:02
oye sistema, créame 00:11:04
un espacio de memoria. 00:11:06
¿Cómo se llama este espacio de memoria? 00:11:08
No. 00:11:14
Sí, va. 00:11:14
La idea es la memoria principal, pero 00:11:17
yo le estoy diciendo, sistema, quiero crear 00:11:18
una variable, ¿vale? Esta variable 00:11:20
me creará, me reservará un trozo 00:11:23
de memoria. Este 00:11:25
trozo de memoria reservado, 00:11:26
¿cómo se llama? Con esto, 00:11:29
¿eh? Edad, ¿vale? 00:11:31
Este es el identificador, es el 00:11:35
nombre. Int edad, 00:11:37
edad, me está definiendo que este 00:11:39
trozo de memoria ahora se llama 00:11:40
edad. Cada vez que usaré 00:11:43
dada a partir de ahora no me estoy refiriendo a no sé qué más ese trozo de memoria porque lo 00:11:45
ha decidido lo ha declarado qué tipo de datos puedo poner dentro de edad enteros sería este 00:11:50
int. En inglés, integer o integer, no sé, ¿vale? Integer, como he conocido yo, no puedo decir integer, nunca he olvidado o nunca he buscado la pronunciación correcta, pero int me está diciendo que aquí dentro solo pueden ir números. 00:12:02
No puedo poner palabras, no puedo poner números con coma, 00:12:21
no puedo poner valores verdadero y falso, que serían booleanos. 00:12:26
He declarado que este trozo solo puede contener el término. 00:12:31
¿Y qué contiene ahora mismo? 00:12:35
Si yo abro la caja y miro, ¿qué hay dentro? 00:12:38
18. 00:12:42
¿Se entiende? 00:12:45
Puedes cambiar su valor y poner 19, por ejemplo, 00:12:50
Pero no puedes poner salmón 00:12:53
Salmón, no lo aceptaría 00:12:55
Porque salmón no es una palabra, no es un número 00:12:57
¿Sí? 00:12:59
Fijaos que aquí yo digo 00:13:00
Edad es igual a 19 punto y coma 00:13:02
Este ok 00:13:04
Edad es igual a salmón 00:13:05
Me daría error 00:13:07
¿Qué diferencia hay entre esta línea de abajo 00:13:08
Edad igual a 19 punto y coma 00:13:12
Y esta línea de arriba 00:13:14
Int edad igual a 18 00:13:15
No está en int 00:13:17
No está en la mano que sí 00:13:19
Como he dicho 00:13:24
¿Y qué cambia en esto? ¿Por qué una vez está lento y otra vez no? 00:13:25
¿Qué pensáis que... 00:13:31
... 00:13:33
... 00:13:35
... 00:13:37
¿Alguien lo quiere decir de otra forma? 00:13:39
Aquí estoy creando la variable. Aquí estoy declarando la variable. 00:13:43
La variable no existía y aquí te estoy diciendo voy a crear un nuevo espacio de memoria 00:13:51
sólo puede contener entero que se llama edad y ponle dentro 18 ahora a partir de 00:13:56
ahora en mi programa ese trozo ya existe si yo lo quiero modificar no hace falta 00:14:03
que de verdad decir entidad porque él sabe ya que edad puede contener sólo 00:14:10
enteros se lo he dicho cuando la he declarado ahora la estoy solo usando la 00:14:15
estoy modificando cuando la modificó la uso directamente digo hoy vida edad es 00:14:20
es igual a 19, ¿vale? 00:14:28
Esto quiere decir, destruye lo que hay dentro, 00:14:29
pilla este nuevo valor 19 00:14:33
y guárdalo en esa caja. 00:14:34
Recuerda que en la variable está un solo valor. 00:14:36
Entonces, o está el 18 o está el 19. 00:14:39
Antes estaba el 18, 00:14:41
en el momento en que le digo, 00:14:42
no, ahora es igual a 19, 00:14:43
pues lo que tienes que hacer es poner el 19 dentro. 00:14:45
¿Sí? 00:14:49
Este operador de aquí igual 00:14:50
no es el igual que conocéis vosotros. 00:14:52
3 es igual a 3, es verdad 00:14:55
Este de aquí es un operador de asignación 00:14:58
Me está diciendo 00:15:02
Lo que hay a la derecha 00:15:03
Guárdalo dentro de lo que hay a la izquierda 00:15:05
A la izquierda va un identificador de variable 00:15:09
A la derecha va un valor 00:15:13
Que sea del tipo correcto 00:15:15
¿Dudas hasta aquí? 00:15:17
Muy bien, sabéis que es una variable 00:15:22
¿Vale? ¿Sí? Y si en vez de un no, de un, de un, de un, ah, no, perdón. Aquí vamos a ver cómo se da un nombre a una variable. ¿Vale? ¿Qué puedo hacer para dar un nombre a una variable? ¿Vale? Se compone de uno más caracteres de los siguientes. Letras de A a la Z o A mayúscula Z. ¿Vale? Números de 0 a 9, guión bajo se puede usar y símbolo de dólar. ¿Sí? Todo esto son caracteres admitidos para una, el nombre de una variable. 00:15:23
pero por ejemplo el punto no, no puedo llamar edad de punto mía, o mi punto edad, no lo puedo hacer, 00:15:53
pero sí puedo hacer mi guión bajo edad, ¿sí? Personalmente, he olvidado esto, ¿sí? 00:16:02
Yo usaré solo letras y números, ¿sí? 00:16:14
No puede comenzar por número 00:16:19
Como he dicho antes 00:16:22
Los identificadores en Java no empiezan por número 00:16:23
Puedo llamar edad de 3 00:16:25
Pero no puedo llamar 3 edad 00:16:27
¿Ok? 00:16:29
No pueden coincidir con ninguna palabra reservada 00:16:31
No puedo llamar una palabra 00:16:33
Int public es igual a 18 00:16:35
No funciona 00:16:37
¿Ok? 00:16:38
Son case sensitive o sensibles a mayúscula 00:16:41
O sea, edad con la e mayúscula 00:16:43
No es la misma variable 00:16:46
que edad con la e minúscula. 00:16:47
Cuidado. 00:16:50
Concajará los 00:16:53
identificadores compuestos de varias palabras 00:16:53
poniendo en mayúscula la primera letra 00:16:56
de cada palabra, en lugar de utilizar 00:16:58
bien, bajo, solo, tal, cosa. 00:16:59
Fecha de nacimiento, 00:17:01
la d de d es 00:17:03
mayúscula, la n de nacimiento es 00:17:05
mayúscula, y cosas por el estilo. 00:17:07
La primera letra de un 00:17:09
identificador de variable, o de 00:17:11
método, será minúscula. 00:17:13
¿Es necesario? No. 00:17:17
¿Todos los programadores de Java hacen así? Sí. 00:17:20
Eso me permite, dado un identificador, saber si es una variable, si es un método o si es una clase. 00:17:25
Si empieza por mayúscula es una clase, si empieza por minúscula es una variable o un método. 00:17:33
¿Se entiende? 00:17:39
Literal. ¿Qué es el concepto de literal? 00:17:44
Literal es un valor concreto, ¿vale? Es un valor. 00:17:46
Si yo te digo un literal de los enteros, pues 3 es un literal de entero. 00:17:50
27 es un literal de entero. 00:17:55
45 es un literal de entero. 00:17:57
Si yo quiero literales de coma flotante, ¿vale? 00:17:59
Que se llaman flot, ¿vale? 00:18:03
Que son números con la coma, pues 3,7 es un literal de flot. 00:18:04
25,9 es un literal de flot. 00:18:10
39 es un literal de flot. 00:18:14
Que ya te he entrado a cómo hacer. ¿Sí? ¿Eh? 00:18:16
Pillamos dos tipos. Entero, ¿vale? Entonces, el entero, cuando yo te digo int, es... 00:18:24
Tú aquí dentro puedes poner el conjunto de todos los números enteros del mundo. 00:18:30
Cada uno de esos es un literal. Es algo que puedes usar para meterlo ahí dentro. 00:18:35
No sé qué has dicho, no me he enterado. Que estoy hablando... 00:18:40
Entonces, por ejemplo, 5 es un número entero, por lo tanto es un íntegro. 00:18:43
Lo puedes usar como íntegro. 00:18:48
27 es un número entero. 00:18:51
27,4 no lo puedes usar porque no es un literal de entero. 00:18:53
¿Me entiendes? 00:19:00
Es otra cosa, pero no es un entero. 00:19:01
Porque 27,4, el coma 4 me hace pensar que no es un íntegro. 00:19:03
Por lo tanto, no me da. 00:19:07
Ahora, otro tipo de datos. 00:19:08
Lo veremos, pero para introducirlo, para que se suene. 00:19:10
Float. 00:19:13
Float es coma flotante, o sea que es un número que puede tener una coma que se mueve, ¿vale? 00:19:14
Es un número con coma, es un número decimal, ¿sí? 00:19:19
Entonces, 27,4 es un número con coma, por lo tanto puede ir dentro de un float, ¿sí? 00:19:22
39,5 también es un literal de los float, por lo tanto puede ir dentro del float, es un número decimal. 00:19:30
Ahora, 91, así, a seca, ¿es un número decimal? 00:19:37
Sí. 00:19:45
Es 91,000000. 00:19:47
Entonces, el 0000 a la derecha no los pones. 00:19:51
Pero 91 es un número con coma. 00:19:55
Lo puedes ver como número con coma. 00:19:58
Entonces, si uso los números float, que son los números que admiten decimales, 00:20:00
también puedo admitir 91. 00:20:05
Todos los enteros son números con coma. 00:20:06
Solo que hay una coma precisa, coma C. 00:20:12
Entonces sí lo puedo usar. 00:20:16
Tipo palabra, ¿vale? 00:20:21
Será string, con una S mayúscula. 00:20:23
Dentro de string yo puedo poner gato, puedo poner cocodrilo, puedo poner mi nombre, puedo poner el Quijote. 00:20:26
Me da igual. 00:20:36
¿Sí? Siempre que sean delimitados, de comillas a comillas, ¿vale? 00:20:38
Un literal del tipo string son todas las palabras, el conjunto de palabras que se te ocurren. 00:20:42
Son una cadena de carácteres, una serie de carácteres, uno tras otro. 00:20:50
¿Sí? 00:20:56
Este de aquí, con una camilla sola, es también un literal de un tipo que se llama carácter. 00:20:59
El tipo carácter es un solo símbolo. 00:21:08
Puede ser una letra, puede ser un número, puede ser un punto, puede ser un asterisco, 00:21:11
pero un solo símbolo. 00:21:15
La cadena de caracteres es una secuencia de este tipo de aquí. 00:21:19
Si tengo uno solo, es un char, C-H-A-R, tipo char. 00:21:23
Si en vez tengo muchos unos detrás de otros, será una cadena de caracteres, o sea, un string. 00:21:27
Y esto es simplemente para decir que cada tipo de variable tiene un conjunto de valores admitidos. 00:21:32
Estos valores admitidos se llaman literales. 00:21:42
Entonces, ¿me podéis hacer un ejemplo de un literal de int? 00:21:47
Uno. 00:21:53
Otro ejemplo. 00:21:54
20. 00:21:55
Otro ejemplo. 00:21:56
Un ejemplo de literal de string. 00:21:57
Gato. 00:22:01
Gato. 00:22:02
¿Qué más? 00:22:03
Un ejemplo de literal de número decimal, lo habéis pillado, ¿no? 00:22:04
¿Y para entero? 00:22:17
Para entero, no. Para un ínter, no. Para un float o un double, sí. 00:22:22
De alguna forma, luego lo veremos. Ahora lo que me interesa es que entendáis el concepto de literal. 00:22:30
En un cierto sentido 00:22:36
Cuando declaro la variable 00:22:38
Int, o sea, tipo 00:22:41
Nombre 00:22:43
Es igual literal 00:22:44
¿Entendéis? 00:22:46
Sí, sí, a ver, lo repiteremos 00:22:50
Este es el tipo 00:22:52
Este es el nombre 00:22:53
Igual, y aquí va un literal 00:22:56
De este tipo 00:22:59
¿Sí? 00:22:59
Cuando hago edad es igual a 19 00:23:02
Esto tiene que ser un literal 00:23:04
De este tipo 00:23:06
del tipo de esta variable, ¿se entiende?, va. ¿Qué más?, ok. Literales se pueden 00:23:08
guardar en variable cuyo tipo lo permita, vale, si un variable, o sea cada literal 00:23:20
tendrá su tipo, 91 tendrá un tipo, 91,5 tendrá un tipo float, se puede 00:23:24
guardar en variables punto float, o sea de tipo float. Gato tendrá tipo string, pues se 00:23:30
puede guardar dentro de variables de tipo string. En realidad, 91 es tipo int, pero también es tipo flag. 00:23:36
Ok, entonces, ¿qué tipos de datos tenemos? Vamos a ver lo que se llaman los tipos de datos primitivos. 00:23:48
¿Vale? Son los más básicos. Nunca. En algunos lenguajes de programación sí. Te permite, por ejemplo, 00:23:55
Javascript, por ejemplo, Credo o Python. 00:24:10
En una lista tú puedes imaginar números, textos y tal, pero aquí no. 00:24:13
Tampoco en la lista. 00:24:19
O sea, el Java es un lenguaje de programación tipal. 00:24:22
O sea que todo tiene que tener su tipo. 00:24:26
Tú puedes hacer algunos truquillos para conseguir obtener una lista, un array, 00:24:30
o lo que sea, con valores 00:24:38
mezclados, pero normalmente 00:24:40
no es lo que quieres. Tú quieres mantener 00:24:42
todo separado. 00:24:44
Cuando aprendes a hacerlo, es todo 00:24:46
más ordenado. Claramente 00:24:48
aprecio de que tú tienes que saber qué estás 00:24:50
haciendo. Mientras en 00:24:52
otros lenguajes que son poco tipados, 00:24:54
pues el mismo 00:24:57
sistema infiere 00:24:58
qué tipo de datos están en las 00:25:00
variables. Y luego 00:25:02
de vez en cuando se equivoca. 00:25:04
Porque si tú dentro de la variable no sabes si tienes una palabra o un número, luego no podrás nunca sumar esa variable. 00:25:06
Porque a la vez que tienes un número que funciona, a la vez que tienes una palabra, no lo puedes hacer. 00:25:12
Gato plus 7, más 7. 00:25:18
Entonces, ¿vale? 00:25:21
¿Qué tipos de datos hay? 00:25:24
Entonces, hay el tipo booleano, desde el concepto de álgebra de Boole, que era un señor. 00:25:27
El álgebra de Boole es un álgebra que se basa sobre dos valores, verdadero y falso, cero y uno, si quisiéramos. 00:25:34
Entonces, son todas una matemática que se basa sobre preposiciones que cuando yo las resuelvo, en vez de tener un número, pues tengo un valor que es verdadero o falso. 00:25:47
La lógica. 00:26:01
Esto nos servirá a nosotros y como programadores lo tendremos que ver mucho porque, por ejemplo, todas las condiciones del if, del while, y cosas por el estilo, usarán estos tipos de valores. 00:26:04
¿Verdad? Y cuando yo decía, si una condición es verdadera, haz esto. Si es falsa, haz otra cosa. 00:26:14
Esto es porque el if recibe un booleano. 00:26:20
Pasa un booleano. 00:26:24
Si esta cosa de aquí, que más le quita aquí, se soluciona, se resuelve con un true, entonces se ejecuta este trozo de código. 00:26:24
si se resuelve con un false 00:26:32
entonces se ejecuta un trozo de código distinto 00:26:34
pero en general 00:26:37
lo veremos 00:26:38
el tipo booleano 00:26:39
es un tipo que admite solo dos valores 00:26:41
hay dos literales 00:26:44
en booleano, ninguno más 00:26:46
que son true y false 00:26:48
en Java 00:26:50
la palabra que me dice que es un booleano 00:26:53
es boolean 00:26:56
ocupa un byte 00:26:57
de espacio 00:27:00
o sea que cuando yo creo una variable boolean me crea un trocito de memoria grande un byte 00:27:01
vale 8 bits como mínimo vale false o máximo vale true y dos valores positivos dudas 00:27:08
carácter vale es un singolo carácter letra o número o símbolo vale en java se llama char 00:27:20
y ocupa dos bytes. Para almacenar un carácter, ocupo dos bytes de memoria. 00:27:31
Cuando creo una variable de tipo char, char letra es igual a un 00:27:39
literal de tipo char, pues lo que estoy ocupando es dos bytes de memoria dentro 00:27:47
de la RAM. 00:27:52
Los valores mínimos y máximos no me los sé. 00:27:55
Son carácteres. 00:27:59
A, B, C, K, asterisco, comilla, punto y coma. 00:28:00
Eso son símbolos. 00:28:05
Bytes. 00:28:09
Desde aquí, desde byte, hasta esto, hasta long, byte, short, interlong, son todos números enteros. 00:28:11
representan 00:28:22
todos números enteros 00:28:25
lo que cambia es el rango 00:28:27
de lo que puedo poner ahí dentro 00:28:29
si uso un byte 00:28:30
es de tamaño un solo byte 00:28:33
un byte son 8 bits 00:28:35
entonces el número 00:28:37
más pequeño que puede hacer 00:28:39
es menos 128 00:28:41
y el número más grande que puede hacer 00:28:43
es 127 00:28:45
¿sabéis algo de binario? 00:28:46
si yo tuviera 8 bits 00:28:49
¿Cuántos números distintos puedo hacer con 8 bits? 00:28:52
2 elevado a la 8 00:29:00
Que son 256 posibles valores 00:29:02
Si contáis desde menos 128 a más 127 00:29:07
Son 256 posibles valores 00:29:13
El primer bit 00:29:16
Si es 0 00:29:18
Si es 0 es positivo 00:29:20
Si es 1 es negativo 00:29:23
O sea, el primer bit me dice simplemente si es un número positivo o negativo. 00:29:24
Y luego me quedan otros 7 bits, que 2 a la 7 son 128, 00:29:29
posibles números para decir si es positivo o negativo. 00:29:34
Por eso, si pongo el primero a 1 y todo el resto a 1, me voy hasta menos 128. 00:29:39
Si pongo el primero a 1 y luego pongo todo a 1, me voy a 127. 00:29:44
Tened en cuenta que en los positivos se cuenta también el 0, por eso es un número. 00:29:50
¿Dudas? ¿Entiendes? Vale, si yo quiero números más grandes que estos, en vez de utilizar un byte que ocupa solo un byte, puedo usar un short, que es un número corto, un número pequeño, que en vez de ocupar un byte, ocupa dos bytes. 00:29:56
Ahora, en vez de tener 8 bits con el que puedo jugar, tengo 16 bits con el que puedo jugar. 00:30:17
Por lo tanto, puedo llegar hasta 2 a la 16 distintos números. 00:30:23
O sea, 65.536 posibles números distintos. 00:30:27
Que van desde menos la mitad de eso, o sea, menos 32.000, hasta más 32.000. 00:30:31
Números pequeños. 00:30:38
Si necesito números más grandes, puedo ir a int, que ocupa 4 bytes. 00:30:40
Entonces, ahora no tengo 16 bits con los que jugar, 00:30:46
pero tengo 32 bits con los que jugar. 00:30:49
Entonces, puedo llegar hasta 2 a las 32 posibles valores, ¿vale? 00:30:52
Que van desde menos punto, punto, punto, 00:30:56
2.000 millones hasta más 2.000 millones. 00:31:00
Son 4.000 millones más o menos de números posibles. 00:31:03
Y estos me sobran normalmente. 00:31:08
La mayoría de las veces que usamos un número entero 00:31:12
Este rango es más que aceptable 00:31:15
Edad 00:31:19
Es más aceptable 00:31:20
Tener desde menos 2.000 millones de años 00:31:22
A más 2.000 millones de años 00:31:25
2.000 millones de años 00:31:26
Sí, poca gente que conozco yo 00:31:28
Ha pasado los 2.000 millones de años 00:31:30
¿Sí? 00:31:32
De hecho para la edad hasta podría 00:31:33
Podría valer un byte 00:31:35
El 37 00:31:37
Llegar a ese 27 00:31:39
No imposible 00:31:42
Pero, si imaginaos un programa que está calculando las distancias entre planetas o entre estrellas, 00:31:44
entonces, en kilómetros, entonces a lo mejor este número de aquí ya se queda por título. 00:31:57
Entonces se necesita una variable que sea todavía más grande. 00:32:02
Esto ocupa 8 bytes en memoria, ¿vale? 00:32:06
Entonces 64 bits, si no me equivoco. 00:32:10
pues entonces puede hacer 00:32:12
números mucho, mucho más grandes. 00:32:14
Siempre enteros son. 00:32:17
Todo esto son enteros. 00:32:18
¿Vale? 00:32:20
Pero la idea es que 00:32:21
dependiendo del tipo de variable que pillo 00:32:22
ocupará más o menos en memoria. 00:32:25
¿Vale? 00:32:28
Y podrá contener números más grandes o más pequeños. 00:32:29
¿Dudas? 00:32:34
¿Para qué me sirve esto? 00:32:36
Porque depende de lo que hago yo. 00:32:38
¿Vale? 00:32:40
en nuestros ordenadores, en nuestros ejercicios 00:32:40
nosotros usaremos siempre int porque da igual 00:32:42
pero imaginaos que estáis en una situación 00:32:44
en el que el dispositivo 00:32:46
donde vais a programar tiene 00:32:48
muy poca memoria RAM 00:32:50
poquísima memoria RAM 00:32:51
y yo no voy a usar estos números RAM 00:32:54
entonces en vez de utilizar int 00:32:56
uso byte para que sea lo más 00:32:58
gaste lo menos recursos 00:33:00
posible 00:33:02
si yo hago un programa donde voy a 00:33:03
hacer distancias interestelares 00:33:06
y cosas por el estilo y necesito 00:33:08
un entero grande pues no puedo utilizar esto utilizar si yo estoy contando milisegundos o 00:33:10
nanosegundos en tiempos de reciente largos pues a lo mejor entre hoy y mañana en milisegundos pues 00:33:17
esta cosa aquí no me perdón no es suficiente necesito un número más grande se entiende 00:33:25
Tú das 00:33:32
Vale, ahora 00:33:34
Si en vez de los enteros 00:33:36
Quiero coma flotante 00:33:38
O sea, quiero decimales 00:33:40
Quiero poder tener números coma algo 00:33:41
Tengo dos opciones 00:33:44
Los float o los double 00:33:45
Los float 00:33:48
Ocupan 4 bytes 00:33:49
Y me permiten hacer números 00:33:51
Desde menos 3.4 00:33:54
Multiplicado de 10 a la 38 00:33:56
O sea, sí 00:33:58
Hasta 3.4 por 10 a la 38 00:33:59
son números bastante más grandes, son muchos números, o el double que tiene 8 bytes y puede hacer estas cosas aquí, que son mucho más. 00:34:02
Tened en cuenta que mientras aquí lo que escribo dentro es directamente el número, en Sloat double dentro de la variable no escribo directamente el número, 00:34:13
Pero hay una parte que es un exponente y una parte que es un número. 00:34:26
Y luego calcularé este número elevado a este exponente. 00:34:30
Por eso me permite hacer muchos más números por aquí. 00:34:34
¿Por qué se llama double? 00:34:38
Porque tiene el doble de precisión. 00:34:41
Este de afloat me permite una precisión buena. 00:34:44
El double me permite una precisión del doble. 00:34:48
Tened en cuenta que, mientras los enteros van directamente por el número que es, aquí tenemos dos problemas con los float y los double. Por un lado, el número máximo al que puedo llegar. Y el segundo problema es cuánto preciso puedo ser con un número. 00:34:52
Imaginaos un número que es 3,123,123,123,123,123,123,123,123,123,123,123,123,123 por un millón de veces. 00:35:10
Un millón de veces, 1, 2, 3. 00:35:22
Pues eso en un ordenador no lo puedo guardar. 00:35:24
Es demasiado preciso para que se pueda guardar en un ordenador. 00:35:27
¿Me explico lo que quiero decir? 00:35:32
lo puedo aproximar 00:35:34
a un número un poquito más grande 00:35:37
un poquito más pequeño que se pueda 00:35:39
representar 00:35:41
con un dado 00:35:42
pero estos son problemas 00:35:44
complejos que 00:35:49
conllevan a que cuando se hacen 00:35:51
por ejemplo el mundo de la física, el mundo de la biología 00:35:53
cuando se tienen que hacer mediciones muy 00:35:55
precisas con ordenadores, allí tengo problemas 00:35:57
pero por lo que hacemos nosotros 00:35:59
nos da igual 00:36:01
Entonces vamos a declarar variables 00:36:02
Tiro un poquito más adelante 00:36:07
Tanto luego estaré feo 00:36:09
5 minutos antes a lo mejor 00:36:11
Pero aquí si no tengo que bloquear el vídeo 00:36:13
Declaración de variables 00:36:15
Hay dos formas de declaración 00:36:17
Simple o con inicialización 00:36:19
Lo que hemos visto antes es esta aquí debajo 00:36:22
¿Cómo se hace una declaración simple? 00:36:24
Tipo 00:36:27
Nombre.com 00:36:27
intedad.com 00:36:30
¿Qué hace esto? 00:36:32
Me está creando un trozo de memoria 00:36:34
Dentro de este trozo de memoria solo puedo poner enteros 00:36:36
Este trozo de memoria se llama edad 00:36:39
Pero no he metido dentro nada 00:36:41
No lo he inicializado 00:36:43
Cuidado 00:36:46
Porque si ahora lo uso 00:36:48
Mi programa explota 00:36:49
En general es muy importante inicializar las variables 00:36:51
Darle un número inicial 00:36:59
En realidad, por ejemplo, en el caso del entero, 00:37:02
si yo no le doy ningún número, 00:37:05
él me lo inicializa en automático a hacer. 00:37:06
¿Vale? 00:37:09
Pero en teoría yo debería siempre ponerle un número. 00:37:09
O sea, que esta cosa de aquí, 00:37:13
veremos que a veces se puede utilizar, 00:37:15
veremos por qué, 00:37:17
pero en general nosotros usaremos esta ahora. 00:37:18
Sí. 00:37:22
Ah, o sea, el literal es el tipo de dato que equipas 00:37:23
al detectar una variable. 00:37:25
El literal es el valor... 00:37:27
El tipo de datos. 00:37:30
el valor que le das pillándolo del conjunto de todos los posibles valores 00:37:31
de ese tipo. Yo te digo, tu edad es 37, pues 37 es un número que entre 00:37:39
todos los números posibles que son int, he elegido este índice de edad. 00:37:50
Entonces, por ejemplo, int edad, estoy creando una variable que se llama edad, que tiene dentro 00:37:58
enteros pero no sé cuánto vale damos resultado estoy creando una variable que 00:38:03
se llama resultado al trozo de memoria grande cuánto 00:38:08
8 bytes y entonces hay un espacio de memoria de 8 bits va bytes guardado al 00:38:13
que me refiero con resultado cada vez que utilizaré la palabra resultado me 00:38:20
estoy refiriendo a lo que está dentro de esa caja de 8 bytes que guardaron la 00:38:24
memoria y dentro puede tener sólo 00:38:27
decimales decimales de decisión doble de precisión doble 00:38:35
decimal boolean hay espacio libre punto y coma 00:38:40
he creado un espacio de memoria grande cuanto 00:38:46
un byte que se llama hay espacio libre se llama así vale y dentro puede guardar 00:38:50
solo dos tipos de valores. ¿Cuáles valores? ¿Valero o falso? Porque es booleano. ¿Y qué hay dentro? 00:38:58
No lo sé, porque no lo he inicializado, pero normalmente booleano, si no lo inicializo, me pone false. 00:39:06
Edad, si no lo inicializo, me pone cero. Y double, si no lo inicializo, me pone cero también. 00:39:12
Pero inicializadlo, porque luego cuando llegue el futuro, veremos cuándo se usa esto. 00:39:18
Pero ahora sepáis que existe. Pero nosotros usamos esto, que es tipo nombre igual literal punto y coma. 00:39:26
Como por ejemplo, int numpáginas igual 200 punto y coma. 00:39:34
Entonces tengo una variable. ¿Cómo se llama la variable? 00:39:38
Numpáginas. ¿Qué contiene dentro? 00:39:43
Y 200 es un literal de qué? 00:39:46
De int. 00:39:48
Porque en esta caja solo puedo poner int. 00:39:53
¿Vale? 00:39:55
Solo valores 00:39:57
Que tienen tipo int 00:39:57
Y 200 00:39:59
Es un número entero 00:40:00
Y tiene tipo int 00:40:01
Lo puedo guardar 00:40:02
Boolean 00:40:03
Acabado 00:40:05
Es igual a 00:40:05
False.com 00:40:06
¿Cómo se llama 00:40:07
La variable? 00:40:09
¿Es acabado? 00:40:11
Porque es falso 00:40:14
¿Ve? 00:40:15
Probablemente 00:40:16
Esto será en mi programa 00:40:17
Que le he puesto 00:40:18
Acabado false 00:40:19
Y que hará lo que sea 00:40:20
Y cuando en un determinado momento 00:40:22
Habrá acabado 00:40:23
Pondrá acabado true 00:40:24
y entonces yo puedo ir a mirar acabado 00:40:25
y saber si se ha acabado o no 00:40:27
en un determinado momento. 00:40:29
¿Falso qué es? 00:40:33
¿Qué es? 00:40:35
Valor booleano. 00:40:37
Es decir, es un 00:40:38
literal 00:40:39
de tipo booleano. 00:40:41
¿Se entiende? 00:40:43
Easy. 00:40:45
Vale. 00:40:46
Declaración múltiple. 00:40:49
Declaro varias variables de golpe. 00:40:51
¿Vale? 00:40:53
Tanto con literal como sin literal. 00:40:54
¿Vale? 00:40:56
Int 00:40:57
¿Cuántas variables he creado? 00:40:57
Dos. 00:41:02
¿Cómo se llama la primera? 00:41:03
¿Cómo se llama la segunda? 00:41:05
¿Qué contienen? 00:41:07
Cero. 00:41:10
Cero probablemente. 00:41:11
¿Y qué pueden contener? 00:41:13
¿Qué tipo tienen? 00:41:14
Interos. 00:41:16
Int. 00:41:17
¿Me seguís? 00:41:19
¿Hay alguien que se ha perdido? 00:41:20
Si alguien se ha perdido, me lo diga, 00:41:22
que la próxima se la ha perdido a él 00:41:24
y lo razonamos juntos. 00:41:25
No tengáis miedo. ¿Habéis entendido todo? 00:41:27
Va. 00:41:31
Char, inicial, nombre, coma, inicial, apellido, punto y coma. 00:41:32
¿Cuántas palabras hay? 00:41:38
Dos. 00:41:43
¿Cómo se llama la primera? 00:41:44
¿La segunda? 00:41:48
¿Qué contienen? 00:41:50
Ni idea. 00:41:54
No sé cuál es el valor por defecto de un char. 00:41:55
Realmente es vacío. 00:41:58
Pero no lo sé. 00:42:00
Hay que probarlo. 00:42:01
que pueden contener un carácter, es decir, un símbolo, una letra, un valor, uno, uno, no dos. 00:42:01
Si fueran dos carácteres, ¿podría usar char? ¿Qué tendría que usar? 00:42:12
No lo hemos visto todavía, string. 00:42:21
O puedo inicializar múltiple o multioble, como lo he escrito aquí, pero con el literal, ¿vale? 00:42:25
entonces aquí cuánta hagamos esto cuántas para en lo de abajo cuántas variables se crean 00:42:33
si yo tengo este comando de aquí cuántas variables se crea 00:42:52
no no porque es una declaración este es un único comando es una declaración 00:43:22
múltiple es un coma no es un punto y como que se puede declarar la comerci 00:43:27
intervalle formatura algún te coma lo que está haciendo es creando las dos a 00:43:35
la vez misma cosa aquí está creando tres variables a la vez la primera como se 00:43:39
llama error la segunda la tercera 00:43:44
que contiene que pueden contener las 13 que pueden contener profundo es decir un 00:43:49
valor booleano su tipo es booleano de las 3 00:43:59
la primera tiene la segunda tiene la tercera tiene 00:44:05
que son literales de booleanos sí o no perfecto 00:44:11
Cambiar el valor a una variable, ya lo hemos visto, ¿vale? 00:44:19
Para cambiar el valor a una variable es nombre igual a valor. 00:44:21
Tiene una variable que tiene que haber existido antes. 00:44:25
O sea, antes declaro la variable y luego le cambio el valor. 00:44:28
No puedo cambiar el valor a una variable que no he creado. 00:44:30
La diferencia es que para crear la variable, aquí va el tipo, para cambiarla el tipo no está. 00:44:33
¿Sí? 00:44:41
Por ejemplo, si hago int edad es igual a 18, fenomenal. 00:44:42
He creado una variable que se llama edad, que puede tener dentro enteros. 00:44:45
y tiene el valor 18, para modificarla, edad igual a 19. 00:44:49
Te estoy diciendo, vete a la porción que se llama edad, 00:44:53
y allí dentro, tira lo que hay ahí dentro, 00:44:56
bórralo, y pon 19, que es un literal de índice. 00:44:59
¿Entiendes? 00:45:06
¿Entiendes la diferencia entre declaración y modificación? 00:45:07
Yo, antes de poder modificar algo, lo tengo que haber declarado. 00:45:13
Si no lo hago así, me va a decir, no sé quién es este. 00:45:16
Ponme 19 en edad. 00:45:22
No sé quién es edad. 00:45:24
No puedo resolver el símbolo edad, te voy a decir. 00:45:25
¿Qué es nuestro símbolo edad? 00:45:28
Lo más declarado que es, no sé qué identificador es, no puedo hacer nada. 00:45:31
Boolean, tienda abierta es igual a true, punto y coma. 00:45:36
¿Es una declaración o es un cambio de valor? 00:45:39
Declaración, estoy diciendo. 00:45:44
Creemos en una cosa, se mantiene abierta, dentro le pones true, 00:45:45
y puede tener dentro booleanos, o sea, true or false. 00:45:48
y ahora hago tienda abierta igual a false 00:45:50
hasta modificar 00:45:52
¿sí? 00:45:55
notas y cambios 00:45:57
no he declarado antes 00:45:58
boom, error 00:46:00
¿sí? 00:46:02
tipo string, ¿vale? 00:46:05
el tipo string es un tipo distinto 00:46:07
no es un tipo primitivo 00:46:10
los tipos primitivos son los que hemos visto hasta ahora 00:46:12
¿vale? 00:46:15
char, un carácter 00:46:16
es un tipo primitivo 00:46:18
string no es un tipo primitivo 00:46:19
¿Le veis una diferencia gráfica entre String y los otros? 00:46:22
La mayúscula. 00:46:31
String es con la S mayúscula. 00:46:33
¿Y cuándo un identificador empieza con una letra mayúscula? 00:46:35
¿Qué es? 00:46:38
¿Dónde ponemos nosotros nombres con la letra mayúscula? 00:46:46
Con la primera letra mayúscula. 00:46:49
En Java. 00:46:57
¿Dónde hemos usado nosotros identificadores cuya primera letra es mayúscula? 00:46:58
En el sistema. 00:47:04
No, no lo hemos hecho nosotros. 00:47:05
Lo hemos usado, 00:47:07
pero no lo hemos hecho nosotros. 00:47:07
No es un identificador 00:47:08
que hemos dado nosotros. 00:47:09
No es un nombre 00:47:10
que hemos dado nosotros. 00:47:11
Public class 00:47:14
y el nombre de la clase. 00:47:15
El nombre de la clase 00:47:18
va en mayúscula. 00:47:19
Y entonces, 00:47:20
stringer, 00:47:20
si tiene la S mayúscula, 00:47:21
¿qué es? 00:47:22
La clase. 00:47:23
¿Vale? 00:47:26
Vosotros, 00:47:27
cada vez que intentáis 00:47:27
el stringer 00:47:28
como si fuera un tipo, 00:47:29
en realidad ya estáis 00:47:31
trabajando con objetos, 00:47:32
pero no lo sabéis. 00:47:34
¿Vale? 00:47:36
Lo volveremos a ver, ¿vale? 00:47:36
Cuando en un futuro veremos que son los objetos 00:47:38
Y le vamos a acordar string, jaja 00:47:40
¿Vale? Pero por ahora 00:47:42
Por ahora nosotros usamos string como si fuera 00:47:43
Otro tipo primitivo, solo que los otros tipos 00:47:47
Primitivos son todos sin minúsculas 00:47:49
String es el único que va en mayúsculas 00:47:50
¿Vale? Entenderemos por qué en un futuro 00:47:52
Y lo que tiene string 00:47:55
Es una concatenación 00:47:57
Chart 00:48:00
Es un elemento, una cosa 00:48:01
un objeto que lo que hace 00:48:05
es concatenar dentro 00:48:07
un char detrás de otro char 00:48:09
detrás de otro char 00:48:10
como por ejemplo hola 00:48:11
hola es el carácter h 00:48:14
seguido del carácter a o 00:48:17
seguido del carácter l etc 00:48:19
si os 00:48:20
fijáis bien 00:48:23
cuando trabajo 00:48:24
con string uso 00:48:27
las comillas 00:48:28
las dobles, las que están en mayúscula 00:48:30
dos 00:48:33
sin embargo 00:48:33
cuando he hablado de char 00:48:36
he hecho un ejemplo de char 00:48:38
por algún lado, hay un ejemplito por aquí 00:48:40
no he usado 00:48:42
la comilla doble 00:48:44
he usado 00:48:46
una sola comilla, una apóstol 00:48:48
que es 00:48:50
al lado de cero 00:48:51
si yo escribo esto así 00:48:56
este es un char 00:48:59
si yo escribo doble comillas 00:49:01
a doble comillas 00:49:03
ese es un literal de, repito, este es un literal de, y si le pongo comillas a comillas, ese es un literal de, ¿entendéis? 00:49:05
Vale, entonces, por ejemplo, esta cosa aquí, 00:49:21
y, en el medio del camino de nuestra vida, en el trabajo de una selva oscura, que la debilitaría a las marritas, 00:49:26
ay, a decir cuál era la cosa dura de esta selva, el barrio de los transportes, que no pensé en el nuevo puro, 00:49:32
o cosas por el estilo, es el principio de 00:49:37
muy bien 00:49:39
muy bien, y todo esto 00:49:41
es una literal de 00:49:43
string 00:49:45
¿se entiende? 00:49:46
da igual el tamaño 00:49:50
no es que una palabra es un string 00:49:51
no, de comillas a comillas 00:49:53
todo lo que está ahí dentro es un literal 00:49:55
de string 00:49:57
¿dudas? vale, declaración 00:49:57
de variable de tipo string 00:50:03
string, nombre es 00:50:04
igual a Juan 00:50:07
String ciudad es igual a Toledo 00:50:07
String trampa es igual a tres 00:50:10
Hay una trampa aquí 00:50:13
Una trampa, todo correcto 00:50:15
¿Vale? 00:50:21
Cuidado, comilla, tres, comilla 00:50:22
Es un literal de 00:50:25
String 00:50:26
Si yo pongo string trampa es igual a tres 00:50:28
¿Es correcto o no? 00:50:33
No, ¿por qué no? 00:50:36
¿Y 3 qué es? 00:50:38
3 es un literal de int. 00:50:42
Pero no me vale para ponerlo dentro de string. 00:50:45
¿Entienden la diferencia? 00:50:48
Eso menos. 00:50:50
Estamos con las variables. 00:50:52
Muchas cosas, pero... 00:50:54
Vale, entonces, para verlo gráficamente. 00:50:56
¿Eh? 00:51:01
Misma cosa otra vez. 00:51:01
Muchas cosas, pero son siempre las mismas. 00:51:02
Int edad de guardia 16. 00:51:06
tengo un trozo de memoria con dentro 16 sólo puede contener enteros y se llama edad 00:51:07
20 días igual a 22, misma cosa, string nombre igual a stefano, stefano sin la e, sin ph, con una f sola 00:51:14
con la o al final, que lo sepáis, que luego os va a parecer, string a la mesa igual a octubre, es una variable que se llama 00:51:27
mes, que puede tener string dentro y tiene el valor octubre, literal octubre. 00:51:36
¿Se entiende? 00:51:41
Entonces, int resultado es igual a 22. Creo una nueva variable que es resultado 00:51:59
en 32. Ahora digo 00:52:05
result... 00:52:06
¡Ay! ¡Ay! 00:52:08
Ahora mejor. Entonces, 00:52:17
si el resultado 00:52:20
de 22 me crea esto, 00:52:21
resultado es igual a 17, ¿qué hace? 00:52:22
No crea una nueva variable, 00:52:31
es la misma variable, pero el valor 00:52:32
lo cambia en 17. 00:52:34
Vale. 00:52:38
Resultado es igual a 5 más 400. 00:52:38
¿Qué hace? ¿Y qué pone? 00:52:41
Hace resultado, 00:52:47
evalúa lo que está a la derecha del igual 00:52:48
entonces hace la operación 400 más 5 00:52:52
405 00:52:55
y este valor final 00:52:56
lo guarda dentro del resultado 00:52:58
por lo tanto dentro del resultado tengo 00:53:00
resultado es igual a 10 por 10 menos 200 00:53:02
lo calcula y lo pone 00:53:07
¿y cuánto sale? 00:53:14
menos 100 00:53:16
es un índice menos 100 00:53:17
¿sí? 00:53:19
menos 100 00:53:24
¿sí? 00:53:25
Siguiente 00:53:29
Entonces 00:53:37
Variable int res es igual a cero 00:53:41
Me crea esta variable 00:53:45
Int op es igual a dos 00:53:46
¿Qué hace? 00:53:49
Crea otra variable 00:53:51
Que dentro le pone dos 00:53:52
Res es igual a op más uno 00:53:54
Cambia en res 00:53:57
Y le pone ¿cuánto? 00:54:01
Lo que hay dentro de op 00:54:04
más 1. Dentro de OPT, ¿qué hay? 2. 2 más 1, 3. Lo repito, RES es 0. OPT es 2. Ahora me dice, dentro de RES, pone el resultado de esta operación. 00:54:08
¿Cuál es el resultado de la variación? 00:54:31
OP vale 2. 00:54:32
Esto vale 1, 2 más 1, 3. 00:54:35
Este 3 lo guardas dentro de RES. 00:54:39
Creo que aquí hay un pequeño paso hacia adelante del número de la variable. 00:54:45
¿Dudas? 00:54:49
Vale. 00:54:51
OP, esta, es igual a RES más RES por OP. 00:54:52
¿Cuánto pongo allí dentro? 00:55:02
aquí alguien me ha dicho 12 00:55:04
¿quién está de acuerdo con 12? 00:55:28
¿quién no está de acuerdo con 12? 00:55:30
¿y cuánto es para vosotros? 00:55:34
que hay de nuevo aquí que es un poquito raro 00:55:35
pero que hay que hay diferente por respeto a todo lo que hemos hecho ahora aquí en esta cosa 00:55:44
está haciendo la operación 00:56:02
solo con los números de las variables 00:56:06
yo creo que lo que pasa 00:56:07
es que en la diapositiva anterior 00:56:10
has neutralizado variables 00:56:12
y luego cuando has modificado 00:56:14
el valor de cada una 00:56:15
realmente lo estás modificando 00:56:17
y cambiándolo de nuevo 00:56:20
pero aquí en la siguiente diapositiva 00:56:21
estás utilizando el valor del último valor 00:56:23
que se ha quedado en la variable 00:56:26
aquí estoy utilizando 00:56:27
variables también a la derecha 00:56:29
del igual 00:56:32
antes la usaba solo a la izquierda 00:56:32
pero también 00:56:35
en esta última hago una cosa rara 00:56:36
que es 00:56:39
usar 00:56:40
la misma variable 00:56:43
a la izquierda 00:56:45
y a la derecha 00:56:47
esto es subtil 00:56:48
acordaos que cuando se hace una cosa así 00:56:52
siempre antes 00:56:55
se hace la operación 00:56:57
y una vez que he evaluado la operación 00:56:58
y tengo el resultado 00:57:01
a este punto 00:57:02
lo guardo, porque no es tan obvio 00:57:04
porque si yo estoy usando op aquí 00:57:08
y aquí op, no es que le estoy 00:57:10
dando un valor y luego lo reuso aquí 00:57:12
y si op vale eso 00:57:14
no sé si me explico lo que quiero decir 00:57:16
no es que esto es 12, porque el resultado de esto 00:57:17
es 12, entonces cuando uso 12, 12 00:57:20
entra en un bucle, no, vale 00:57:22
antes me olvido del operador este aquí 00:57:23
hago la operación a la derecha 00:57:26
hago la multiplicación que tengo que hacer 00:57:28
y luego esta es la operación, y como hago la 00:57:30
operación, pues sustituyendo 00:57:32
cuando escribo res, escribo lo que está dentro de res 00:57:33
3, 3 es 3 00:57:38
y op es 2, entonces esto es 3 más 3 00:57:41
entre paréntesis por 2, 6 por 2 00:57:46
12, y el valor que sacaré aquí 12, lo guardo 00:57:49
dentro de op 00:57:53
¿Qué? Aquí, 12. 00:57:55
Entonces, si se pone ese mismo comando debajo más veces, va a seguir multiplicando el resultado anterior. 00:58:03
Si yo lanzo otra vez este mismo comando, me haría 3 más 3, 6, por 12. 00:58:10
Y 6 por 12 es un programa que, un cálculo que nadie puede hacer de mí. 00:58:18
¿Vale? 00:58:23
Ok. Vamos a ver esto entonces. 00:58:25
entonces 00:58:28
creo una palabra que se llama hola 00:58:34
una palabra que se llama 00:58:38
palabra y que tiene dentro el lo 00:58:40
esto 00:58:42
¿qué hace esto? 00:58:43
cambia lo que hay allí dentro 00:58:48
y le pone world 00:58:50
por lo tanto ahora allí dentro tengo solo world 00:58:51
vale, aquí 00:58:54
palabra es igual a el lo 00:58:58
más 00:59:01
world 00:59:02
¿qué es el más? 00:59:03
Nosotros estamos acostumbrados a que sea una suma. 00:59:09
Pero, ¿gato más cocodrilo cuánto hace? 00:59:16
Ni idea. 00:59:20
Esto porque el operador más es sobrecargado. 00:59:21
En Java tiene dos valores distintos dependiendo de si lo uso con palabras o lo uso con números. 00:59:26
Si lo uso con números, es el operador aritmético que todos conocéis. 00:59:35
Si lo uso entre palabras, o palabras con números, o palabras con cualquier otra cosa, 00:59:39
pues entonces, en vez de ser una suma aritmética, es una concatenación. 00:59:45
Píllame lo que está a la izquierda y pégale detrás lo que está a la derecha. 00:59:51
Entonces, esto hace que salga el logotipo. 00:59:55
Sería sin espacio, ¿vale? 01:00:07
esto sería en los bordes sin espacio 01:00:09
o pongo un espacio aquí 01:00:12
o si no son pegados 01:00:14
no hay ningún espacio aquí, esto es un typo 01:00:15
error, por lo tanto lo vais apuntando 01:00:18
ahí 01:00:21
y si hago esto 01:00:21
que sale ahí dentro 01:00:24
col 01:00:30
con pegado a 01:00:32
entonces hola 01:00:36
espacio a, espacio t 01:00:37
con pegado detrás a odos 01:00:40
hola a todos, ¿entiendes? 01:00:41
Sí, es la hora. 01:00:46
Venga, debo seguir. 01:00:50
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Autor/es:
Stefano Chiesa
Subido por:
Stefano C.
Licencia:
Reconocimiento - No comercial
Visualizaciones:
7
Fecha:
22 de septiembre de 2025 - 11:45
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
1h′ 00′ 53″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
510.79 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid