Saltar navegación

20240917 ProgrEstruct-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 2024 por Raquel G.

21 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, pues entonces vamos a seguir el paradigma de programación estructurada, que es la que se usa siempre en las aplicaciones comerciales. 00:00:04
Lo que estaba diciendo, cuando se empezó la programación, empezaron unos primeros lenguajes, el BASIC famoso, incluso el COBOL, algunos lenguajes que no eran estructurados. 00:00:12
¿Qué significaba que no fueran estructurados? 00:00:22
Pues significaba que daban lugar a códigos un poquito desorganizados, que usaban muchos tipos de sentencias, aparte de estas tres que os he dicho. 00:00:25
leer y escribir datos 00:00:32
decisiones y bucles 00:00:34
usaban sentencias del tipo 00:00:36
¡sáltate a la línea tal! 00:00:38
pues un programa que ¡sáltate a la línea tal! 00:00:40
es complicadísimo de seguir 00:00:42
se pierde un poquito la coherencia 00:00:44
entonces, como esos programas 00:00:46
eran tan complicados de mantener y de todo 00:00:48
pues allá por hace muchísimo tiempo 00:00:49
que lo tenéis en los apuntes 00:00:52
de resumencillo que tenéis ahí 00:00:54
¿vale? pues dijo 00:00:56
vamos a hacer programación estructurada 00:00:57
que es lenguajes que solamente 00:01:00
usen esto que digo de entrada 00:01:02
a salida de datos, decisiones 00:01:04
y bucles, ya está, porque con eso 00:01:06
con eso se puede hacer cualquier 00:01:08
se puede resolver cualquier problema 00:01:10
que le puedas encargar a una CPU 00:01:12
eso se demostró en el teorema de la estructura 00:01:14
y en todo eso, con lo cual 00:01:16
si nos restringimos esos tres tipos 00:01:18
de sentencias, pues ya vamos a 00:01:20
entendernos todos mejor, incluso 00:01:22
trabajando en diferentes tipos de lenguaje 00:01:24
eso es la programación 00:01:26
estructurada, vale, luego ya 00:01:28
dije ayer, que los programas 00:01:30
estructurados pueden ser larguísimos 00:01:32
pues vamos a organizarlos 00:01:34
en módulos separados, de ahí ya vino 00:01:36
la programación orientada a objetos, que lo organizaba 00:01:38
en clases, ¿vale? Eso ya lo veremos en el 00:01:40
tema de programación orientada a objetos, ya nos vamos a quedar 00:01:42
en estructurada, que es la base de todo. 00:01:44
Bueno, ¿en qué lenguaje lo vamos 00:01:47
a ver? Ya sabemos que en Java, entonces 00:01:48
vamos a empezar ahora mismo 00:01:50
por lo básico de Java, 00:01:52
que es vamos a empezar a declarar 00:01:54
variables 00:01:57
para que vayan en ella 00:01:58
mis datos y ver cómo trabajar en ellas 00:02:00
y ya está 00:02:02
entonces, aquí tenéis un resumencito 00:02:03
muy resumido 00:02:06
de toda esta primera parte 00:02:07
que no es nada 00:02:10
y luego ya 00:02:12
lo siguiente ya pasaremos a la sentencia 00:02:14
de decisión, que a vosotros ya la tenéis oculta 00:02:16
y luego ya la sentencia 00:02:18
repetitiva, bucles, y ya está 00:02:20
la planeación estructurada ya habrá acabado 00:02:21
¿vale? bueno, pues entonces 00:02:23
estos resúmenes que yo pongo aquí 00:02:26
esto no es 00:02:29
material para estudiar para el examen 00:02:31
esto es un resumen para que lo tengáis ahí 00:02:33
centralizado, pues a lo mejor para situaros 00:02:35
pero no, el examen 00:02:37
¿sobre qué va? pues sobre lo que 00:02:39
estamos viendo y haciendo en clase, de lo cual 00:02:41
esto es un resumencillo que yo hago 00:02:43
para que uno no pierda mucho el hilo 00:02:45
pero no es que uno llegue al examen y tenga que estudiar esto 00:02:46
no, ¿vale? 00:02:49
dime 00:02:51
vale, pues te puedes 00:02:51
automatricular con 00:02:54
PROG 00:02:56
2024, o PROG 24 00:02:57
para los secos 00:03:00
podrás, luego en el cambio te lo digo 00:03:01
como ahora no vais a usar esto 00:03:06
ya luego en el cambio 00:03:08
lo miramos y 00:03:10
y descargáis esto 00:03:11
pero ya digo, no os confundáis 00:03:14
las cosas que yo pongo aquí 00:03:16
no es material para estudiarse 00:03:18
lo que tenéis que trabajar 00:03:20
y estudiar es lo que hagamos aquí 00:03:22
estos son resúmenes, bueno pues 00:03:23
venga, ahora ya sí que empezamos a ver 00:03:26
tipos de datos 00:03:27
entrada y salida por consola, esta parte de aquí 00:03:29
bueno, pues ahora ya 00:03:32
sí que necesitamos pizarros rápido 00:03:34
antes de empezar a hacer ya un proyecto de ciencia 00:03:36
y ahora ya con la pizarra 00:03:38
sí que vamos a encender la luz, pero creo que la luz es 00:03:42
atrás 00:03:43
¿no? 00:03:44
no se enciende atrás 00:03:48
sí, sí, sí, porque es que cuando 00:03:49
cambiaron la 00:03:53
vale 00:03:54
vale, pues venga 00:04:03
bueno, pues los que ya sabéis 00:04:07
más de programación 00:04:14
o estáis repitiendo 00:04:16
pues bueno, todo esto sonará 00:04:17
pues fenomenal, que os suene y que lo sepáis 00:04:19
y los que no tengáis ni idea de programar 00:04:21
ahora empieza el punto 00:04:23
en el cual no perdáis ni un segundo 00:04:25
ni un detalle, ni un nada 00:04:28
y luego todos lo miráis, os lo estudiáis 00:04:29
lo repasáis en casa y lo trabajáis en los ejercicios 00:04:32
que hayamos hecho aquí y en los que planteemos 00:04:34
Bueno, pues vamos a ver 00:04:36
¿Alguien ha dicho ok? 00:04:38
No, no, no he dicho ok 00:04:41
¿Has dicho ok? 00:04:42
Pues eso, ¿alguien ha dicho ok? 00:04:44
Y has dicho no, he dicho ok 00:04:45
Bueno, da igual 00:04:46
Vale, no, pero lo digo porque está bien que me respondáis 00:04:47
Que a veces parece que estoy con un montón de zombies 00:04:51
Yo asiento 00:04:53
Ah, eso se agradece muchísimo 00:04:54
Se agradece mucho 00:04:56
Que podéis no escuchar ni hacerme ni caso 00:04:58
Pero que parezca que sí 00:05:01
Porque de verdad que es que si no uno se va muy deprimido a casa 00:05:02
Bueno, pues ¿qué es un programa? 00:05:05
Un programa ya sabemos que es 00:05:13
Una secuencia de sentencias que hace cosas 00:05:15
Sí, claro, pero ¿qué cosas hace? 00:05:19
Pues en realidad lo único que hace el programa 00:05:22
Lo único que nosotros le vamos a pedir físicamente que haga 00:05:25
En realidad es que trabaje con datos 00:05:30
Operando con ellos, sumándolos, restándolos 00:05:33
haciendo las diferentes operaciones que los operadores nos permiten, que ya veremos, haciendo cosas con datos, nada más. 00:05:37
Y componiendo todas esas cosas, muchas de ellas, suma, resta, patín, componiendo todas ellas ya quedará un programa que hace algo más complejo. 00:05:43
Pero como unidad básica atómica de operación, lo único que un programa hace es hacer operaciones con datos, nada más. 00:05:53
¿Vale? Nada más. Vale. Luego la pregunta es, si un programa opera con datos, que es lo único que hace, ¿esos datos dónde los tiene? ¿Dónde puede el programa ir a ellos para leerlos, hacer la operación, poner el resultado en otro sitio, etcétera? 00:05:59
Pues los datos están y siempre están ahí y esto no tiene vuelta de hoja. Todos los datos con los que trabaja un programa están en una cosa que se llama variables. Ahí están todos los datos con los que un programa trabaja y no hay alternativa. 00:06:19
todo aquello con lo que un programa 00:06:43
tenga que operar, tiene que estar 00:06:46
en una cosa que se llama variable 00:06:48
vale, pues que es 00:06:49
una variable, y ahora entenderemos un poquito más 00:06:54
porque se ha decidido llamar variable, no se ha decidido llamar 00:06:56
cajita, no se podría haber llamado cajita 00:06:58
pues que es una variable, pues una variable 00:06:59
es una cajita 00:07:02
una cajita que está en donde? 00:07:02
en la memoria RAM 00:07:05
la memoria RAM de un ordenador 00:07:07
ya sabéis que es 00:07:09
una memoria 00:07:11
que está funcionando 00:07:12
no está limpia a cero 00:07:16
está funcionando 00:07:18
cuando el ordenador está arrancado 00:07:19
y guarda ceros y unos 00:07:20
y ya está 00:07:22
y esos ceros y unos tienen información 00:07:23
eso es una RAM 00:07:24
guarda información codificada en ceros y unos 00:07:25
bueno, pues dentro de esa información 00:07:28
en ceros y unos en la RAM 00:07:30
nuestro programa 00:07:32
puede reservarse unas cajitas 00:07:35
puede reservarse unas cajitas 00:07:38
para meter los datos 00:07:39
¿vale? 00:07:41
Entonces, cada programa que se está ejecutando en el ordenador tiene reservado su propio conjunto de cajitas para trabajar. Que yo en mi ordenador tengo arrancados siete programas a la vez, que puedo tener arrancados siete programas a la vez, de hecho los tengo, el sistema operativo, el explorador, el OBS, tengo varios programas. 00:07:42
Pues cada programa tiene su conjunto de cajitas en la RAM donde guarda sus datos, ¿vale? 00:08:02
Claro, el programa cuando arranca tiene que decir, 00:08:08
eh, oye, me quiero reservar estas cajitas para guardar este tipo de datos. 00:08:11
Ahora veremos más qué significa tipo. 00:08:17
Lo tiene que decir cuando arranca, oye, que yo quiero estas cajitas. 00:08:19
Vale, muy bien. 00:08:23
¿Cómo lo dice el programa? 00:08:24
Pues con sentencias, con sentencias del lenguaje. 00:08:25
Entonces, las primeras sentencias de lenguaje Java que vamos a ver son las sentencias que le permiten al programa reservarse estas cajitas, ¿vale? Porque si no tiene cajitas reservadas, ¿qué puede hacer? Nada, puede mostrarnos un mensaje por pantalla como mucho, pero no puede hacer nada porque no tiene un sitio para sus datos. 00:08:29
Entonces, ¿qué hace un programa sin datos? Pues nada. Vale, pues entonces, estas cajitas, cada una de ellas, es esto que estamos llamando variable. ¿Y por qué se llama variable? Pues hombre, el nombre le viene muy bien, porque el dato que va adentro va cambiando. 00:08:50
según el programa va ejecutándose 00:09:10
el dato va cambiando 00:09:13
el ordenador, el proceso 00:09:15
el programa, reserva su cajita 00:09:17
y en un momento dado 00:09:19
pues a lo mejor mete aquí 7 00:09:21
vale, pero luego 00:09:23
7 líneas más abajo 00:09:25
este 7 lo borra y pone 8 00:09:26
vale, y 7 líneas 00:09:29
más abajo, aquí ha puesto 6 00:09:31
y decide que en esta 00:09:33
cajita pone la suma de esta otra 00:09:35
y de esta otra, vale, pues entonces aquí 00:09:37
pondrá 14, ahora como 00:09:39
está cambiado y decide que pone 00:09:41
5, por lo que sea 00:09:43
pues ahora dice, ahora aquí 00:09:44
pon la suma de estas dos, pues ahora está 00:09:46
cambiando otra vez y pondrá 13 00:09:49
entonces por eso se llama variable 00:09:51
obviamente, porque el contenido 00:09:53
de las cajitas 00:09:55
cambia a lo largo de la ejecución del programa 00:09:57
¿vale? va cambiando 00:09:58
bueno, pues entonces el concepto 00:10:00
de variable es casi el más importante 00:10:03
en programación y por supuesto 00:10:05
el universal para cualquier lenguaje 00:10:06
de programación, porque cualquier programa 00:10:09
tiene que tener su espacio para sus datos 00:10:11
¿vale? y eso 00:10:13
siempre va a estar en variable 00:10:14
y solo en variables 00:10:16
y además esas variables están en la 00:10:18
memoria RAM 00:10:21
¿qué ocurre? cuando el programa termine 00:10:22
¡pum! apagado 00:10:25
todo esto 00:10:26
ha desaparecido, se ha ido a la basura 00:10:27
porque cuando un programa termina 00:10:30
su zona que se había 00:10:32
reservado de cajitas 00:10:35
desaparece 00:10:36
desaparece y se queda 00:10:37
ya a disposición para otro programa 00:10:40
si la quiere usar, desaparece 00:10:42
claro, pues una pena 00:10:44
que desaparezca, pero claro para eso 00:10:46
pues tenemos herramientas, más sentencias 00:10:48
más cosas para poder 00:10:50
llevarlo a una base 00:10:52
de datos, a un disco duro, a donde sea 00:10:54
y no perderlo, pero eso ya es otro problema 00:10:56
que no nos interesa a nosotros 00:10:58
ahora, ahora no nos interesa a nosotros 00:11:00
ahora nuestros datos 00:11:02
no los vamos a guardar 00:11:03
antes de que el programa se apague en bases de datos ni nada, 00:11:06
ni tampoco los vamos a rellenar, que podría hacerse, 00:11:10
rellenar de una base de datos. 00:11:14
No vamos a trabajar así. 00:11:16
Entonces, diréis, ¿y de dónde sacamos información para rellenar estas cajitas 00:11:18
y luego esos resultados que están en las cajitas, cómo nos enteramos? 00:11:24
Pues ahora mismo vamos a trabajar solamente con consola, ¿vale? 00:11:28
Es decir, nuestro programa arrancará, se reservará sus cajitas para datos. Esos datos, ¿cómo los iremos rellenando? Pues a través del teclado. Cuando digo consola, digo el teclado que nos va escribiendo sobre la marcha y el monitor que nos va viendo resultados. Esa es lo que llamamos consola, ¿no? Teclado y monitor, la consola. 00:11:33
Y nosotros ahora mismo, durante todo el curso, trabajaremos rellenando estas variables por consola. El programa las puede ir cambiando, por supuesto, según va haciendo operaciones, puede copiar esta aquí, puede llevar esta aquí, lo que sea que nosotros queramos decirle que haga, lo que sea. 00:11:59
cuando queramos ver el contenido de una de ellas 00:12:18
pues haremos la sentencia correspondiente 00:12:22
para que la muestre también por pantalla 00:12:24
luego nuestra comunicación ahora en esta primera parte 00:12:26
con la aplicación va a ser 00:12:30
a través del teclado podremos rellenar estas variables 00:12:34
que el programa se ha reservado antes 00:12:38
y a través de la pantalla 00:12:41
podremos ver el contenido de las variables 00:12:43
que queramos 00:12:47
que el ordenador 00:12:48
que el programa ha puesto ahí 00:12:51
el dato que sea 00:12:53
luego a final de curso 00:12:53
para no tener que estar 00:12:57
introduciendo los datos 00:12:59
siempre por teclado y mostrándolos 00:13:01
siempre por la consola 00:13:03
por la línea de comandos 00:13:05
pues podremos hacer una interfaz gráfica 00:13:06
pero es lo mismo, es en tiempo real 00:13:09
una interfaz gráfica que también 00:13:10
servirá para esto 00:13:13
para rellenar los datos y también 00:13:15
nos puede servir para mostrar un resultado 00:13:16
¿vale? 00:13:18
pero eso es lo de menos ahora 00:13:21
lo que a mi me interesa ahora es que entendáis 00:13:22
lo que es una variable, entonces un 00:13:24
programa cuando arranca 00:13:26
repito, tiene que reservarse 00:13:28
un conjunto de variables 00:13:31
cajitas, espacios 00:13:33
en memoria RAM 00:13:36
para poder usarlas, para guardar sus datos 00:13:37
y hacer ahí todas sus chuminadas 00:13:41
ahí, pa pa pa, lo que sea 00:13:42
Y claro, ahora ya lo que añado 00:13:44
Hombre, de algún sitio tendrán que llegar esos datos 00:13:47
Pues inicialmente 00:13:49
Llegarán porque los meteremos por teclado 00:13:52
Ya veremos la sentencia para meterlos 00:13:54
Y como los veremos 00:13:55
Los resultados, porque si un programa 00:13:57
No nos ofrece resultados, pues los veremos 00:13:59
Porque también usaremos la sentencia correspondiente 00:14:01
Para mostrar por pantalla 00:14:03
¿Vale? 00:14:06
Bueno, pues entonces 00:14:08
Ahora ya, sabiendo que el programa 00:14:09
Necesita esas variables 00:14:11
Ahora ya, ¿cómo las reservamos? 00:14:13
Ahora ya empezamos a escribir cosas 00:14:18
Que ya sí que son código Java 00:14:20
Bueno, pues reservarse las cajitas 00:14:22
Es lo que se llama declarar variables 00:14:31
Entonces, lo que vamos a ver ahora 00:14:33
Es la declaración de variables 00:14:40
¿Vale? Esto es 00:14:41
Entended que declarar una variable 00:14:46
es reservar espacio en memoria para un dato. 00:14:49
Eso es declarar una variante. 00:15:03
Bueno, vamos a dejar aquí nuestro dibujo 00:15:16
con tres cajitas, por ejemplo, 00:15:21
que se quiere declarar una aplicación 00:15:28
porque necesita tres números para trabajar 00:15:30
o lo que sea, tres datos. 00:15:32
Vale, pues entonces nuestra aplicación va a trabajar 00:15:34
con un número 00:15:37
que yo le tengo que meter 00:15:40
un dato de entrada, un numerito, un dato de entrada 00:15:42
y ese dato de entrada 00:15:45
que yo le meto, tiene que ir entonces 00:15:47
a una cajita 00:15:49
para luego hacer cosas con él, lo que sea 00:15:50
ya veremos que se puede hacer con él 00:15:53
y mediante qué sentencias hacerlo 00:15:55
pues entonces lo primero será declarar ese espacio 00:15:56
para ese dato, primero se va a declarar 00:15:59
vale, pues como lo declaramos en Java 00:16:01
pues primero fundamental 00:16:03
cada cajita, cada variable 00:16:05
que yo quiera declarar 00:16:08
tiene que tener un nombre que la identifique 00:16:09
si no, ¿cómo sé que me refiero 00:16:12
a esta, o a esta, o a esta? 00:16:15
entonces, cada variable 00:16:17
cada espacio en memoria 00:16:19
tengo que darle yo 00:16:20
como 00:16:22
desarrollador del programa 00:16:23
desarrollador del código 00:16:27
tengo que darle yo un nombre 00:16:28
¿qué nombre le doy? el que me dé la gana 00:16:29
claro 00:16:32
cuál es la idea 00:16:34
darle un nombre 00:16:35
lo más 00:16:37
que es 00:16:38
y que lo más posible 00:16:39
que va a contener 00:16:40
para qué sirve esa caja 00:16:41
eso es lo ideal 00:16:42
porque claro 00:16:44
yo puedo decir 00:16:44
la voy a llamar X 00:16:45
vale 00:16:46
X es un nombre muy válido 00:16:47
está muy bien 00:16:48
pero jolines 00:16:49
nuestros códigos 00:16:50
los van a leer 00:16:51
más desarrolladores 00:16:52
más gente que esté trabajando 00:16:53
con nosotros 00:16:54
gente que a lo mejor 00:16:55
le toca retocarlo 00:16:56
porque nosotros 00:16:57
no lo hemos hecho bien 00:16:58
entonces si yo veo 00:16:59
en mi código 00:17:00
un montón de variables 00:17:01
X, Y, Z 00:17:02
Este que quería meter aquí, pero claro, si la llamo edad cliente, pues ese nombre está estupendo. 00:17:03
Ah, vale, esta variable es para meter la edad del cliente. 00:17:11
Ya está, rápidamente identifico la función de ese código. 00:17:14
Entonces, tip 1, que los nombres de las variables sean lo más explicativo posible. 00:17:18
¿Vale? 00:17:25
Entonces, para declarar una variable hay que elegir un nombre, lo primero. 00:17:26
entonces, ideal, que sea explicativo 00:17:31
me da igual 00:17:37
que ocupa 00:17:41
27 caracteres 00:17:43
no pasa nada 00:17:46
¿qué más da? que el nombre de variable sea largo 00:17:48
pero si luego con un entorno de desarrollo 00:17:50
pues te lo va a autocompletar, copias, pegas 00:17:51
¿qué más da? es mucho más importante que el código 00:17:54
sea claro y legible 00:17:56
a que el nombre de variable sea corto para ahorrarte 00:17:57
tu a escribir una vez 00:18:00
da lo mismo que sea largo, no pasa nada 00:18:01
que sea explicativo 00:18:04
para favorecer lo que se llama 00:18:05
la legibilidad del código 00:18:07
es decir, que alguien que no ha hecho el código 00:18:09
cuando lo mire, rápidamente 00:18:12
se dé cuenta de qué es lo que hace 00:18:13
eso le va a ocurrir si los nombres están bien 00:18:15
elegidos 00:18:17
y luego aparte, esto es un tip 00:18:18
pero luego aparte hay ciertas restricciones 00:18:21
que bueno, hombre 00:18:23
los nombres de variables se supone que tienen 00:18:25
que empezar por un carácter 00:18:27
alfabético 00:18:29
o la barra baja 00:18:30
pero bueno, estas restricciones 00:18:33
ya propias del lenguaje 00:18:35
son las que van cambiando 00:18:36
a veces según las sucesivas versiones de Java 00:18:39
y no nos importa tanto 00:18:41
porque normalmente una variable la empezamos 00:18:45
con un carácter alfabético, o se llama nombre 00:18:47
o se llama edad, o se llama como sea 00:18:48
aunque también 00:18:51
se permite el guión bajo 00:18:53
porque el guión bajo a veces tiene un significado propio 00:18:54
como variable de control, la empiezas con un guión bajo 00:18:57
y ya dices, uy esta variable es rara 00:18:59
empieza con guión bajo 00:19:01
Entonces igual a lo mejor significa algo extraño 00:19:02
¿Vale? 00:19:05
Esas son restricciones de cada lenguaje 00:19:06
Tiene las suyas propias 00:19:08
¿Vale? 00:19:09
Y como código de estilo 00:19:16
Como pauta de estilo 00:19:19
Hay una cosa que se llaman las pautas de estilo 00:19:20
En programación 00:19:23
No es que sean obligatorias 00:19:23
Pero si todos seguimos ciertas pautas de estilo 00:19:25
Pues nos entenderemos mejor 00:19:29
Entre unos y otros 00:19:31
Los códigos que ha hecho uno 00:19:32
Si se parecen en estilo a los que ha hecho otro 00:19:34
Pues casi mejor 00:19:36
Entonces, como pauta de estilo 00:19:37
Es deseable que los nombres de las variables 00:19:40
Empiecen en minúscula 00:19:42
Entonces, esto digamos que sería deseable 00:19:43
Estas dos cosas que pongo aquí 00:19:48
Que el nombre sea explicativo y en minúscula 00:19:50
Pero no es que sea obligatorio 00:19:52
Pero facilitamos la elegibilidad del código 00:19:54
Ahora mismo diréis 00:19:58
¿Por qué empezar en minúscula lo facilita? 00:19:59
Bueno, ahora mismo no lo entendemos muy bien 00:20:02
Porque hay otras cosas que se llaman objetos 00:20:03
Que pertenecen a clases 00:20:06
las clases tienen como pauta de estilo empezar 00:20:08
en mayúscula, entonces cuando algo empieza 00:20:10
en minúscula, ya sabes que es una variable 00:20:12
y si empieza en mayúscula sabes que es 00:20:14
una clase, rápidamente un poquito va por ahí 00:20:16
pero ahora mismo quedémonos 00:20:18
como que para seguir un estilo 00:20:20
de programación elegante, de alguna 00:20:22
manera elegante, pues que el 00:20:24
nombre sea explicativo y que arranque en minúscula 00:20:26
entonces será un código 00:20:28
habitual como lo hace 00:20:29
casi todo el mundo y cuando lo vea tu jefe 00:20:32
pues bueno, pues verá que sí, que tú programas 00:20:34
siguiendo esas reglas de estilo 00:20:36
¿vale? 00:20:38
bueno, pues por ahora hemos elegido el nombre solamente 00:20:39
lo hemos elegido 00:20:42
y ahora ya 00:20:43
¿qué ponemos en el código? 00:20:44
ahora ya estamos haciendo el programa 00:20:47
ya estoy con mi blog de notas 00:20:48
que ahora pondremos 00:20:51
ya escribiendo 00:20:54
un programa Java 00:20:55
y lo primero que voy a hacer en mi programa Java 00:20:56
va a ser reservarme este espacio 00:20:59
para el que ya he decidido el nombre 00:21:02
vamos a suponer que en vez de X 00:21:03
lo vamos a llamar número 00:21:06
por lo menos algo explica 00:21:07
número, vale 00:21:09
lo vamos a llamar número, vale, pues ahora ya escribimos 00:21:11
código Java, ¿qué escribo yo? 00:21:14
pues tengo que, mi sentencia 00:21:18
va a ser, el nombre de la 00:21:20
variable que yo he elegido, el que me ha dado 00:21:22
la gana, siguiendo estas restricciones 00:21:23
pero delante 00:21:25
tengo que poner algo obligatoriamente 00:21:27
¿qué pongo? 00:21:29
el tipo de dato 00:21:33
que va a contener esta cajita 00:21:35
el tipo de dato 00:21:38
si va a ser un número, si va a ser un carácter 00:21:40
es decir, aquí 00:21:42
tenemos que poner 00:21:44
el tipo del dato 00:21:46
y ahora veremos qué tipos tiene Java 00:21:50
y luego ya lo terminamos 00:21:52
en punto y coma 00:21:55
porque las sentencias de Java terminan en punto y coma 00:21:55
no en todo el lenguaje en punto y coma 00:21:58
como en Python, todo termina en punto y coma 00:21:59
pero en muchos sí 00:22:01
pues en nuestro caso 00:22:03
sí acaba en punto y coma 00:22:05
vale, entonces 00:22:06
lo de especificar el tipo 00:22:09
es obligatorio 00:22:11
en Java 00:22:13
bueno, obligatorio con un matiz 00:22:14
que se incorporó de poner uno genérico 00:22:17
y luego sustituirlo, pero bueno 00:22:19
las cosas que yo os digo en muchos casos 00:22:20
tienen por decirlo así 00:22:23
una especie de matiz, pero yo no puedo decirlos 00:22:25
todos porque entonces nos volvemos locos 00:22:27
entonces este tiene un matiz, hay una especie de caso especial 00:22:28
en el cual 00:22:31
no tienes por qué poner el tipo si pones otra cosa 00:22:33
pero eso ya son cosas que vamos a ignorar 00:22:35
por ahora 00:22:38
porque son detalles muy concretos 00:22:39
y de versiones de Java además 00:22:41
que se han ido sacando poco a poco 00:22:43
vale, pues entonces 00:22:45
el tener que poner el tipo 00:22:48
es una restricción 00:22:50
de Java un poco pesada 00:22:51
porque hombre 00:22:54
yo me comprometo ya para siempre 00:22:55
a que esta variable solo 00:22:57
pueda contener datos de este tipo 00:22:59
es una restricción muy pesada 00:23:01
hay otros lenguajes que no la tienen 00:23:04
Python no la tiene 00:23:06
tú dices el nombre de la variable 00:23:07
que vas a usar, con eso ya reservas 00:23:11
la cajita, pero no dices 00:23:12
el tipo de dato 00:23:14
entonces el intérprete de Python te va 00:23:15
cambiando esta cajita 00:23:18
pues que de repente le metes un numerito 00:23:19
pues te adapta el tamaño, que ya le metes 00:23:22
una cadena de 30 caracteres, te cambia la cajita 00:23:24
una cadena de 30 00:23:26
¿vale? ¿qué es mejor? 00:23:27
¿Un lenguaje como Java que te obliga a poner el tipo y ya reserva una cajita con el tamaño exacto para datos de ese tipo? 00:23:30
¿O un lenguaje como Python que no te obliga a ponerlo y se adapta? 00:23:39
Pues depende. 00:23:43
Para los vagos y cómodos y para que cuele todo y hacer un programa que funciona rápido y fácil, 00:23:45
mucho mejor los que no te obligan a poner el tipo, como Python. 00:23:52
Es decir, en tiempo de desarrollo, que se llama, que es cuando yo estoy escribiendo el código, 00:23:55
Más cómodo si no me obligan. 00:24:00
Pero ojo, ¿qué pasa en el tiempo de ejecución? 00:24:02
Cuantas menos restricciones te pongan, más se puede escapar de control a la hora de ejecutar. 00:24:06
¿Vale? 00:24:13
Si a ti te dejan salir de casa por la noche y no te ponen ninguna restricción, eso es lo que tienes que hacer. 00:24:14
Vete a saber cómo llegas a casa. 00:24:19
¿No? 00:24:21
Pero si te han dejado salir por la noche y te han dicho, vale, no puedes beber, no puedes fumar y solo te puedes fumar un gorro. 00:24:21
Pues entonces solo habrá pasado eso. 00:24:27
Ya está. 00:24:29
entonces ya sabes exactamente cómo va a volver tu hijo 00:24:30
lo más que puede pasar es que se haga como un pobre 00:24:32
vale, pues esto igual 00:24:34
esto igual 00:24:36
si tú desde tiempo de desarrollo 00:24:38
has puesto restricciones 00:24:40
en tiempo de ejecución 00:24:42
es muy difícil que se te escapen errores 00:24:44
incontrolados, porque ya has puesto esas restricciones 00:24:46
esa es la ventaja 00:24:48
de los lenguajes tipados 00:24:50
que se llaman, los que te obligan a 00:24:52
los que te restringen 00:24:53
ya mucho en tiempo de escritura de código 00:24:56
y Java es de esos, de los que te restringe 00:24:58
mucho, quizá por eso es 00:25:00
uno de los que más éxito ha tenido, Python está bien 00:25:02
para aprender a programar, pero luego 00:25:04
para desarrollar aplicaciones 00:25:06
pues no 00:25:08
consigue 00:25:10
echar a Java, no consigue por estas cuestiones 00:25:11
es bueno para aprender a programar, pero luego 00:25:14
en el entorno de trabajo ya no se usa tanto 00:25:16
bueno, pues entonces en nuestro caso 00:25:18
estábamos con 00:25:20
que tenemos que especificar el tipo, obligatorio 00:25:22
esto ya sería una sentencia que yo 00:25:24
puedo escribir, un programa que podemos escribir ahora mismo. 00:25:26
Poniendo aquí un tipo válido. 00:25:29
Claro, luego la pregunta que viene ahora 00:25:30
es, oye, ¿de qué 00:25:32
tipos dispongo? 00:25:34
¿De qué tipos disponemos en Java? 00:25:36
Bueno, pues afortunadamente 00:25:39
no muchos, porque si no 00:25:41
tendríamos ahí una elección enorme. 00:25:42
No muchos. 00:25:45
Disponemos en general 00:25:47
de números, 00:25:48
de caracteres 00:25:50
sueltos 00:25:52
y de booleanos 00:25:53
qué se llaman, que ahora para 00:25:56
lo de que el boolean se le haga raro, pues 00:25:57
explicaremos lo que es, pero sobre todo es eso 00:26:00
números, caracteres 00:26:02
y booleanos, pero claro, los números 00:26:04
¿qué números? ¿número entero? ¿número decimal? 00:26:05
bueno, pues tipos para los dos 00:26:08
en resumen, los tipos 00:26:09
tal y como nosotros los escribiremos aquí 00:26:12
son estos 00:26:14
vamos a ponerlos 00:26:18
aquí 00:26:20
el tipo byte 00:26:22
el tipo short 00:26:29
El tipo int 00:26:32
El tipo long 00:26:34
Ahora especificaremos las diferencias entre cada uno de ellos 00:26:36
El tipo float 00:26:40
El tipo double 00:26:43
El tipo char 00:26:47
Y el tipo boolean 00:26:49
Estos son los tipos 00:26:53
Añado la palabra 00:27:01
Primitivos 00:27:03
Ahora indico por qué he añadido esta palabra 00:27:04
En Java 00:27:07
¿Vale? Y ya está 00:27:11
Y no hay más que esto 00:27:12
No hay más tipos que estos 00:27:13
¿Por qué los he llamado primitivos? 00:27:15
Ahora, esto es una especie de inciso 00:27:26
Para explicar la palabra 00:27:28
En la cual, pues bueno 00:27:30
Tengo que mencionar alguna cosa 00:27:32
La tengo con objetos y no sé qué 00:27:33
Pero bueno, ahora no me importa tanto 00:27:35
Si es inciso, no lo entendéis demasiado 00:27:37
Pero al menos la idea es que se os quede 00:27:39
¿Por qué decir que son primitivos? 00:27:40
¿Es que hay tipos de otra clase? 00:27:44
Sí, hay tipos de otra clase 00:27:47
¿Por qué? 00:27:48
porque claro, a la vista de estos tipos de datos 00:27:49
diréis, jolines 00:27:51
¿son una aplicación? 00:27:52
¿sólo puede trabajar con números 00:27:54
un char suelto y booleanos 00:27:56
que ahora especificaremos lo que es? 00:27:59
pues vaya, y si yo quiero trabajar 00:28:00
que mi aplicación trabaje con clientes 00:28:02
donde mi cliente tiene un nombre 00:28:05
que son un montón de caracteres 00:28:06
tiene un DNI que también son un montón de caracteres 00:28:08
tiene una edad que son números 00:28:11
pues mira a tu cliente 00:28:12
¿qué le pasa? no cae ninguno de estos 00:28:15
claro 00:28:17
pues para eso precisamente se usan 00:28:18
entre otras cosas 00:28:21
los objetos 00:28:22
un objeto, ahora no me importa 00:28:23
ahora solamente quiero que la idea vaya sonando 00:28:27
pero nada más 00:28:29
un objeto es como si fuera 00:28:29
una caja gorda 00:28:32
con un montón de datos 00:28:34
de este tipo dentro, con un montón 00:28:37
entonces un objeto es muy útil 00:28:38
porque te puede meter dentro 00:28:41
un número entero que es un int 00:28:42
un decimal que es un double y un char 00:28:45
o muchos char 00:28:47
entonces, un objeto te puede 00:28:48
meter dentro muchas 00:28:51
variables de diferentes tipos 00:28:52
entonces 00:28:55
si yo quiero guardar los datos 00:28:56
de un cliente, no los guardo 00:28:59
en una variable de estas, o de estas, o de estas 00:29:01
por enero clave, los guardo en lo que llamamos 00:29:03
una variable objeto 00:29:05
porque una variable objeto es una caja grande 00:29:06
donde puedo meter muchas variables 00:29:09
de estos tipos, ¿vale? pero eso ya 00:29:11
lo veremos más adelante 00:29:13
estos son los primitivos que se llaman 00:29:14
los datos primitivos 00:29:17
bueno, esto ahora paramos 00:29:19
esto sería para guardar 00:29:22
números enteros 00:29:24
esto sería para guardar 00:29:25
números decimales o reales 00:29:28
como os guste llamarlo 00:29:29
esto para guardar un único carácter 00:29:30
y solo uno 00:29:34
con lo cual para guardar un nombre no nos vale 00:29:35
y el boolean es para 00:29:37
guardar la idea de 00:29:40
¿verdad? no mentira, nada más 00:29:41
o sea, una variable 00:29:44
que es de tipo boolean 00:29:46
solo puede tener dos valores 00:29:47
o verdadero 00:29:49
o falso 00:29:51
no es como una variable int 00:29:53
que puede tener un montón de valores 00:29:57
7, 12, 15, 28, 93, menos 12 00:29:58
puede tener muchos 00:30:01
una variable boolean es un tipo de dato 00:30:02
que solamente puede tener 00:30:05
¿verdad? o mentira 00:30:06
y diréis, jolín, ¿qué tipo de dato 00:30:08
tan raro y tan artificial? 00:30:11
no sé, meter ahí un tipo de dato 00:30:13
que puede contener verdad o mentira 00:30:15
que rarísimo es eso 00:30:17
bueno, no es tan raro en programación 00:30:18
porque en programación muchas veces 00:30:20
interesa saber si algo 00:30:22
es verdad o si algo es mentira 00:30:24
y en función de eso irse por una rama 00:30:27
o por otra 00:30:29
recordad las medidas de selección que decía 00:30:29
entonces viene muy bien tener una cajita 00:30:32
para guardar 00:30:34
lo que llamamos condiciones, que son cosas 00:30:36
que son verdad o mentira 00:30:38
entonces viene bien una cajita para poder guardar 00:30:40
el resultado de una condición 00:30:42
o lo que es lo mismo 00:30:45
si se cumple, no se cumple, lo tengo ahí guardadito el resultado y cuando quiero 00:30:46
usar eso para decidir si me voy por una rama o por otra, pues uso. ¿Qué tiene esta 00:30:51
cajita? ¿Tiene verdad o tiene mentira? ¿Tiene verdad? Pues voy por aquí. ¿Tiene mentira? 00:30:55
Pues no voy por aquí. Eso para las intenciones de defensa. 00:30:59
Vale, vamos a parar aquí y luego seguimos otro ratinín 00:31:03
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
21
Fecha:
17 de septiembre de 2024 - 17:49
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
31′ 11″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
1.11

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid