Saltar navegación

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

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

19 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, bueno, pues entonces, vamos a empezar con, vamos a concretar ya un poquito como con Java, podemos hacer programas estructurados, que ya sabemos que combinan esos tres tipos de ciclología que hemos visto. 00:00:04
Bueno, pues hay antes una cosa fundamental, un concepto fundamental que tenemos que tener 00:00:17
Que es el concepto de dato, ¿verdad? 00:00:25
Esto, porque muchas veces orientamos la tarea de programación a órdenes que hacen cosas 00:00:34
Y está claro, los programas son una secuencia de sentencias, órdenes que hacen cosas, eso lo sabemos 00:00:41
pero claro, esas cosas que hace 00:00:48
las estamos diciendo abstracto, esas cosas que hacen 00:00:50
que son, que es lo que hacen 00:00:52
pues los programas, esas sentencias 00:00:54
en realidad, lo único que hacen 00:00:56
es mover datos 00:00:58
eso es lo que hacen todas las aplicaciones 00:01:00
del mundo, mover datos 00:01:02
ya está, no hacen ninguna otra cosa 00:01:04
lo que pasa es que 00:01:06
como resultado del movimiento 00:01:07
de esos datos, esos datos a veces se mueven 00:01:10
a una salida, como puede ser 00:01:12
ponerse en las ventanitas que esté 00:01:14
ponerse la consola, esos datos a veces se recogen 00:01:16
que los hemos introducido por consola, los hemos introducido pinchando en una ventana 00:01:20
y la aplicación mueve, sigue moviendo esos datos 00:01:24
y opera con ellos, las aplicaciones mueven datos de un sitio a otro 00:01:28
si os ocurre algo, alguna situación que hayáis vivido con alguna aplicación 00:01:31
informática que no se pueda expresar lo que hace 00:01:36
en términos de que está moviendo datos 00:01:40
Cuando hacéis login 00:01:43
¿Qué hace la aplicación? 00:01:45
Coge el dato que le habéis dado vosotros 00:01:46
Primer movimiento de dato 00:01:49
Coge ese dato 00:01:50
Y luego consulta en una base de datos 00:01:52
Y lo trae, segundo movimiento de dato 00:01:56
Consulta lo que ha pedido la base de datos 00:01:58
Con el que le habéis dado 00:02:00
Si es igual 00:02:00
Te dice, si eres correcto 00:02:02
Es decir, el dato 00:02:05
Si eres correcto, te lo pone en la pantalla 00:02:07
Todas las aplicaciones 00:02:09
Todo lo que hacen 00:02:11
se puede traducir en última instancia 00:02:12
es un movimiento de datos de un sitio a otro 00:02:14
entonces cuando decimos secuencias que hacen cosas 00:02:15
las secuencias no lo que hacen es mover datos 00:02:17
ya está, eso es lo único que hacen 00:02:20
luego, el concepto de datos 00:02:21
es fundamental 00:02:24
bueno, pues entonces tenemos que concretar 00:02:24
de alguna manera, y ese dato 00:02:29
de donde lo saca Java, donde está ese dato 00:02:31
que hace con él, Java o cualquier otro lenguaje de operación 00:02:33
si va a mover datos 00:02:36
de donde coge esos datos 00:02:37
bueno, pues ahí viene el 00:02:39
concepto más importante de programación, que es el concepto de variable. Y mientras 00:02:41
no tengamos ese concepto claro y no sepamos habilitar estas variables, es imposible hacer 00:02:54
ningún programa, porque los programas, como yo he dicho, lo único que hacen son mover 00:03:00
datos, pues esos datos tienen que estar en algún sitio. Bueno, pues, ¿qué es una variable? 00:03:04
Una variable 00:03:11
Que es un término 00:03:15
Que aplica a cualquier lenguaje de pronunciación 00:03:18
A cualquiera 00:03:20
Una variable es un espacio en memoria 00:03:21
Para guardar un dato 00:03:25
Eso es una variable y nada más que eso 00:03:26
Un espacio en memoria RAM 00:03:28
Para guardar un dato 00:03:39
Las variables están en RAM sí o sí 00:03:41
Siempre 00:03:52
Para que el ordenador pueda trabajar con un dato 00:03:52
tiene que estar en una variable 00:03:55
y la variable está en RAN 00:03:56
otra cosa es que hay sentencias 00:03:57
cuyas órdenes 00:04:01
que sirven específicamente 00:04:02
para mover de una ubicación externa 00:04:04
a una variable 00:04:07
pero hasta que no ejecutemos esa sentencia de traslación 00:04:08
el ordenador no puede 00:04:11
el programa no puede hacer cosas con esa variable 00:04:12
es decir, hay sentencias específicas 00:04:15
de trasladar del exterior a variables 00:04:17
y luego 00:04:20
de trasladar de variables al exterior 00:04:21
pero luego ya todas las operaciones 00:04:23
todo lo que haya que hacer 00:04:26
se tiene que hacer con las variables 00:04:27
es decir, un programa no puede sumar 00:04:29
dos números si esos dos números 00:04:31
están alojados en ubicaciones 00:04:34
que no sean variables, no puede 00:04:35
un programa solo puede trabajar con datos 00:04:37
que están en variables, pero claro 00:04:39
para que los datos lleguen a variables 00:04:41
tienen que llegar de algún lado 00:04:42
entonces hay sentencias específicas 00:04:44
que sirven solo para eso 00:04:47
mover de ese lado 00:04:49
sea base de datos, sea lo que sea 00:04:51
a la variable, para poder trabajar con ello 00:04:53
dime 00:04:56
pero si dices que una variable es un cambio de la característica 00:04:56
del disco duro para que funcione en ambos lados 00:05:11
a ver, si tu programa se está ejecutando en Linux 00:05:13
tú no puedes leer 00:05:17
del disco duro 00:05:19
que no sea compatible 00:05:21
claro, no sé si va por ahí tu pregunta 00:05:23
no sé si lo entiendo 00:05:25
mi pregunta es 00:05:26
que no puede ser 00:05:27
La memoria puede ser en un sitio que tampoco sea la RAM, me refiero, o sea... 00:05:31
Bueno, eso no es la memoria, eso es el almacenamiento permanente. 00:05:34
O sea, tenemos memoria RAM, que es los datos con los que cualquier software 00:05:37
tiene que trabajar cuando está funcionando, 00:05:42
sea el sistema operativo, sea un programa nuestro, 00:05:45
todos los datos tienen que estar en memoria RAM, ¿vale? 00:05:47
Para que cualquier programa sea el que sea, sistema operativo en su lugar, 00:05:50
para trabajar con él. 00:05:53
Y luego otra cosa ya es el almacenamiento permanente, 00:05:54
porque claro, cuando ese programa sea sistema operativo, 00:05:56
sea nuestro propio programa, cuando ese programa 00:06:00
termina, todo lo que hay en RAM 00:06:02
asociado a él, con lo que el trabajo desaparece 00:06:04
entonces si 00:06:06
el programa no quiere que desaparezca 00:06:08
porque quiere que se conserve para que 00:06:10
la siguiente ejecución se detrace 00:06:12
en el valor, entonces ya lo tiene que pasar 00:06:14
a almacenamiento permanente 00:06:16
almacenamiento permanente es disco duro 00:06:17
base de datos, pendrive 00:06:20
lo que es almacenamiento permanente 00:06:22
entonces claro, lo que sí que tiene que haber es 00:06:23
desde el lenguaje de programación 00:06:26
la posibilidad de hacer ese movimiento 00:06:28
pero solo eso 00:06:30
mover de almacenamiento permanente 00:06:32
el que sea disco duro 00:06:34
pendrive a variable 00:06:36
y luego de variable a disco duro 00:06:38
pero luego todas las operaciones 00:06:39
todo el trabajo 00:06:42
ya del programa se tiene que hacer cuando los datos 00:06:43
ya están ahí 00:06:46
se han trasladado previamente 00:06:46
entonces claro, desde un programa 00:06:49
tú solamente podrás hacer ese traslado 00:06:51
de almacenamientos permanentes 00:06:53
pues bueno, sí que son compatibles 00:06:55
que tu programa pueda abrir 00:06:57
un socket hacia ellos 00:06:58
o como lo haga internamente 00:07:00
pero nosotros invocamos la sentencia y ya está 00:07:02
como lo hace internamente eso no podemos meternos 00:07:04
¿vale? 00:07:06
bueno, pues la variable es un espacio 00:07:08
en memoria RAM para guardar 00:07:10
un dato 00:07:12
y nuestros programas van a trabajar 00:07:12
con los datos que estén en variables 00:07:18
lo que pasa es que claro, ese programa 00:07:20
de alguna manera tendrá que incluir 00:07:22
sentencias 00:07:25
para que esto sea útil, porque si queremos trabajar con un dato 00:07:28
que nosotros le estamos suministrando a un programa, 00:07:33
que le das dos números y te dice cuál es mayor que otro. 00:07:36
Entonces, para comparar si el numerito primero es mayor que el segundo, 00:07:40
para compararlos, esos numeritos los tiene que tener en memoria. 00:07:44
Imaginaos un programa que le das dos números y te dice 00:07:48
el primero es el mayor, el segundo es el mayor 00:07:57
o son iguales, una chorrada de programa 00:07:59
¿vale? 00:08:01
entonces el análisis de esta enunciada es muy sencillo 00:08:24
porque todos entendemos que nos han pedido 00:08:26
vamos, dos números 00:08:28
y nuestro programa en Java 00:08:30
esos dos números, pues tiene que decir 00:08:32
el mayor es el primero, el mayor es el segundo 00:08:34
son iguales, tres posibles salidas 00:08:36
tres mensajitos 00:08:38
¿vale? esa sería la fase 00:08:39
de análisis completamente hecha 00:08:42
¿entiendo lo que 00:08:44
me pide? sí 00:08:45
¿Qué datos de entrada necesita? 00:08:47
Dos números que le suministramos desde el exterior 00:08:50
¿Cuáles son sus posibles salidas? 00:08:52
Tres posibles mensajes 00:08:55
El primero es el mayor 00:08:57
El segundo es el mayor 00:08:59
Son iguales 00:09:00
Todo esto para la parte de análisis 00:09:00
Que uno hace conectado con su cliente 00:09:02
¿Quieres eso? 00:09:05
¿Quieres que te muestre estos tres mensajes posibles? 00:09:06
¿O quieres alguna otra posibilidad 00:09:09
Que yo no he contemplado? 00:09:11
¿O no te gustan estos mensajes? 00:09:13
¿O además de los datos de entrada 00:09:14
necesitas otra cosa para ver si lo que quieres 00:09:16
es decir si es mayor 00:09:19
si es menor, eso forma parte de la parte 00:09:20
de análisis, en este caso una vez hecha sería 00:09:22
vale, datos de entrada 00:09:24
dos, salidas 00:09:26
tres posibles 00:09:29
mensajes, el primero es mayor 00:09:31
esos dos mayores son iguales 00:09:32
ya que lo tenemos todo analizado pues ya 00:09:34
construiríamos el programa, dos líneas 00:09:36
vale, ya he hecho 00:09:39
pero para qué lo pongo 00:09:39
porque el programa tiene que trabajar 00:09:41
con esos dos números 00:09:44
entonces esos dos números tienen que caer en la RAM 00:09:46
en algún sitio, tienen que caer 00:09:49
entonces 00:09:50
este programa en algún momento tendrá que poner 00:09:51
una sentencia que sea 00:09:55
coger 00:09:56
la fuente del dato 00:09:57
que si el programa es 00:10:00
que yo le meto el dato por teclado 00:10:02
pues entonces tendremos que 00:10:04
usar la sentencia 00:10:06
que es capaz de leer 00:10:08
lo que hay en el buffer del teclado 00:10:10
porque cuando uno teclea algo 00:10:12
en el teclado 00:10:14
Eso va a un buffer del teclado 00:10:15
Y como no haya ninguna aplicación 00:10:17
Ninguna aplicación ahí 00:10:20
Pendiente del buffer del teclado 00:10:22
Eso se puede quedar en el buffer del teclado de por vida 00:10:24
Lo que pasa es que normalmente 00:10:26
Cuando escribimos en el teclado 00:10:27
Es porque tenemos una aplicación arrancada 00:10:30
Que está ahí a la escucha 00:10:32
Como el Word, por ejemplo 00:10:33
Tenemos el Word que está ahí escuchando 00:10:34
Y en cuanto ve que hay una cosa en el buffer del teclado 00:10:36
Lo saca del buffer del teclado 00:10:39
Y lo pone en la pantallita 00:10:41
Pues este programa sería igual 00:10:43
Tiene que haber una sentencia 00:10:45
Que coja lo que haya 00:10:47
En el buffer del teclado 00:10:50
Y lo pase a la memoria RAM 00:10:51
¿Vale? Entonces 00:10:53
Nosotros te creamos el 27 00:10:55
Pues entonces 00:10:57
Una sentencia, que ya veremos cuál 00:10:59
Tiene que coger lo que hay en el buffer del teclado 00:11:01
Porque para este programa en particular 00:11:03
Esa es nuestra fuente de datos 00:11:05
Podríamos leer un archivo de otro lado, pero no 00:11:07
El teclado está bien, vale 00:11:09
Pues coge lo que haya en memoria RAM 00:11:10
Primer paso imprescindible, porque el programa solo puede trabajar si está en RAM. 00:11:12
Siguiente paso del programa, volver al buffer del teclado, a ver si alguien ha escrito ya el segundo número. 00:11:16
Como alguien no lo haya escrito, pues el programa se estaría esperando dos horas hasta que el buffer del teclado se llene. 00:11:24
Bueno, pues ahora el teclado se ha llenado, ha llegado el numerito. 00:11:29
Lo paso a RAM y ahora ya es cuando empieza el programa. 00:11:32
Ya están los dos en RAM, ya están los dos en variables. 00:11:36
ahora ya que están en variables 00:11:38
ya podemos empezar a hablar 00:11:41
y empezar a decir, vale, ¿qué hago con los números? 00:11:42
¿los sumo, los resto, los comparo? 00:11:44
¿los multiplico? 00:11:47
¿les quito 100? 00:11:49
ahora ya podemos empezar a hablar 00:11:50
pero porque ya están en memoria RAM 00:11:51
ya están en una variable 00:11:53
luego, los datos con los que trabaja 00:11:54
cualquier aplicación 00:11:58
tienen que estar en memoria RAM 00:11:59
y para ello se habrán hecho previamente 00:12:02
las sentencias que correspondan 00:12:04
para que esos datos de entrada lleguen 00:12:06
que será la de leer del teclado 00:12:08
la de leer de un disco duro 00:12:13
la de la que sea 00:12:14
cuando ya está en RAM 00:12:15
ya empezamos a trabajar, empezamos a operar 00:12:18
empezamos a hacer decisiones, bucles, lo que sea 00:12:20
pero tiene que estar en RAM 00:12:22
bueno, pues eso es una variable 00:12:23
una variable es 00:12:25
un espacio en memoria RAM para guardar un dato 00:12:27
y es imprescindible que existan las variables 00:12:30
porque si no, el programa no puede trabajar con datos 00:12:32
¿de qué nos sirve? 00:12:34
A ver, perdonadme, pero es que tengo una situación un poco peliaguda en casa 00:12:36
y tengo que coger el teléfono cuando me llaman. 00:18:34
¡Uh! Y no he cortado la grabación. 00:18:43
¿Veis? Estas son las cosas que me pasan siempre. 00:18:44
Así que ahora pues tendréis que, si alguien la ve, pues tendrá un rato muy gordo que tendrá que pasarlo rápido. 00:18:46
Porque os oirá bailar a vosotros. 00:18:54
O si no, uno lo evita. 00:18:56
Claro, pero os aviso de eso, de que si a veces estamos grabando y entra alguien, pues yo no me acuerdo y bueno. 00:19:00
Pues eso, que al final son grabaciones así y igual muchas veces es puro... 00:19:06
Vale, pues entonces, está claro lo que es una variable, ¿verdad? 00:19:11
y que son necesarias porque el programa 00:19:15
tiene que trabajar con los datos en la memoria RAM 00:19:17
¿vale? 00:19:20
tenemos claro ese concepto 00:19:21
de que es una variable 00:19:24
pues entonces, si queremos hacer programas 00:19:25
antes de empezar a hacer las sentencias 00:19:28
propiamente dichas del lenguaje de programación 00:19:30
que son las decisiones 00:19:32
los bucles 00:19:34
y no hay más 00:19:35
vamos a ver 00:19:36
cómo hacer que aparezcan variables 00:19:39
en un programa para que un programa 00:19:41
pueda usarlas para meter datos en ella 00:19:43
pues venga 00:19:45
a ver 00:19:47
ahora ya 00:20:03
sí que tenemos que concretar ya en el lenguaje 00:20:05
de programación, ya no podemos hablar 00:20:08
en términos generales de cualquier lenguaje 00:20:10
aunque en todos 00:20:11
el concepto es el mismo 00:20:14
una variable, un espacio de memoria RAM 00:20:15
pues venga, ahora ya sí que nos metemos 00:20:17
en variables en Java 00:20:20
pues está claro que son 00:20:21
una cajita 00:20:32
de memoria RAM, yo las variables 00:20:34
Siempre las identifico así 00:20:36
Como un cuadradito, pero son una cajita 00:20:37
Son una cajita para meter un dato 00:20:39
¿Verdad? Son una cajita para meter un dato 00:20:41
Así es como yo las represento gráficamente 00:20:43
Cuando utilizamos cosas 00:20:46
Son una cajita para meter un dato 00:20:47
Vale, entonces 00:20:48
¿Qué tipo de dato se mete en memoria RAM? 00:20:50
¿Qué tipo de datos usamos? 00:20:54
Pues en realidad 00:20:57
Números o letras 00:20:57
Ya está, números o letras, no hay más 00:21:00
Lo que pasa es que esos números y letras 00:21:01
Luego dan información 00:21:04
Pero toda la información 00:21:05
Que los humanos manejamos 00:21:08
Toda la información 00:21:10
Se puede concretar con números y letras 00:21:11
¿Vale? Ya está 00:21:13
Pues 00:21:14
Ahora es 00:21:16
Entonces una variable yo puedo meter el 37 00:21:19
En una variable 00:21:22
Yo puedo meter el carácter A 00:21:24
Esas cosas las puedo meter en variables 00:21:26
Entonces ahora 00:21:30
Surge la pregunta 00:21:31
el espacio de memoria 00:21:33
vale el mismo espacio 00:21:39
vale la misma cajita 00:21:40
si yo voy a meter números o si voy a meter letras 00:21:41
o si voy a meter números grandes 00:21:44
o números pequeños 00:21:46
pues yo no voy a la misma cajita 00:21:47
para que el programa funcione 00:21:49
genere los menos errores 00:21:52
efectos secundarios indeseados 00:21:54
Java es un lenguaje 00:21:56
que se llama 00:21:58
tipado, es un lenguaje tipado 00:21:59
que no lo son todos tipados 00:22:01
concepto también en la cabeza 00:22:03
como todos 00:22:09
¿qué es un lenguaje tipado? 00:22:09
un lenguaje tipado es un lenguaje de programación 00:22:13
que exige 00:22:15
que tú digas el tipo de dato 00:22:16
que va a tener una variable 00:22:19
antes de usarla 00:22:20
exige que digas el tipo de dato 00:22:22
que va a albergar 00:22:48
una variable 00:22:50
antes de 00:22:52
usarla 00:23:00
¿vale? 00:23:01
No todos son tipados 00:23:05
Hay lenguajes de programación 00:23:09
Que tú puedes usar una variable 00:23:11
Y meterle un número 00:23:12
La primera vez que la usas 00:23:14
Y siete sentencias más abajo 00:23:16
Le metes una cadena de texto 00:23:18
Entonces el lenguaje 00:23:20
¿Perdón? 00:23:22
Python 00:23:24
PHP sí 00:23:25
Python puede hacerlo 00:23:27
Pero puedes definir los tipos también 00:23:29
Y en ese caso funciona mejor 00:23:31
¿por qué es más peligroso 00:23:33
que no uses 00:23:38
la posibilidad de definir los tipos? 00:23:40
como te ofrecen algunos lenguajes 00:23:41
ahí no tengo muy claro cómo funciona 00:23:43
tengo que mirarlo 00:23:45
¿eh? 00:23:46
¿definir o declarar? 00:23:52
¿quién está hablando? 00:23:55
es que son cosas distintas 00:23:56
pero bueno, no pasa nada, vamos a dejarlo ahí 00:23:59
lo importante es que distinguamos qué significa tipado o no tipado 00:24:01
entonces, ¿cuál sería el problema de un lenguaje 00:24:03
que te permite que tú no comprometas 00:24:06
el tipo de dato antes de usarlo 00:24:09
y no digas, esta variable va a ser 00:24:10
para números, esta variable va a ser para detrás 00:24:12
¿cuál puede ser el problema? 00:24:14
que cabe más cualquier cosa 00:24:16
es decir, que se puede 00:24:19
que tú puedes colar muchas cosas 00:24:20
sin tener errores de compilación 00:24:22
y cuidado 00:24:24
un lenguaje que es muy abierto 00:24:26
y te permite que escribas cualquier cosa 00:24:28
y no te da errores de compilación porque te permite cualquier cosa 00:24:30
por ejemplo, con una variable metas 00:24:33
primero un número, luego metes una letra 00:24:35
entonces no te va a dar errores de compilación, te viene cualquier cosa 00:24:36
pues cuidado, porque cuanto más 00:24:39
abierto y más te deje hacer, cuanto más 00:24:41
libertad 00:24:43
seguramente más probable sea cagarla 00:24:44
cuando eso se ejecute 00:24:47
entonces siempre hay un compromiso en general 00:24:48
en informática, tanto en el diseño de bases de datos 00:24:51
como en la operación, hay un compromiso entre 00:24:53
la libertad de acción del programador 00:24:54
y luego los errores 00:24:57
que puedan surgir en esa 00:24:59
en ese programa y ejecutándose 00:25:00
si el lenguaje te permite mucha libertad 00:25:03
de acción, estupendo 00:25:06
lo vas a tener más fácil para hacer un desarrollo 00:25:08
pero a lo mejor no te das cuenta 00:25:10
de cosas, no te das cuenta 00:25:12
porque el compilador no hace una primera criba 00:25:13
no te das cuenta y a la hora de ejecutar 00:25:16
se hacen errores con los que no contabas 00:25:18
si el lenguaje es muy estricto 00:25:19
es un rollo 00:25:22
porque se hacen errores de compilación todo el rato 00:25:23
y tienes que pensarlo todo más 00:25:25
pero a cambio 00:25:27
es más segura la ejecución 00:25:29
entonces bueno, hay un compromiso 00:25:31
en bases de datos igual 00:25:33
las bases de datos relacionales que no las he visto ya este año 00:25:34
imponen tropecientas restricciones 00:25:37
para hacerlas tablas de relaciones 00:25:40
pero a cambio son muy robustas 00:25:41
luego en su funcionamiento 00:25:43
cuando no queremos tanto arrobuster 00:25:44
es un rollo de una base de datos relacional 00:25:48
por eso hay otros modelos de datos relacionales 00:25:49
pero bueno, es otro tema 00:25:52
en cualquier caso, Java es tiparo 00:25:53
ha incorporado una pequeña 00:25:55
un pequeño matiz en las versiones 00:25:57
estas últimas 00:26:00
que bueno, dejamos para su momento 00:26:01
para no contar cada cosa 00:26:03
añadiendo muchas cosas 00:26:05
para tratar de huir un poco de esto 00:26:07
pero ahora ya es un parchecillo 00:26:09
que lo que hace es 00:26:11
te permite no comprometerte en un momento un tipo de dato 00:26:12
pero una vez que te has comprometido no puedes cambiarlo 00:26:15
es un parche medio raro 00:26:16
bueno, pues a ver, Java 00:26:18
hasta el uso 00:26:20
os vais a ver en todas partes 00:26:22
y vais a usar siempre 00:26:24
y vais a ver en cualquier lado que vais a trabajar 00:26:25
al menos a corto plazo 00:26:27
Java exige que tú comprometas 00:26:30
El tipo de dato que vas a salvar en una variable 00:26:34
Antes de usarlo 00:26:35
Bueno, pues entonces la siguiente pregunta es 00:26:36
¿Y qué tipos de datos tenemos? 00:26:39
Bueno, pues tipos de datos en Java 00:26:42
Esa sería la siguiente cosa 00:26:43
¿Qué tipos de datos tengo? 00:26:45
¿Qué alternativas tengo? 00:26:47
Vale, pues tengo estos 00:27:01
Aquí ya tenemos que empezar a dar información 00:27:02
Pues bueno, que hay que darla 00:27:04
Porque es básica y hay que conocerla 00:27:06
Vale, para guardar números 00:27:07
Hay dos tipos de números en general 00:27:09
Los enteros 00:27:12
Y los que llevan decimales 00:27:14
Los números reales 00:27:16
Bueno, pues para guardar números enteros 00:27:17
Hay hasta cuatro tipos de datos 00:27:20
Cuatro tipos diferentes 00:27:24
By, short, in 00:27:27
Y long 00:27:29
Y estos son para guardar enteros 00:27:31
Numeritos enteros 00:27:35
Positivos y negativos 00:27:38
¿Vale? 00:27:41
Positivos y negativos 00:27:43
¿Por qué hay cuatro tipos de datos? 00:27:44
Hombre, porque a lo mejor hay aplicaciones 00:27:59
Que van a trabajar solo con números enteros 00:28:01
Pues como mucho 00:28:03
Que alcancen un valor absoluto de 400, 500 00:28:04
A lo mejor hay aplicaciones que trabajan con números muy grandes 00:28:08
Bueno, pues se diferencian 00:28:10
En la cantidad de bits 00:28:14
Que dedican cada uno 00:28:15
almacenar la variable. Las variables byte, las variables de tipo byte dedican solo, ocupan 00:28:18
más que dedican, ocupan solo 8 bits de memoria RAM para guardar el dato. Sin embargo, las 00:28:28
variables short dedican 16 bits para guardar el dato. Sin embargo, las variables in dedican 00:28:38
32 bits 00:28:46
Y las variables log 00:28:47
Dedican 64 00:28:50
Entonces, que yo voy a usar 00:28:51
Números muy grandotes 00:28:57
Pues puedo usar el tipo log 00:29:00
Porque el tipo log me va a dar 00:29:03
Números de 00:29:05
La codificación en complemento a 1 00:29:07
O complemento a 2, imagino que no habéis visto 00:29:12
Nada de sistemas todavía, ni os suena 00:29:14
O a lo mejor os suenan los de sistemas 00:29:15
los que ha dicho el grado medio 00:29:18
no nos vamos a meter en ellos, no tiene mayor importancia 00:29:19
pero 00:29:22
esto que yo menciono ahora 00:29:22
de complemento a 1 o complemento a 2 00:29:26
son formas de codificar 00:29:28
los números enteros en binario 00:29:30
en ordenador, porque lo que sí que sabéis 00:29:32
claro es que en ordenador todo está codificado 00:29:34
con ceros y unos, ahí sí que no hay alternativa 00:29:36
todo está con ceros y unos 00:29:38
pues si yo quiero un número entero 00:29:39
para pasarlo a ceros y unos 00:29:41
están estos mecanismos, complemento a 2 00:29:43
Y complemento a 1 00:29:46
Entonces este mecanismo 00:29:47
El complemento a 2 00:29:50
Sigue unas reglas 00:29:51
Como que el bit más significativo 00:29:53
Es el de signo 00:29:56
El que me indica si el número es negativo o positivo 00:29:57
Porque los números enteros son negativos o positivos 00:30:00
Entonces el bit más significativo 00:30:01
Me indica el signo 00:30:04
Si es positivo o negativo 00:30:07
Y el resto de bits 00:30:08
Ya me codifica el valor del número entero 00:30:09
Pero en binario 00:30:12
Entonces por ejemplo 00:30:13
no, tendríamos 63 bits 00:30:16
para el valor absoluto 00:30:18
los que os suene esto 00:30:21
que esto en particular no nos importa a nosotros 00:30:23
pero bueno, es cultura informática 00:30:25
que en algún momento os tiene que sonar 00:30:27
si no es por aquí os tendrá que sonar por sistemas 00:30:29
pues con 63 bits 00:30:31
uno puede codificar 00:30:34
números, el número más alto 00:30:36
que puede codificar 00:30:38
es este, ¿verdad? 00:30:39
2 elevado a 63 00:30:41
¿no? 00:30:42
Con 63 bits 00:30:43
¿Vale? 00:30:46
Bueno, no, 263, no, 264 menos 1, perdón 00:30:50
¿Vale? Este 00:30:53
¿No? O sea, con 2 bits, pues uno puede codificar 4 números 00:30:57
¿Vale? 00:31:00
Bueno, esto nos da igual 00:31:02
Lo que quiero decir es que cuantos más bits haya 00:31:04
Puedes codificar números en valor absoluto más grandotes 00:31:06
Obviamente, eso es evidente 00:31:10
Puedes codificar números más grandotes 00:31:12
cuantos más bits haya 00:31:15
y el número máximo que puede codificar el long 00:31:16
es gigantesco, muy grande 00:31:19
entonces aplicaciones que vayan a trabajar 00:31:21
con números enteros tan grandes 00:31:23
pues es raro que haya 00:31:25
entonces normalmente el tipo de dato que se usa 00:31:26
normalmente por defecto 00:31:29
cuando uno va a trabajar con números enteros 00:31:30
suele ser este, este es el más habitual 00:31:33
cada vez que trabajamos con números enteros 00:31:35
usamos este 00:31:37
vale, entonces ahora 00:31:38
cuando lo veamos en la pantalla 00:31:41
pues podemos mirar por curiosidad 00:31:43
cuál es el número máximo positivo y el número mínimo negativo 00:31:44
que me permite codificar un IN, un LONG, un SHORT, 00:31:50
por si yo tengo que tomar una decisión en un momento dado 00:31:52
de qué tipo de datos se adapta más. 00:31:54
Bueno, pues para eso valen estos cuatro, 00:31:57
para codificar números enteros, positivos y negativos. 00:31:58
Y la diferencia entre ellos es el tamaño que dedica en RAM. 00:32:02
Cuanto menos tamaño dedique en RAM, en principio sería mejor, 00:32:08
menos RAM ocupada. 00:32:10
Pero bueno, la RAM tampoco tendría que ser un problema en la mayoría de las aplicaciones. 00:32:11
Vale, pues ya sabemos que aparte de enteros, hay números con decimales, que también podemos necesitar codificar. 00:32:17
Nuestras aplicaciones pueden trabajar con decimales, claro, con notas decimales, con precios, una aplicación de factura y cada decimales. 00:32:23
Bueno, pues para codificar números decimales, tenemos dos tipos de datos. 00:32:31
tenemos el float 00:32:36
y el double 00:32:48
esto para codificar números reales 00:32:51
o decimales 00:32:56
como os guste más llamarlos 00:32:57
o sea su número 00:33:00
su nombre 00:33:01
adecuado sería llamarles números reales 00:33:05
vale, pero bueno 00:33:12
si os gusta más decimales, no, no, no 00:33:13
números con cifras decimales 00:33:15
¿Vale la diferencia entre ellos? Pues que Float usa 32 bits para guardar el número decimal y Dabble usa 64 bits. 00:33:17
¿Cómo se codifican los números decimales? Con un sistema de codificación que no nos vamos a meter aquí porque es una historia, 00:33:34
pero la diferencia entre FOAD y DABEL 00:33:51
es que DABEL permite más precisión 00:33:53
como su nombre indica 00:33:56
y permite guardar números 00:33:57
con más cifras decimales 00:34:00
¿vale? con más cifras decimales 00:34:01
entonces si yo quiero mucha precisión 00:34:03
o lo que es lo mismo, muchas cifras decimales 00:34:06
la precisión para mí es importante 00:34:07
pues utilizaré el DABEL 00:34:09
y si no quiero mucha precisión 00:34:11
utilizaré el FOAD 00:34:14
ambos son para lo mismo, para cifras decimales 00:34:15
¿vale? 00:34:18
Bueno, pues ya llevamos seis tipos de datos 00:34:21
Nos faltan en realidad 00:34:24
Dos, nada más 00:34:25
Aparte de números, ¿qué otra cosa se puede almacenar en una variable? 00:34:27
Una letra, un carácter, punto pelota 00:34:34
Y para guardar una letra, un carácter 00:34:36
Lo que llamamos un char, en general 00:34:40
El tipo de dato, ¿cómo se llama? 00:34:42
Pues char, como nos podríamos imaginar 00:34:45
Y el char es para guardar un carácter 00:34:47
y se acabó 00:34:52
solo uno 00:34:54
en la variable char 00:35:03
solo cabe la codificación de un carácter 00:35:05
char en realidad 00:35:07
ocupa, aunque estos detalles 00:35:09
no nos importan mucho a nosotros tampoco 00:35:12
ocupa memoria de 16 bits 00:35:14
aunque la mayoría de las veces 00:35:16
solo 00:35:18
este es el que nos interesa, porque de hecho en la tabla 00:35:19
solo se tienen en cuenta 00:35:21
8 bits 00:35:24
pero Java utiliza el unicode 00:35:25
para codificar caracteres 00:35:27
lo utiliza internamente el unicode que se llama 00:35:29
y que en el unicode son 16 bits 00:35:31
entonces la variable char son 16 00:35:34
pero vamos 00:35:35
lo que va aquí dentro es el código 00:35:36
en realidad es el código asti según la tabla asti 00:35:39
del carácter 00:35:42
entonces un char y ya está 00:35:43
¿que uno quiere guardar nombres? 00:35:45
pues tiene que guardar la variable char 00:35:48
la variable es char 00:35:49
nada más 00:35:52
¿y cuál nos falta? 00:35:53
nos falta una que es medio rara 00:35:57
que recoge la siguiente idea 00:35:59
la información normalmente son datos 00:36:04
¿verdad? son datos 00:36:10
pues una serie de caracteres 00:36:11
que sean nombres, una serie de números 00:36:14
la información son datos, normalmente son datos 00:36:15
pero la información a veces también es 00:36:18
saber si algo ha ocurrido o no ha ocurrido 00:36:20
eso también es información 00:36:23
¿no? saber si algo pasa o no 00:36:24
eso es información también 00:36:27
De hecho, para un programa 00:36:28
Es una información interesante 00:36:31
Porque muchas veces en función de si algo ocurre o no 00:36:33
Es decir, en función de esa información 00:36:35
Hace una cosa o hace otra 00:36:38
Entonces 00:36:39
Lo que se plantea Java 00:36:41
Es tener una variable 00:36:45
Para guardar la siguiente información 00:36:46
Si o no 00:36:49
Es decir, esto es verdad o esto es mentira 00:36:51
Verdad o mentira 00:36:54
Para guardar eso 00:36:55
Podría haberse planteado este lenguaje y muchos otros sin la necesidad de este tipo de datos 00:36:55
Y nosotros por programa codificar el que algo ha ocurrido, por ejemplo, con un char que diga S 00:37:03
Y codificar el que algo no ha ocurrido con un char que diga N 00:37:10
Podríamos hacerlo así, nuestro programa tira y recogería así la información 00:37:15
La información de si algo ha ocurrido sería una S y la información de si algo no ha ocurrido sería una N 00:37:19
pero eso ya sería 00:37:24
un convenio nuestro 00:37:27
una decisión nuestra 00:37:29
entonces es más 00:37:30
es más generalizable todo 00:37:32
si nos planteamos 00:37:35
una variable 00:37:38
que codifique 00:37:38
si algo ha ocurrido o no 00:37:40
y solo eso, y no codifique más cosas 00:37:42
porque un char puede codificar aparte de la s y la n 00:37:45
puede codificar la o, la p 00:37:47
pues no, java ha hecho una variable 00:37:49
que se llama boolean 00:37:51
el tipo de dato 00:37:53
porque es lo que estamos viendo 00:38:00
el tipo de dato es boolean 00:38:02
y esta variable 00:38:04
sirve para guardar esa información 00:38:07
la información de verdad 00:38:12
o mentira 00:38:29
esa es la información que guarda 00:38:32
verdad o mentira 00:38:38
y la guarda 00:38:39
de esta manera 00:38:41
según este convenio 00:38:44
Cuando tenga true 00:38:45
Cuando tenga true 00:38:48
Y cuando digo true no digo la cadena true 00:38:50
Sino la forma en la que Java guarda en binario 00:38:52
Esa idea de true 00:38:54
Cuando tenga esto 00:38:55
Luego ya veremos en este programa 00:38:57
Como ver si lo que ha guardado es esto 00:38:59
Cuando tenga true será haber codificado verdad 00:39:01
Y cuando tenga false 00:39:04
Estará codificando 00:39:06
O almacenando mentira 00:39:09
Y solo puede tener estos dos valores 00:39:10
No puede almacenar nada más que esto 00:39:12
vale, pues las variables Boolean 00:39:15
con estos dos posibles valores 00:39:32
y solo estos dos posibles valores 00:39:34
se usan en muchos lenguajes de programación 00:39:35
y su existencia nos permite 00:39:38
cosas como entender 00:39:40
más fácilmente los códigos de otros 00:39:42
¿no? porque si otros recogen 00:39:44
la información de verdad o mentira 00:39:46
con una S o con una N 00:39:48
lo tengo que imaginar yo, que la recogen así 00:39:50
o si la recogen con un 0 o con un 1 00:39:51
lo tengo que interpretar yo, que la han recogido con un 0 y con un 1 00:39:53
es un poquito más complicado 00:39:56
pero que existan variables boolean para recoger 00:39:58
pasa o no pasa, verdad o mentira 00:40:00
y además 00:40:03
con estos términos 00:40:04
nos permite de alguna manera trabajar 00:40:06
de forma más homogénea a todo el mundo 00:40:08
y entender más los códigos de otros 00:40:10
pero eso nos iría a dejar en el diario 00:40:12
podríamos guardar 00:40:14
esta misma información 00:40:16
con las variables que ya tenemos 00:40:17
pero claro, estableciendo un convenio 00:40:19
que sería un convenio del programador 00:40:22
no un convenio general 00:40:24
Bueno, estos son los tipos de datos que existen en Java. 00:40:29
Y estos tipos de datos se llaman primitivos. 00:40:32
Tipos de datos primitivos en Java. 00:40:42
Son los que hemos dicho, los primitivos, porque son los originales, los que trae de serie. 00:40:44
Y todo esto, de nuevo, pues os lo vais creando en la cabeza. 00:40:54
Los tipos de datos primitivos son estos que hemos mencionado, pero no se va a ver a ninguno. 00:40:58
y cualquier otra información que queramos 00:41:02
guardar y con la que queramos trabajar 00:41:06
tiene que ser 00:41:08
con muchos de estos 00:41:10
con muchos de estos, no hay otro 00:41:12
con muchos de estos 00:41:14
luego ves que claro, muchos de estos es un rollo 00:41:15
por ejemplo, si yo quiero trabajar 00:41:18
con páginas de un libro 00:41:20
pues cada página tiene muchos caracteres 00:41:22
cada página son un montón de chat 00:41:25
entonces es un rollo trabajar con un montón de chat 00:41:26
pues hay que trabajar con un montón de chat 00:41:29
lo que pasa es que claro 00:41:30
lo que hace Java es ya darnos 00:41:32
software hecho 00:41:34
para trabajar de golpe con un montón de chat 00:41:35
pero lo hace él, trabaja con un montón de chat 00:41:38
y yo lo uso 00:41:41
y eso es lo que se llaman las clases 00:41:41
ese concepto de clases 00:41:45
las clases son 00:41:46
código ya hecho 00:41:49
que me permite a mí 00:41:50
abstraerme de ciertas tareas 00:41:52
lo uso 00:41:55
y se acabó 00:41:57
Bueno, pues en este caso 00:41:58
Si yo quiero trabajar con datos 00:42:01
Que no sean exactamente de estos tipos 00:42:04
Sino que sean muchos de ellos 00:42:06
Combinaciones 00:42:07
Pues un tipo de datos que me interesa 00:42:09
Quiero que sean números y luego letras después 00:42:12
Ese tipo de datos no se recoge en ningún dato primitivo 00:42:15
Pues tengo que combinar estas variables 00:42:17
O las combino yo y las trabajo yo 00:42:21
Combinándolas y usando varias de ellas 00:42:23
o a lo mejor si hay una clase 00:42:26
me lo hace estupendo 00:42:29
o si no la puedo hacer bien 00:42:29
pero los tipos de datos primitivos que hay son estos 00:42:31
y no hay más que estos 00:42:33
cualquier dato que yo quiera almacenar 00:42:34
tiene que ser con muchos de esos 00:42:37
con muchos 00:42:39
y como normalmente trabajamos con muchos 00:42:40
pues entonces existe ya código hecho 00:42:43
para trabajar con muchos de estos 00:42:45
como son los arrays, las colecciones, etc 00:42:47
que forman parte de todo lo que tenemos que ver 00:42:50
pero ahora mismo tenemos que 00:42:52
saber usar tipos primitivos de datos 00:42:53
y trabajar con ellos 00:42:56
vale 00:42:58
relajamos un poquito 00:43:00
pero mientras paso lista 00:43:03
y así para las dos últimas horas 00:43:04
y así descansáis un poco 00:43:06
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
19
Fecha:
25 de septiembre de 2023 - 12:01
Visibilidad:
Público
Centro:
IES ROSA CHACEL
Duración:
43′ 10″
Relación de aspecto:
1.78:1
Resolución:
1280x720 píxeles
Tamaño:
823.89 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid