Saltar navegación

20250917-ProgEstr-Variables_1 - 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 17 de septiembre de 2025 por Raquel G.

20 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, bueno, pues ahora ya 00:00:00
¿Quiere la pizarra? 00:00:05
Sí, muy bonito, pero yo no quiero esto 00:00:25
Ahora, esto 00:00:27
Ahora sí, vale 00:00:30
El roto de pizarra 00:00:32
Dime 00:00:36
Vamos a empezar 00:00:43
programación estructurada, sí, un stream en particular 00:00:48
ahora no, ¿vale? 00:00:51
Sí, bueno pues entonces 00:00:52
Bueno, pues ahora ya sí que estamos 00:00:57
contextualizados 00:01:05
dentro de lo que es la 00:01:07
tarea del desarrollo 00:01:09
de software, que para nosotros 00:01:10
ahora mismo va a ser 00:01:13
hacer programas sencillos, eso va a ser 00:01:14
bueno, pues entonces para eso tenemos que seleccionar 00:01:18
primero una metodología de programación 00:01:22
en realidad no hay una única forma de programar 00:01:24
no hay una única metodología de programación 00:01:29
hay varias, pero en cuanto a metodología 00:01:31
de programación de propósito general 00:01:35
para resolver cualquier tipo de problemas 00:01:37
aplicaciones comerciales, etcétera 00:01:41
La metodología de programación que se usa es la programación estructural, entonces cuando se empezaron a desarrollar los primeros programas, sobre todo desde el momento en que ya se definió la arquitectura de Von Neumann famosa, pues en los 40, 50 o por ahí, 00:01:43
que no es más que un microprocesador que es capaz de leer sentencias de una memoria RAM, 00:02:19
hacer operaciones con ella y darme resultados a unos registros que a su vez se pueden mandar por buses a dispositivos. 00:02:28
Pues desde que se vio que ese modelo sobre el papel se podía ya implementar en un hardware como este, 00:02:36
dijo pues ahora ya 00:02:45
llega el momento de empezar a definir 00:02:46
posibles sentencias 00:02:50
pues había empezado lenguajes de pronunciación 00:02:51
a tutiplén, sentencias de todo tipo 00:02:53
cosas rarísimas, extrañísimas 00:02:55
pues desde los primeros lenguajes 00:02:57
hasta el basic, hasta no sé qué 00:02:59
entonces era un galimatía de lenguajes 00:03:01
un desastre, ahí nadie entendía nada 00:03:03
y los programas eran súper 00:03:05
rarísimos, un montón de líneas 00:03:07
que ahora de repente de aquí te ibas aquí 00:03:09
porque cambiabas de idea 00:03:11
eso no había manera de progresar 00:03:12
por ese camino 00:03:15
bueno 00:03:16
como habéis descansado el rato que estábamos con ellos 00:03:18
¿os hace falta descansar? 00:03:21
pues seguimos hasta las 2 y cuarto 00:03:24
por ahí y ya está 00:03:26
vale 00:03:27
entonces ahí había que poner orden 00:03:29
entonces todos los estudiosos 00:03:31
de la materia 00:03:35
matemáticos y todo eso 00:03:35
que son efectivamente 00:03:37
los que crearon 00:03:40
todas las técnicas de programación, pues se dieron cuenta de una cosa que recogieron en el famoso teorema de la estructura. 00:03:42
Entonces, el teorema de la estructura es un enunciado básico en programación, que lo podéis buscar en la Wikipedia, donde sea, 00:04:00
y dice lo siguiente, dice, cualquier cosa que yo pretenda que un ordenador que responda a la arquitectura de Von Neumann, 00:04:09
esta que os he dicho, o sea, un ordenador de toda 00:04:18
la vida, que yo 00:04:20
pretenda que un ordenador de toda la vida me resuelva 00:04:22
cualquier cosa que yo pretenda que me resuelva, 00:04:24
la puedo conseguir 00:04:28
con una secuencia exclusivamente 00:04:30
de tres 00:04:32
tipos de estructuras. O sea, la puedo 00:04:33
conseguir con una secuencia de 00:04:36
sentencias de este tipo. Es decir, 00:04:38
este teorema de la estructura 00:04:41
diría, vale, 00:04:42
bueno, da igual, todo fue 00:04:49
más fácil. Este teorema de la 00:04:50
estructura diría, cualquier 00:04:52
problema que queramos que un ordenador 00:05:02
nos resuelva, se puede 00:05:04
resolver con 00:05:27
programas que usan solamente 00:05:29
tres cosas, que le decimos 00:05:30
qué cosas son. 00:05:33
Esto es lo que dice el tema de la estructura, lo que dice 00:05:51
con mis palabras, para intentar 00:05:53
que sea un poquito más comprensible 00:05:55
pero bueno, lo podéis buscar en la Wikipedia, donde sea 00:05:57
se puede resolver con programas 00:05:59
que incluye tres cosas 00:06:01
en realidad, tres conceptos, más 00:06:07
que de tres cosas, las vamos a llamar 00:06:08
tres conceptos 00:06:10
o tres tipos 00:06:12
de sentencias. 00:06:23
Lo queremos llamar así. 00:06:29
¿Y cuáles son esos tres conceptos básicos 00:06:37
o tres tipos de sentencias? 00:06:39
Lo estoy tuneando un poquito. 00:06:42
Lo digo porque si alguno lo busca por ahí, 00:06:44
lo estoy tuneando un poquito. 00:06:46
Pues la recogida 00:06:47
y la devolución de los datos. 00:06:49
¿Lo hizo lo mismo Luma o no? 00:07:03
No, no, no. 00:07:05
La recogida y devolución de los datos. 00:07:06
decisiones y bucles y todo eso puesto en secuencia que incluyen estaría mejor expresado si pusiéramos 00:07:10
que combinan estaría mejor expresado si pusiéramos que combinan bueno es un poquito túnel pero qué 00:07:29
significa significa yo tengo que resolver un problema pues calcula lees tres usuarios 00:07:47
saca el mayor de los tres 00:07:53
y el mayor de los tres 00:07:56
pues calcula cuántos años le faltan 00:07:57
para cumplir una edad 00:08:00
igual que la de su tío 00:08:02
yo qué sé, cualquier problema 00:08:04
que tengo que resolver 00:08:06
vale, pues yo ya me pongo a pensar en un algoritmo 00:08:06
pues da igual el problema que sea 00:08:10
da igual lo complicado que sea 00:08:11
da igual las operaciones que involucre 00:08:13
da igual lo que sea 00:08:15
siempre va a existir un programa 00:08:16
que lo resuelva 00:08:19
que es una lista de sentencias 00:08:20
una tras otra en secuencia 00:08:23
eso es importante 00:08:24
una lista de sentencias una tras otra 00:08:26
en secuencia 00:08:29
no hace ninguna falta 00:08:29
que se haga nada en paralelo para resolver 00:08:32
cualquier problema, no 00:08:34
siempre se va a poder 00:08:36
resolver con una lista de cosas 00:08:39
en secuencia 00:08:40
y que va a haber ahí en esa secuencia 00:08:41
pues la combinación que nosotros 00:08:44
veamos que funciona 00:08:46
pero solamente de estas cosas 00:08:48
recogida y devolución de los datos 00:08:50
eso es básico, hay que recoger los datos y devolverlos 00:08:52
pero bueno, eso no es nada 00:08:55
lee, escribe, lee, escribe 00:08:56
y luego 00:08:58
tomar decisiones 00:08:59
es decir, en función 00:09:02
de los datos 00:09:04
en función de una preguntita 00:09:06
en función de una condición 00:09:08
hago una cosa o hago la otra 00:09:10
eso es una decisión 00:09:12
en función de si una condición 00:09:14
sobre esos datos 00:09:16
ser mayor que cero 00:09:18
ser múltiplo uno del otro 00:09:20
En función de una condición, hacer una cosa o hacer otra, es decir, el programa se puede dividir por este camino o por esta en función de una condición. Eso es una decisión. Un bucle, ¿qué un bucle es? Yo tengo unas sentencias, pues mandarle al programa que las haga un montón de veces, que esté todo el rato haciéndolas. 00:09:21
las haga y vuelve arriba, ya las has hecho 00:09:43
pues vuelve arriba, ya las has hecho y vuelve 00:09:46
arriba, ya las has hecho y vuelve arriba 00:09:48
hasta que yo te diga, para, y entonces 00:09:50
ya continúas 00:09:52
entonces, la combinación 00:09:53
de mover los datos de acá 00:09:56
para allá 00:09:58
y hombre 00:09:58
a la vez que los mueves puedes 00:10:01
operar con ellos, sumar, restar y 00:10:04
veremos que operación, pero lo básico 00:10:06
mover los datos de acá para allá 00:10:08
decidir en función 00:10:10
de una condición si haces esto o haces 00:10:12
lo otro, eso es una decisión 00:10:14
o un bucle 00:10:16
que es, esto me interesa 00:10:18
hacerlo 27 veces 00:10:20
pues venga, ala 00:10:21
27 veces, esto 00:10:23
también es una sentencia 00:10:26
la decisión 00:10:27
es una sentencia, como ya veremos 00:10:30
y el bucle 00:10:32
es otra sentencia, como ya veremos, más compleja 00:10:33
la sentencia 00:10:36
n igual a 3 más 1 00:10:37
es una sentencia 00:10:39
la sentencia 00:10:41
haz 00:10:44
esto 27 veces 00:10:45
también es una sentencia 00:10:48
más compleja, pero también es una sentencia 00:10:50
en este caso es una sentencia 00:10:52
de bucle, porque es 00:10:54
haz esto 27 veces, también es una sentencia 00:10:56
otra sentencia posible, la decisión 00:10:59
que decimos, que es 00:11:02
si x es igual a 3 00:11:04
haz esto 00:11:06
eso también es una sentencia posible para el programa 00:11:07
un poquito más compleja que la de n igual a 2 00:11:10
porque implica 00:11:14
si x es igual a 3 hace esto 00:11:15
pero también es una sentencia 00:11:17
pues ya está, no hacen falta más tipos de sentencias 00:11:18
no hacen falta 00:11:22
combinando 00:11:22
y esa combinación dependerá 00:11:24
lógicamente de nuestro pensamiento lógico 00:11:26
que ha decidido cómo tiene que combinarlas 00:11:29
combinándolas en secuencia 00:11:30
tres decisiones 00:11:33
ahora un bucle, ahora una lectura de datos 00:11:35
ahora una decisión, ahora tres bucles 00:11:37
combinándolas en secuencia 00:11:39
tal y como nuestro pensamiento 00:11:41
lógico haya decidido 00:11:44
podemos resolver 00:11:45
cualquier problema 00:11:47
que pueda hacer una máquina de esas 00:11:49
y eso 00:11:52
no ha cambiado y eso sigue siendo así 00:11:53
y eso es así 00:11:55
una cuestión matemática 00:11:56
no hace falta nada más 00:11:58
nada más que combinar esas tres cosas 00:12:01
entonces 00:12:03
cuando ya por fin eso se 00:12:05
y se comprobó que era así, 00:12:07
empezaron a desaparecer los lenguajes 00:12:10
que se inventaban sentencias que hacían cosas raras. 00:12:12
Porque lo único que hacían era obtener programas muy complejos. 00:12:15
Entonces, a partir de ese punto, 00:12:21
empezaron a surgir los lenguajes de programación estructurados, 00:12:23
que se llamaban. 00:12:28
¿Y cuáles son los lenguajes de programación estructurados? 00:12:29
Lenguajes de programación que solo tienen estos tipos de sentencias. 00:12:32
Y no tienen nada más 00:12:36
¿Por qué? Porque no les hace falta nada más 00:12:38
No les hace falta nada más 00:12:40
Contener eso es suficiente 00:12:42
Ya está 00:12:44
Y todos los lenguajes 00:12:51
Que manejamos ahora mismo 00:12:54
Salvo los específicos para a lo mejor 00:12:55
Pues para 00:12:58
De programación funcional 00:13:00
Para matemáticas 00:13:02
que son programación funcional 00:13:03
pero son cosas muy concretas 00:13:06
todos son estructurados 00:13:07
¿qué es lo que han ido aportando? 00:13:09
la forma de organizar 00:13:13
el código 00:13:15
el código es estructurado siempre 00:13:15
pero ¿qué han aportado? 00:13:17
pues Java en particular 00:13:20
lo que fue pionera es 00:13:21
vamos a organizarlo en cachos diferentes 00:13:22
lo que os decía el primer día 00:13:26
porque si yo puedo hacerme 00:13:27
un programa estructurado solamente 00:13:30
con estos tres tipos 00:13:32
de cosas, me resuelve todo. 00:13:34
Pero me han salido 10.000 líneas. 00:13:36
Pues voy a dividirlo en tres cachitos 00:13:38
y cada cachito 00:13:40
una clase. Ya está, pero lo que hay 00:13:42
en cada clase es estructurado, es que no hay otra. 00:13:44
¿Vale? Luego, la programación 00:13:46
de entrada de objetos no es que sea una alternativa 00:13:48
a la estructurada. No. 00:13:50
La programación de entrada de objetos 00:13:52
incluye la estructurada 00:13:53
y cambia la forma de organizar 00:13:55
esos trozos 00:13:59
estructurados para facilitar la reutilización 00:14:00
nada más, pero todo 00:14:02
es estructurado dentro 00:14:04
bueno, pues entonces lo primero 00:14:05
que hay que aprender, cuando uno tiene que aprender a programar 00:14:10
que es lo más importante porque es lo que 00:14:12
te da el pensamiento lógico 00:14:14
es la programación estructurada 00:14:15
que es como con tu lenguaje de programación 00:14:17
puedes utilizar 00:14:20
estos tres tipos de sentencias, ver que sintaxis 00:14:21
tienen, etcétera, para construir tus códigos 00:14:23
y ya está 00:14:26
¿vale? 00:14:27
bueno, pues por eso este tema 00:14:28
es programación estructurada 00:14:31
bueno, los que ya habéis programado alguna vez 00:14:33
aunque sea con Scratch, en tercero de la ESO 00:14:51
la decisión y el bucle 00:14:53
os suena, aunque sea por un muñeco 00:14:55
que daba muchas volteretas 00:14:57
o se iba por un camino o se iba por otro 00:14:59
pues es eso, es lo mismo 00:15:00
se podría aprender programación estructurada 00:15:02
sin aplicar a ningún lenguaje 00:15:09
no hace falta 00:15:11
podemos incluso escribir en lenguaje 00:15:12
natural un programa 00:15:15
Por ejemplo, programa que me lea dos números y me diga el mayor de los dos 00:15:17
Por ejemplo, eso es un problema que a lo mejor yo quiero resolver con un ordenador 00:15:24
Te doy dos números y tu ordenador dime cuál es el mayor 00:15:28
Porque es que yo estoy un poco lento para eso 00:15:32
Pues eso sería, por ejemplo, un primer problema que queremos resolver 00:15:35
programa que recibe 00:15:42
dos números 00:15:49
y muestra 00:15:50
el mayor. 00:15:58
Claro, esto es como si fuera 00:16:03
en términos nuestros un ejercicio, 00:16:04
pero en términos generales 00:16:07
un problema que tú te has encontrado 00:16:09
que es, yo tengo dos números 00:16:11
y quiero saber cuál es el mayor. 00:16:13
Hombre, ese lo vas a saber resolver por ti mismo. 00:16:15
Pero imagínate que se lo quieres 00:16:17
dar a una máquina, ¿por qué? 00:16:19
Porque quieres hacer eso 00:16:21
200.000 veces. 00:16:23
Entonces, si lo tienes que hacer tú, dos números, el mayor es este, dos números, el mayor es este, dos números, el mayor es este, hasta que lo hagas 200.000 veces, te vas a estar un rato. 00:16:25
Entonces, a ver, espérate, voy a hacer esto en un ordenador, porque el ordenador, los números, a toda velocidad, los puede ir leyendo de donde sea, de un fichero, de donde sea, y a toda velocidad me va a dar los resultados, mucho más rápido de lo que yo lo haría. 00:16:35
que es para lo que en la mayoría 00:16:53
de los casos sabemos las cosas 00:16:55
porque lo hacen rápido 00:16:57
¿vale? entonces 00:16:59
pues entonces es un problema 00:17:01
que nos hemos encontrado que por la razón 00:17:04
que sea, que en este caso hemos dicho 00:17:05
porque él es más rápido que nosotros 00:17:07
y si lo quiero hacer 300 veces 00:17:09
pues mucho mejor que lo haga él que no que lo haga yo 00:17:11
con esta razón hemos decidido 00:17:13
que queremos que lo haga ordenado 00:17:15
¿vale? pues aquí 00:17:17
aquí no hay lenguaje de programación que valga 00:17:19
ni hay nada que valga. 00:17:21
Aquí lo primero que tenemos que pensar es un algoritmo. 00:17:23
Es lo primero que pensamos. 00:17:27
¿Qué algoritmo seguir para esto? 00:17:29
Todavía no he mencionado ningún lenguaje de programación ni nada. 00:17:36
¿Vale? 00:17:39
¿Algoritmo qué es? 00:17:41
Lo mencionamos el primer día en cuanto a sinónimo, 00:17:43
lo podíamos entender como sinónimo de programa. 00:17:47
Un algoritmo es una secuencia ordenada y finita de pasos para resolver un problema. 00:17:50
Eso es un algoritmo, secuencia ordenada y finita de pasos. 00:17:58
Venga, pues vamos a pensar qué secuencia ordenada de pasos puedo seguir yo para resolver esto. 00:18:03
Pues si vamos por orden, lo primero será leer los números. 00:18:12
Entonces, no voy a leer dos números de golpe, no puedo. 00:18:17
Al ordenador, el ordenador tiene sus limitaciones. 00:18:20
Entre ellas es que las cosas hay que dárselas una por una. 00:18:24
Vale, pues entonces, el algoritmo, ya tendríamos. 00:18:28
Primer paso del algoritmo, leer el numerito 1. 00:18:31
Ala, ya tengo el primer paso del algoritmo, bien. 00:18:39
Siguiente paso de mi algoritmo, necesito otro número más. 00:18:42
Pues venga, leer el segundo número. 00:18:46
Vale, aquí ya se me complica la vida. 00:18:54
para elaborar el algoritmo. 00:18:57
Entonces, aquí lo primero que tenemos que pensar, 00:19:00
una vez que hemos hecho la lectura de datos, 00:19:02
que esa es la más fácil, 00:19:03
¿qué datos necesito? 00:19:05
Estos. 00:19:06
Leer, leer, leer. 00:19:07
Ahí hay poco que pensar. 00:19:08
Leer los datos. 00:19:10
Vale. 00:19:10
Ahora ya es cuando tenemos que pensar, 00:19:11
vale, pero ¿qué operaciones tengo que hacer aquí? 00:19:14
Porque si lo tengo que dar todo muy más caro y detallado. 00:19:16
Desde luego, el siguiente paso no podría ser al ordenador 00:19:18
decir el mayor. 00:19:23
Este no es un paso válido para un algoritmo, porque el ordenador no sabe, no sabe, al ordenador hay que dárselo todo en términos de operaciones algebraicas que son las únicas que sabe hacer, algebraicas y lógicas, hemos dicho que un ordenador es una unidad aritmético-lógica que hace operaciones aritméticas, sumas, restas y lógicas, ah, Dios, y ya está, vamos a hacer más que eso, entonces el concepto de dime el mayor, ¿qué me estás contando? 00:19:28
con lo cual esto como algoritmo no nos vale 00:19:54
pues entonces 00:19:57
uy no yo quería esto 00:19:58
pues entonces como ya se nos ha complicado la cosa 00:20:00
porque eso no nos vale como paso del algoritmo 00:20:04
ni por tanto nos valdrá como paso 00:20:07
del programa no nos valdrá 00:20:08
para arrancar a pensar 00:20:10
lo más fácil es que 00:20:12
nos situemos al final siempre 00:20:14
que es a donde quiero llegar 00:20:16
a donde quiero llegar yo 00:20:18
yo quiero llegar 00:20:20
a un resultado 00:20:22
final que tengo, que está 00:20:24
entre dos opciones. Mi resultado 00:20:26
final, que no sé qué paso será, 00:20:29
el D, el E, el F, no lo sé. 00:20:30
Mi resultado final 00:20:33
yo sé que va a ser 00:20:34
muestra num1 00:20:37
o muestra num2. 00:20:39
Eso el ordenador sí que sabe. 00:20:41
Mostrar 00:20:43
y leer sí sabe. 00:20:44
Vale, pues entonces yo sé que hay 00:20:47
al final 00:20:48
el algoritmo 00:20:49
tiene que hacer 00:20:51
una de dos cosas 00:20:53
y no más 00:20:56
al final mi algoritmo va a hacer 00:20:57
o mostrar 00:21:00
num1 00:21:02
vamos a suponer que no le damos números iguales 00:21:04
porque si no simplemente lo que cambiaría 00:21:07
sería que puede mostrar tres cosas 00:21:10
mostrar num1, mostrar num2 00:21:12
o mostrar el mensaje son iguales 00:21:14
ni siquiera, vamos a dejarlo en dos posibilidades 00:21:17
asumimos que siempre le vamos a dar 00:21:19
números distintos 00:21:21
Pues entonces, para seguir pensando el resto del algoritmo, repito, 00:21:23
lo más fácil es que yo me vaya al final y diga, pero vamos a ver, 00:21:28
¿yo qué espero del programa? ¿Qué espero? 00:21:31
Pues espero que al final pase una de estas dos cosas. 00:21:33
O mostrarme un 1 o mostrarme un 2. 00:21:38
Vale, pero claro, ¿cuál de las dos es? 00:21:42
Porque un programa no puede hacer dos cosas, 00:21:46
tiene que hacer una secuencia de pasos definida. 00:21:49
Pues entonces, aquí es donde decimos, vale, ¿qué decía la programación estructurada? 00:21:52
Que tú puedes incluir decisiones o bucles. 00:22:01
Una decisión que es hacer una cosa o hacer otra en función de una condición. 00:22:05
Ah, vale, vale, eso encaja con lo que yo quiero. 00:22:14
Porque mi programa o bien va a hacer esto o bien va a hacer esto otro, 00:22:16
en función de si 00:22:20
NUM1 es mayor que NUM2 00:22:23
o si NUM2 es mayor 00:22:25
que NUM1. Eso ya es 00:22:27
estructural, porque eso 00:22:29
ya es una decisión, que es 00:22:31
si esto pasa, hace esta cosa 00:22:33
que lo que no sabe hacer, que es mostrar 00:22:35
y si no pasa, hace esta otra. 00:22:37
Eso ya si es 00:22:41
algo de población estructurada, que podemos poner 00:22:41
en nuestro algoritmo. Pues magnífico, 00:22:43
lo podríamos poner como nuestro tercer 00:22:46
paso. ¿Vale? Lo estoy poniendo 00:22:47
como ejemplo, ahora mismo no estamos viendo 00:22:49
sentencias de decisión ni de nada, entonces mi algoritmo 00:22:52
podría seguir ahora ya así, oye 00:22:57
si resulta 00:23:02
que num1 es mayor que num2 00:23:05
si resulta esto 00:23:09
pues entonces muestra 00:23:13
el num1 00:23:17
por ejemplo 00:23:18
y podría escribir aquí 00:23:21
Si num2 es mayor que num1 00:23:25
Muestra num2 00:23:32
Y mi programa habría terminado 00:23:38
Fin 00:23:41
Vale, con esto es lo único que quiero decir 00:23:42
Varias cosas 00:23:47
Primera 00:23:47
Que para aprender a programar en programación estructurada 00:23:48
Yo no necesito ningún lenguaje de programación 00:23:51
¿Vale? 00:23:54
Porque programar es elaborar algoritmos 00:23:55
La traducción de esto 00:23:58
A Java, Python, ASEA 00:24:00
lo que a mí me dé la gana ya es inmediato. Lo difícil es hacer la secuencia de pasos 00:24:02
que resuelven el problema. Y esa secuencia de pasos solo puede involucrar sentencias 00:24:08
de aprobación estructurada, que serían leer y mostrar datos, como en este caso esto que 00:24:15
es leer datos y aquí que estamos devolviendo, decisiones, lo que hemos hecho aquí, aunque 00:24:22
Eso ya lo veremos más en detalle, cómo funciona 00:24:30
una decisión. Si pasa 00:24:32
esto, haz una cosa. 00:24:34
Eso es una decisión, pues la puedo incluir en mi 00:24:36
algoritmo. Y bucles 00:24:38
que aquí no nos han hecho falta. No nos han hecho falta 00:24:40
pero nos pueden haber hecho. 00:24:42
Esto ya es un algoritmo 00:24:44
de programación estructurada, perfecto 00:24:45
porque solo involucra eso. 00:24:48
Y yo lo puedo pasar a un 00:24:50
lenguaje de programación estructurada y tengo el programa hecho. 00:24:52
Lo que pasa es que nosotros, desde el principio 00:24:54
ya vamos a trabajar con un 00:24:56
lenguaje de programación 00:24:58
pues para facilitar 00:24:59
la ejecución, la comprobación 00:25:01
de si está bien, está mal y por optimizar 00:25:04
y por ir más rápido 00:25:06
pero podríamos trabajar en esto 00:25:07
que se podría llamar 00:25:10
pseudocódigo 00:25:12
¿qué es un pseudocódigo? 00:25:13
un lenguaje parecido 00:25:16
al natural 00:25:18
en el que tú escribes programas 00:25:18
que no se corresponden con ningún lenguaje 00:25:21
de programación y que por tanto ni ejecuta 00:25:24
ni nada, porque no se corresponden con ningún 00:25:26
lenguaje 00:25:27
esto podría ser una especie 00:25:28
de pseudocódigo 00:25:30
dime 00:25:31
si, claro, a ver 00:25:33
lo que no sabes entender, dime cuál es mayor 00:25:42
pero los operadores 00:25:45
los entiende, el más, el menos 00:25:46
los operadores aritméticos 00:25:48
y los relacionales los entiende 00:25:50
que son los que vamos a ver, entonces 00:25:52
el operador este es un operador relacional 00:25:54
mayor que, lo entiende 00:25:56
si tú le dices 3 mayor que 2 00:25:58
él te va a decir, ¿verdad? 00:26:00
si le dices 3 00:26:03
mayor que 7, él te va a decir, mentira 00:26:04
o sea, los operadores estos 00:26:06
los conoce, lo que no 00:26:08
entiende es una sentencia del tipo 00:26:10
dime cuál es mayor de los dos 00:26:12
no, pero si tú le das 00:26:14
una sentencia de decisión en la que le dices 00:26:16
la operación que tiene que hacer 00:26:18
él no sabe, que para saber si uno es mayor 00:26:20
que otro, él no sabe que tiene que usar 00:26:22
este operador, él no lo sabe 00:26:24
tú se lo tienes que decir, le dices 00:26:26
este operador 00:26:28
si es mayor 00:26:30
si esto es 00:26:31
verdad, me devuelves esto 00:26:34
¿vale? pero bueno, todo esto 00:26:37
precisamente es lo que tenemos que ir desarrollando 00:26:38
esto lo ponía como ejemplo 00:26:41
de que 00:26:43
programar es elaborar algoritmos 00:26:44
que usando sentencias de parámetro estructurada 00:26:46
resuelven el problema que sea 00:26:49
desde partida vamos a usar 00:26:51
Java nosotros 00:26:55
¿Vale? Y traducir esto a Java 00:26:56
Pues sería inmediato 00:26:57
Pero podríamos aprender a programar 00:26:58
Sin usar ningún lenguaje de programación 00:27:02
Sí 00:27:03
Pero bueno, vamos a empezar 00:27:04
Usando este 00:27:06
Para que sea un poquito más 00:27:09
Más dinámico 00:27:13
Vale, pues primeros conceptillos 00:27:15
Que vamos a ir introduciendo 00:27:19
Para que podamos empezar a ir haciendo las primeras cosas 00:27:20
Aunque sean sencillas 00:27:23
Primera cosa 00:27:24
Importantísima, importantísima 00:27:27
importantísima. Los programas 00:27:29
trabajan con datos. 00:27:33
Si no, no valen para nada. 00:27:35
¿Verdad? Si un programa no tiene 00:27:37
datos con los que trabajar... 00:27:39
Pero esto es aparte de lo de antes, ¿no? 00:27:40
Es como aplicarlo con Java. 00:27:45
Sí, sí, sí. O sea, lo de antes 00:27:47
era un ejemplo 00:27:49
con el que los quería ilustrar 00:27:51
que programar no es 00:27:53
usar un lenguaje de programación. 00:27:55
Programar es diseñar 00:27:57
algoritmos para que resuelvan 00:27:59
problemas. Es decir, es el pensamiento lógico 00:28:01
que te lleva a ti 00:28:03
a decidir qué pasos 00:28:05
resuelven el problema. Pero eso 00:28:08
es independiente de cualquier lenguaje de programación. 00:28:09
Entonces, lo que hemos hecho antes nosotros 00:28:11
es programar, pero no lo hemos aplicado 00:28:13
a ningún lenguaje. Y ahora 00:28:15
lo que os digo es, vamos 00:28:17
a programar, pero ya directamente 00:28:19
usando el lenguaje 00:28:21
para escribir ya directamente la sentencia. 00:28:24
Exacto. 00:28:26
Sí, bueno. 00:28:27
Bueno, eso de antes no. 00:28:29
ese programa en particular no 00:28:30
bueno, pues entonces 00:28:32
ahora ya sí que empezamos en Java 00:28:35
empezamos con Java 00:28:37
entonces 00:28:38
primera cosa que tenemos que entender 00:28:40
que yo creo que es evidente para todos, para empezar a introducir 00:28:42
los primeros conceptos 00:28:45
¿cómo la batería se está agotando? 00:28:47
ah, claro, es que no puede ser 00:28:49
si esto está 00:28:51
¿cómo funciona este? 00:28:52
a ver un momentito 00:29:01
tú 00:29:02
tienes, vale 00:29:05
Bueno, pues a ver 00:29:13
Bueno, pues 00:29:14
Para introducir el primer concepto básico 00:29:19
Que es el de variables 00:29:22
Para introducir el primer concepto básico 00:29:23
Que es el de variables 00:29:25
Tenemos que entender que 00:29:25
Cualquier programa 00:29:28
Que utiliza datos 00:29:30
Los programas necesitan 00:29:34
Datos para trabajar, ¿verdad? 00:29:42
El primer programita que hemos hecho nosotros 00:29:48
El de saludar 00:29:50
Ese no necesitaba ningún dato 00:29:51
ese no, porque eso lo que hacía era 00:29:53
hola, ya está 00:29:55
si lo hubiéramos cambiado 00:29:56
para que me saludara 00:29:59
para que saludara a la persona 00:30:01
que lo ejecuta 00:30:03
vale, si lo hubiéramos hecho 00:30:05
una primera modificación 00:30:07
para conseguir un programita 00:30:09
más sofisticado 00:30:11
que saludara a la persona 00:30:12
que lo ejecuta 00:30:15
ahora ya si necesitaría un dato 00:30:16
que es 00:30:19
el dato de la persona que lo ejecuta 00:30:20
Entonces, ese programa, lo primero que haría sería, ¿cómo te llamas? 00:30:23
Tú le das ese dato y ahora ya el programa te saludaría. 00:30:27
Hola, Pepito. 00:30:31
¿Vale? 00:30:32
Entonces, en general, cualquier programa necesita datos para trabajar, 00:30:33
salvo excepciones como el Hola Mundo de ayer. 00:30:39
Claro, cualquier otro necesita datos para trabajar. 00:30:41
Eso está claro. 00:30:44
Pues, entonces, lo primero que tenemos que ver en Java, 00:30:45
antes de poder hacer cualquier programa, 00:30:47
es donde guardamos los datos 00:30:49
con los que el programa tiene que trabajar. 00:30:53
¿Dónde los guardamos? 00:30:56
Bueno, pues los datos de trabajo del programa 00:30:59
tienen que estar sí o sí, 00:31:01
para eso sí que no hay alternativa, 00:31:18
en variables. 00:31:21
Tienen que estar en una cosa o en muchas, 00:31:27
si son muchos datos, 00:31:30
que se llamen variables. 00:31:32
Un programa no puede trabajar con nada que no esté en una variable. 00:31:34
Entonces, lo primero que tenemos que hacer es desde nuestro programa, 00:31:42
desde nuestros programas en Java, saber cómo crear esas variables 00:31:54
para poder meter en ellas datos. 00:31:58
Entonces, el primer concepto. 00:32:02
El primer concepto es el concepto de variable básico en programación. 00:32:03
Es el concepto más importante de la programación variable, 00:32:06
variable porque todo aquel dato con el que el programa tenga que trabajar tiene que estar en 00:32:09
una variable eso no tiene pero que valga bueno pues vamos a ver un poquito más que es una variable 00:32:14
que es una variable una variable es una cajita para guardar un dato esto es una variable entonces 00:32:24
El programa, nosotros le diremos cuáles son las cajitas en las que están sus datos 00:33:01
y tendremos que aprender cómo llenar esas cajitas con los datos 00:33:11
y cómo sacar esos datos de las cajitas, lógicamente. 00:33:14
Una variable es eso, una caja para guardar un dato. 00:33:18
Puedes guardar uno, lo que pasa es que ese dato puede ser un objeto 00:33:24
y un objeto es una variable gorda con muchos datos dentro. 00:33:27
Entonces, con el matiz de solo puedes guardar uno, sí, solo puedes guardar uno. Pero ese dato puede ser un objeto. Y un objeto puede tener a su vez millones de cosas dentro. Pero dejémoslo por ahora así, ¿vale? 00:33:31
Entonces, la cajita, para que el programa, para poder decirle yo a qué cajita se refiere, porque un programa puede tener mil variables, mil cajitas con mil datos, pues para decirle al programa, oye, usa esta, usa la otra, usa esta otra. 00:33:44
lo normal es que la cajita tenga su nombre 00:34:01
entonces cada cajita 00:34:04
recibe un nombre 00:34:05
luego cada variable 00:34:07
siendo variable el sinónimo de mi cajita 00:34:14
cada variable tiene su propio nombre 00:34:16
cada variable 00:34:19
tiene su propio nombre 00:34:21
entonces la variable involucra por tanto 00:34:22
dos conceptos, dos ideas 00:34:26
su nombre 00:34:28
y el dato que tiene dentro 00:34:29
que son dos cosas distintas 00:34:32
por ejemplo esta variable 00:34:34
se podría llamar a lo mejor 00:34:36
números, y eso es 00:34:38
el nombre de la variable 00:34:40
yo lo decido, ahora veremos como 00:34:41
desde código, creo una 00:34:44
variable o una cajita y la 00:34:46
llamo num, ahora lo haremos en código 00:34:48
pero eso es lo primero que tenemos que hacer 00:34:50
vale, pues 00:34:52
esta variable o cajita se llama 00:34:54
num, porque yo lo he decidido 00:34:56
y a partir de ahí 00:34:57
puede guardar 00:34:59
el dato que a mi me dé la gana 00:35:01
con las restricciones que ahora veremos 00:35:04
qué dato guardará el que yo quiera 00:35:05
siempre el mismo 00:35:09
no, esa cajita puede ir cambiando 00:35:10
a veces guarda un 3, a lo mejor luego guarda un 7 00:35:12
va cambiando 00:35:15
por eso se llama variable 00:35:16
porque su contenido puede 00:35:18
variar, su nombre no varía jamás 00:35:20
su nombre es num 00:35:22
no varía, yo soy la cajita num 00:35:24
qué dato voy a tener dentro 00:35:26
lo que me quieran meter 00:35:28
cuando quieran en cada momento 00:35:30
me da lo mismo 00:35:32
dos variables distintas 00:35:33
cada una tiene su dato distinto 00:35:39
que a su vez puede ir variando si hiciera falta 00:35:41
que no es el caso 00:35:44
uno y dos serían variables 00:35:44
no, eso serían datos contenidos en banco 00:35:47
uno y dos serían 00:35:50
nombres de dos variables 00:35:54
efectivamente 00:35:55
y dentro iría 00:35:56
el dato que tú le das cuando ejecutas 00:36:00
el programa, a lo mejor la primera vez 00:36:02
le das 3 y 2 00:36:04
y en ese momento la variable en un 1 00:36:05
tiene dentro el 3 y la variable en un 2 00:36:08
tiene dentro el 2, pero a lo mejor dentro de 2 horas 00:36:10
haces otra ejecución 00:36:12
entonces la variable en un 1 que se sigue 00:36:13
grabando en un 1, ahora tiene el 7 00:36:16
y la variable en un 2 que se sigue 00:36:18
grabando en un 2, ahora tiene el 8 00:36:20
luego la variable es 00:36:21
una caja que tú creas cuando 00:36:23
arranca el programa o en cualquier momento 00:36:26
de repente sea cuando arranca, que está 00:36:28
pensada para recibir 00:36:30
un dato 00:36:32
el dato puede ser cualquiera 00:36:32
el que a ti te interese en cada momento 00:36:35
¿vale? 00:36:38
pero la cajita una vez que ha recibido 00:36:40
un nombre, ese es su nombre 00:36:42
en el ejemplo anterior 00:36:43
efectivamente, que habíamos mencionado un poco 00:36:46
por encima, solamente para ver el lenguaje natural 00:36:48
teníamos dos cajitas 00:36:50
num1 y num2 00:36:52
su contenido 00:36:53
yo lo varío en función de los dos 00:36:55
números que quiera comparar 00:36:58
si quiero comparar el 3 y el 7 00:36:59
num1 recibe el 3 y num2 00:37:01
recibe el 7, que quiero comparar 00:37:03
el 15 y el 23, num1 00:37:05
recibe el 15 y num2 el 23 00:37:07
num1, num2 00:37:10
los nombres de las variables 00:37:12
el dato 00:37:14
el que me interese a mi en cada momento 00:37:15
¿vale? 00:37:18
primera cosa distinguir 00:37:19
nombre de variable 00:37:20
dato que recibe dentro que es 00:37:22
variable, que puede cambiar 00:37:25
pues cuando uno 00:37:27
hace un programa, pues 00:37:29
primero tiene que hacer 00:37:31
lo que se llama en el desarrollo de software 00:37:33
la fase de análisis 00:37:35
que es una fase importantísima 00:37:36
que esa no tiene nada que ver ni con 00:37:39
entornos de desarrollo, ni con programas, ni con 00:37:41
código, eso tiene que ver con un cerebro 00:37:43
un papel y un lápiz, que es 00:37:45
¿de qué va este programa? 00:37:47
¿cuántos datos va a manejar? 00:37:49
¿muchos, pocos? 00:37:51
¿cuántas variables me va a interesar que tenga? 00:37:53
¿de qué tipo van a ser? ¿son números, son letras? 00:37:55
o sea, una especie de visión global 00:37:57
de de qué va el rollo 00:37:59
eso es lo que hace el analista 00:38:00
se aproxima al problema a ver de que va 00:38:02
y va ilustrando 00:38:04
con pinceladas 00:38:07
su posible solución 00:38:08
y luego ya 00:38:10
después de que ha acabado el analista 00:38:12
que es al que le han pagado 00:38:15
muchísimo más que a nadie 00:38:16
pues ya llega el programador 00:38:18
que ya hace la parte fácil 00:38:20
que es con el lenguaje de programación que sea 00:38:22
pues ya programa 00:38:24
bueno pues entonces 00:38:25
nosotros en nuestra pseudo fase 00:38:28
de análisis, porque nuestros programas son sencillos 00:38:30
pues en nuestra pseudo fase de análisis 00:38:32
cuando nos dan un enunciado 00:38:34
después de leerlo dos, tres, cuatro veces 00:38:36
lo primero 00:38:38
que nos ronda por la cabeza 00:38:40
nos tiene que rondar por la cabeza es 00:38:42
¿cuántas variables yo necesitaría? 00:38:44
en el programa anterior 00:38:47
rápidamente diríamos, como el programa 00:38:48
es, lee dos números 00:38:50
y dime cuál es mayor 00:38:52
voy a necesitar dos cajitas 00:38:54
una cajita para el primero y otra para el segundo 00:38:55
¿Vale? Pero todo eso 00:38:58
lo vamos pensando 00:39:00
en sucesivas lecturas 00:39:01
del enunciado 00:39:04
y cuando ya tenemos un diseño, lo tenemos pensado 00:39:04
en la cabeza, ya empezamos a escribir 00:39:08
¿Vale? Bueno, pues cuando 00:39:09
uno ya ha llegado a la conclusión 00:39:12
de que necesita una variable 00:39:13
para un dato, por la razón que sea 00:39:16
pues ahora ya puede 00:39:17
en Java escribir 00:39:19
la sentencia que te crea 00:39:22
esa cajita, le da el valor 00:39:24
lo que haga falta 00:39:26
¿Vale? 00:39:26
Bueno, pues entonces, ¿está claro, no? 00:39:28
Que una variable es un espacio, lo que yo digo cajita es un espacio en la memoria RAM, lógicamente. 00:39:31
¿Esta cajita físicamente dónde está? 00:39:37
Pues en la memoria RAM. 00:39:40
Luego la memoria RAM no solo va a tener el código que se va ejecutando, 00:39:44
eso va a tener que estar ahí sí o sí. 00:39:48
En la memoria RAM también habrá un cacho ahí reservado para las variables, 00:39:50
Aunque eso a nosotros nos da igual, ni lo vemos ni nos importa. 00:39:56
Pero bueno, es importante que sepamos que todas las variables que nosotros vamos a crear en nuestros códigos, 00:40:01
todas ellas son cajitas o espacios de memoria que van a estar aquí en la RAM. 00:40:09
Cada variable es un espacio de memoria en la RAM. 00:40:15
Y ese espacio de memoria, ¿para qué está pensado? 00:40:20
Para guardar un dato, un dato que irá cambiando. 00:40:23
según el programa vaya necesitando 00:40:25
bueno, pues ahora sí que vamos a ver 00:40:28
en código, cómo poder 00:40:32
crear esas 00:40:34
variables, vale, vamos a suponer 00:40:35
que yo ya tengo 00:40:48
mi class bla bla bla 00:40:48
y mi main bla bla bla 00:40:55
o sea, me ahorro todo esto para no escribirlo 00:40:57
todo el rato, vale, esto ya lo tengo 00:40:58
escrito, me lo ahorro para no escribirlo todo el rato 00:41:00
ahora ya me voy al bloque de código 00:41:03
en el que voy a escribir cosas, ya me voy a ese bloque 00:41:04
de código, vale, ahora 00:41:07
lo hacemos y nos da tiempo en el eclipse 00:41:09
vale, pues 00:41:10
vamos a 00:41:13
crear una variable 00:41:15
vamos a crear la variable num1 00:41:16
por ejemplo 00:41:19
antes de crear una variable 00:41:20
lo primero yo tengo que decidir el nombre 00:41:22
de la variable 00:41:24
entonces, esto es lo mismo que 00:41:25
el nombre del programa este 00:41:28
después del class que decíamos el otro día 00:41:30
el nombre de variable 00:41:32
que esté lo mejor elegido 00:41:34
posible, porque eso va a hacer 00:41:36
que nuestro programa sea lo más legible 00:41:38
o entendible posible. 00:41:41
Entonces, si yo tengo una variable 00:41:44
para guardar la edad de un usuario, 00:41:45
a esa variable la llamaré edad, 00:41:49
no la llamaré x. 00:41:52
Si la llamo x, 00:41:54
lógicamente al compilador le da igual, 00:41:56
pero ese programa está mal escrito. 00:41:58
El que tenga que arreglarlo, 00:42:01
el que lo abra, 00:42:02
¿qué sería x? 00:42:02
Tendría que empezar a mirarlo. 00:42:05
Pero si le llamas edad, 00:42:06
ya empieza a entender un poquito más 00:42:08
de qué van esas sentencias, ¿vale? 00:42:10
Luego, nombres de variables, de nuevo, 00:42:12
como pauta de programación, 00:42:16
no como obligación del lenguaje, 00:42:19
bien elegidos. 00:42:22
Pues venga, por ejemplo, pues ya está, 00:42:24
vamos a hacer una variable 00:42:26
y le voy a dar yo el nombre de edad, 00:42:27
porque en mi programa, a ver, os veo inquietos, 00:42:30
¿eso es porque es tarde? 00:42:33
Eso ni cuánto, vale, no, nos vamos a ir ya. 00:42:34
vale, vamos a crear una variable 00:42:36
para guardar la edad 00:42:39
de una persona, porque yo necesito 00:42:41
un programa que trabaja con la edad de una 00:42:43
persona, para ese es mayor de edad, lo que sea 00:42:45
primero 00:42:46
pienso el nombre 00:42:48
nombre 00:42:50
lo más descriptivo posible 00:42:52
edad, vale 00:42:54
pero no puedo poner edad sin más 00:43:02
si hay la variable aparecido 00:43:04
aquí ya estoy escribiendo código, esto es lo que iría 00:43:06
dentro de ese mail famoso de esas llaves 00:43:09
vale, ¿qué tengo que hacer? 00:43:11
siguiente cosa que pienso 00:43:14
oye, esta cajita 00:43:15
edad que yo he creado 00:43:18
aquí, esta cajita edad 00:43:20
¿qué tipo de dato va a 00:43:21
contener? ¿va a contener 00:43:24
números o va a contener caracteres? 00:43:26
y en función 00:43:29
de eso 00:43:30
ponemos aquí, que ya vemos 00:43:30
mañana o el jueves, el tipo 00:43:33
de dato que va a contener 00:43:35
que ya nos da tiempo 00:43:37
terminamos con punto y coma 00:43:39
y la cajita está creada 00:43:41
¿vale? 00:43:43
pero vamos a dejarlo aquí 00:43:44
¿qué tenemos que ver ahora? 00:43:45
me has dicho que tienes que poner ahí un tipo 00:43:49
un tipo de dato 00:43:52
pues ¿qué tipos de datos tengo? 00:43:53
pues unos 4 00:43:55
¿vale? 00:43:56
ya los vemos el próximo día 00:43:58
para poder empezar a trabajar con las primeras variables 00:43:59
ahora nos quedamos con esto 00:44:01
y ya está 00:44:02
¿vale? 00:44:04
pues 00:44:04
Gracias. 00:44:08
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
20
Fecha:
17 de septiembre de 2025 - 18:34
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
44′ 12″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
2.95

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid