Saltar navegación

20241003 ProgrEstruct-Decision_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 7 de octubre de 2024 por Raquel G.

12 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, pues en lo que estábamos, lo que no incorporamos el otro día, las cadenas de caracteres, ¿las podemos leer por teclado? 00:00:01
Hombre, claro, si no pudiéramos leerlas por teclado y tuviéramos que ponerlas siempre ahí en el código, ¿de qué nos sirve? 00:00:08
Es como un programa para sumar dos números. 00:00:13
Si los dos números yo no se los puedo meter por teclado, sino que tienen que ser siempre los dos números que yo ponga en el código, ¿para qué me vale esa aplicación? 00:00:17
Bueno, pues las cadenas de caracteres también las podemos leer por teclado, lógicamente. 00:00:25
Y lo mismo para leer por teclado 00:00:29
Disponemos de este objeto 00:00:32
Que ya hemos usado 00:00:34
Para leer numeritos 00:00:35
Que ya sabemos que 00:00:37
Aunque no lo entendamos 00:00:40
Del todo o del nada 00:00:42
Ya sabemos que lo tenemos que 00:00:44
Que asignar así 00:00:46
Lo declaramos, es este tipo 00:00:49
Objeto raro, escáner 00:00:52
Y así le tenemos que asignar 00:00:54
Una vez que hemos hecho esto 00:00:57
Este objeto ya puede 00:00:58
Leer una y otra vez lo que a mí me dé la gana 00:00:59
Una y otra vez 00:01:02
Por ejemplo, aquí en lugar de asignarle el nombre directamente 00:01:02
Podríamos 00:01:06
Dárselo 00:01:07
¿Vale? 00:01:09
Por teclado 00:01:16
Por ejemplo 00:01:17
Introduzca nombre 00:01:19
Y ahora 00:01:23
¿A quién le vamos a asignar lo que leamos por teclado? 00:01:27
Venga, pues a esta misma variable 00:01:31
A nombre 00:01:32
¿Vale? 00:01:33
A nombre 00:01:36
¿Qué le vamos a asignar? 00:01:37
El resultado de leer por teclado 00:01:39
Pero ahora ya no es un int 00:01:41
Con lo cual no hacemos next int 00:01:43
No es un double, con lo cual no hacemos next double 00:01:45
No es un boolean, con lo cual no hacemos next boolean 00:01:47
Es un string 00:01:50
Entonces no es next string 00:01:51
Una pena 00:01:54
Porque si no sería todo igualito, pero no 00:01:55
Es algo también muy intuitivo 00:01:57
Next line 00:01:59
¿Vale? Es next line 00:02:00
Pues ya está, next line ¿qué es lo que hace? 00:02:02
Es una acción 00:02:06
Del escáner, que cuando yo la invoco 00:02:07
Cuando yo invoco esa acción 00:02:09
Se queda esperando 00:02:11
Que yo meta lo que sea 00:02:12
Hasta un enter 00:02:14
Y cuando ya he llegado al enter, coge todo eso 00:02:16
Que son caracteres así, números, espacios 00:02:19
Letras, lo que sea, coge todo hasta el enter 00:02:21
¿Vale? 00:02:23
Esto es lo que hace el next line 00:02:25
Coge del teclado todo lo que metamos 00:02:26
Hasta un 00:02:38
Salto de línea 00:02:44
Para hacerlo más corto 00:02:45
Sea lo que sea 00:02:49
y ahora ya pues con ese nombre 00:02:50
uno ya podría hacer lo que quiera 00:02:52
concatenarlo, aquí lo hemos concatenado dos veces 00:02:53
y lo mostramos, pues nos aparecería 00:02:56
dos veces, mostramos el carácter en la posición 00:02:58
tres 00:03:00
vamos a ponerlo 00:03:01
para U, para ejecutarlo 00:03:04
y ver que se hace bien 00:03:06
posición tres 00:03:08
carácter en posición 00:03:21
tres, lo mostramos aquí 00:03:23
ahora vamos a poner el tamaño 00:03:24
longitud 00:03:27
de la cadena 00:03:33
mostramos la longitud de la cadena 00:03:35
que hemos leído aquí, le damos 00:03:40
asignado a esta variable, mostramos la variable 00:03:41
y ahora vamos a ver 00:03:43
si la cadena es igual 00:03:45
a esto, me va a decir 00:03:47
falso, vale, obviamente 00:03:49
me va a decir falso, a menos que yo le meta esto directamente 00:03:51
claro 00:03:53
vale, pues si probamos 00:03:54
a ejecutar esto 00:03:57
vale 00:03:59
introduzca nombre 00:04:01
vale, pues primero me ha mostrado 00:04:03
la concatenación de los dos, que era lo primero que yo había 00:04:06
hecho en mi código, concatenar 00:04:08
nombre más nombre, asignarlo a nombre dos 00:04:10
y mostrarlo 00:04:12
carácter en posición tres, la E 00:04:14
efectivamente, porque cero es la P 00:04:15
uno es la E, dos es 00:04:18
la P y tres es la E, pues justo 00:04:20
me lo ha mostrado bien, longitud de la 00:04:22
cadena, cuatro, efectivamente, tiene cuatro 00:04:24
caracteres, es igual a 00:04:26
la bla bla bla que yo he puesto ahí 00:04:28
no, no es igual, por eso me sale 00:04:30
falso vale si metiéramos la bla bla bla está pues obviamente me daría true vale me da la 00:04:32
concatenación carácter en posición 3 la efe longitud de la cadena esta vez 5 bueno pues 00:04:52
con este uso básico de cadenas ya podemos hacer muchas cosas que necesitamos entonces a lo que 00:04:57
íbamos aún así está este listado de ejercicios es para ver que con los objetos string se pueden 00:05:07
hacer más cosas porque pueden hacer muchas más acciones que estas tres que hemos visto vale esto 00:05:14
de aquí es para mostrar el igual si eso ya lo conocemos este de aquí es para mostrar es la 00:05:21
acción to upper case por nombre ya lo podemos deducir le das una cadena y te devuelve la 00:05:28
cadena en mayúscula, vale 00:05:35
es decir, si 00:05:37
lo pongo solo 00:05:39
como ejemplito, pero repito, estos métodos 00:05:41
bueno, que nos suene, que los objetos 00:05:43
string pueden hacer muchas cosas 00:05:45
pero no hace falta que nos sepamos de memoria 00:05:47
cuantas y como son 00:05:49
vale, por ejemplo, si a la cadena 00:05:51
esta nombre, yo le 00:05:53
llamo a ese método 00:05:55
me va a devolver la 00:05:57
cadena en mayúscula 00:05:59
por ejemplo, si la guardo aquí 00:06:01
vale, si yo mostrara esto 00:06:05
si yo mostrara esto 00:06:09
me devolvería la variable 00:06:21
en mayúsculas 00:06:22
cualquier cosa 00:06:24
y me la darán, vale 00:06:25
entonces estos ejercicios son solamente para eso 00:06:29
son ejercicios de una línea para probar esos métodos 00:06:31
lo que hacen para ganar 00:06:34
pero nada más, no espero ahora mismo 00:06:35
que os sepáis 00:06:38
que esos métodos existen y de memoria 00:06:39
además, cuál es su 00:06:42
sintaxis, vale 00:06:44
este es para el led que lo conocemos 00:06:46
este para probar el operador 00:06:48
más que también lo conocemos 00:06:50
que se puede concatenar también 00:06:51
con esta acción pero si ya 00:06:54
tenemos esta pues para que complica el código 00:06:56
esta es para sacar 00:06:58
la subcadena de una cadena 00:07:01
esta es interesante muchas veces 00:07:03
entonces tenemos 00:07:06
una cadena 00:07:08
y queremos sacar solo una parte 00:07:09
pues se llama este método 00:07:12
Substream pasándole un índice 00:07:14
Y te saca la cadena que hay 00:07:16
A partir de ese índice 00:07:18
Solo quiero que os suenen que se pueden hacer muchas cosas 00:07:19
Con las cadenas para operar con ellas 00:07:22
Substream pues eso es un poco más complicado 00:07:23
Este, reemplazar 00:07:26
Le pasas un carácter 00:07:28
Y de la cadena que llama a esta acción 00:07:29
De la cadena que llama a esta acción 00:07:32
Sustituye un carácter por el otro 00:07:34
Y ya está 00:07:36
Si empieza con o termina con 00:07:38
Te devuelve un boolean 00:07:40
Y el charlat que ya lo hemos visto 00:07:41
Y así muchos más métodos 00:07:43
Aparte de estos, ¿vale? 00:07:45
Bueno, pues si uno los quiere hacer 00:07:47
Es poner esa línea para probar el método 00:07:49
Como funciona, ya está, pues fenomenal 00:07:51
¿Vale? 00:07:53
Vale 00:07:56
Y ya está, esto es lo que tenemos aquí 00:07:58
Vale, antes de pasar 00:08:01
A esto de aquí, que ya lo estaréis 00:08:05
Deseando, porque estamos ya haciendo lo mismo 00:08:07
Una y otra vez 00:08:09
Pues antes de pasar esto de aquí 00:08:10
Vamos a hacer una pequeña tontería 00:08:12
¿Vale? 00:08:16
Os he dicho 00:08:19
Por Dios nunca jamás 00:08:19
Porque os suspendo este curso 00:08:21
Y el módulo de segundo 00:08:23
Ya crédito 00:08:25
Pues lo digo ahora 00:08:26
A lo mejor estabas dormido hablando con 00:08:29
Jesús 00:08:31
Bueno, pues entonces lo digo ahora 00:08:32
Yo os he dicho por Dios santo bendito 00:08:39
Cuando comparéis dos variables string 00:08:42
A ver si vais a poner el doble igual 00:08:44
Eso nunca jamás 00:08:45
Porque si ponéis el doble igual 00:08:47
Que era lo que ocurría 00:08:49
Recordáis que estábamos en ese caso 00:08:51
Justo 00:08:54
Justo 00:08:55
Si yo pongo 00:08:57
Vamos a hacerlo aquí con 00:08:58
String 00:09:00
Cadena 1 00:09:02
Igual a 00:09:04
Hola 00:09:07
y ahora pongo aquí otra cadena 2 00:09:10
en líneas separadas para que se vea mejor 00:09:17
igual a hola 00:09:20
vale, entonces 00:09:27
vamos a mostrar a ver si son iguales 00:09:29
vale, entonces 00:09:33
1, ya he dicho 00:09:34
debemos mostrar como son cadenas de caracteres 00:09:40
nunca haríamos esto, cadena 1 igual a cadena 2 00:09:43
Esto lo hacemos si queremos ver 00:09:47
Obtener el boolean resultante 00:09:53
De ver si esta variable 00:09:55
Es igual a esta otra 00:09:57
Pero siendo estas variables 00:09:58
Cualquiera de los tipos primitivos 00:10:00
By, short, in, long, flow, double, char y boolean 00:10:01
Para cualquiera de esos tipos primitivos 00:10:05
Si yo quiero ver si el contenido de una variable 00:10:07
Es igual al de otra, doble igual 00:10:10
Ahí está clarísimo 00:10:11
Vale, pero este es el primer tipo 00:10:13
No primitivo objeto que introducimos 00:10:15
vale, efectivamente, entonces yo aún así 00:10:17
en dos variables de tipo objeto 00:10:20
también puedo necesitar saber 00:10:22
si contienen lo mismo 00:10:24
esta contiene hola 00:10:26
en este caso concreto y esta otra también 00:10:28
contiene en este caso concreto 00:10:30
vale, entonces hemos dicho, no, nada de 00:10:32
hacerlo así 00:10:34
lo tenemos que hacer así 00:10:36
vale, y de hecho 00:10:39
probamos el equal, si vemos que funciona 00:10:43
perfectamente, no, voy a 00:10:45
cuando ejecute esto voy a poner aquí 00:10:47
Una 00:10:49
Barrita 00:10:51
Para saber cuando hemos llegado 00:10:54
A ese punto de la ejecución 00:10:57
Vale, pues ejecutamos esto 00:10:58
Aquí 00:11:01
Vale 00:11:02
Y después de la barrita 00:11:05
True, false 00:11:07
Le he puesto dos system out 00:11:09
Ah, que me he dejado otro 00:11:10
¿Dónde está? 00:11:13
Ah, vale, que este iguales no sé dónde 00:11:17
Ah, es que este iguales lo he cortado 00:11:19
Era de arriba en realidad 00:11:20
Este iguales venía de 00:11:22
De por ahí arriba 00:11:24
De por ahí 00:11:25
Vale, entonces ahora ya sí 00:11:30
Lo ejecutamos, bueno 00:11:37
Vale, y me da true porque las dos cadenas 00:11:38
Son iguales, eso está claro, es lo que esperamos 00:11:41
¿No? Vale 00:11:43
Si yo aquí cambiara y me 00:11:44
Pusiera esta otra 00:11:47
O si las estoy introduciendo por teclado e introdujera dos 00:11:48
Distintas, da igual 00:11:51
Pues ejecutamos esto 00:11:52
Falso 00:11:54
¿Vale? Pues el igual funciona exactamente como nosotros esperamos y es lo que tiene que hacer, ¿vale? 00:11:57
Bueno, pues ¿qué he dicho yo? Cuidado a ver si uno va a escribir así deprisa a toda velocidad y compara cadena 1 con cadena 2 así, ¿vale? 00:12:02
cuidado 00:12:16
porque si compara cadena 1 00:12:19
con cadena 2 así 00:12:21
vale, acordaos 00:12:22
rápidamente de lo que estábamos haciendo 00:12:26
que nadie se le olvide 00:12:28
que entonces 00:12:30
tenemos, esta es la cadena 00:12:32
este es 00:12:33
vale, que sí, que sí 00:12:36
vale, esta es la cadena 1 00:12:42
se llame como se llame 00:12:48
vale 00:12:49
Esta es 00:12:55
La cadena 2 00:12:59
Y entonces sabemos que cadena 1 00:13:07
En realidad es una dirección de memoria 00:13:13
Con lo cual cadena 1 lo que tiene dentro 00:13:15
En realidad es una dirección de memoria 00:13:17
Que me lleva a un espacio en memoria RAM 00:13:19
Donde ahora ya 00:13:21
Si que está 00:13:23
El hola dentro 00:13:25
Ahí si que está el hola 00:13:27
Y cadena 2 00:13:28
Es otra dirección de memoria 00:13:31
que me lleva 00:13:32
a otro espacio 00:13:33
donde ahora ya sí que está el contenido 00:13:36
¿vale? todo el mundo 00:13:38
aunque no lo tenemos que tener presente 00:13:46
todo el rato, todo el mundo 00:13:48
entiende que 00:13:50
esto es lo que físicamente hay en memoria 00:13:51
cuando declaramos dos variables objeto 00:13:54
cadena 1 en realidad es una dirección 00:13:56
y esa dirección 00:13:58
de donde es, es la dirección de una porción 00:13:59
de RAM donde ahora ya sí que está el valor 00:14:02
y cadena 2 00:14:04
es una dirección de memoria 00:14:06
que de dónde es esa dirección, de otra porción de RAM 00:14:07
donde ya sí que está el valor 00:14:10
si esta variable fuera primitiva 00:14:11
cadena1 fuera un int 00:14:14
esto no existiría 00:14:16
cadena1 sería ya directamente 00:14:17
el valor de la variable 00:14:21
el 3, el 7 00:14:22
esta parte no existiría 00:14:24
pero como es un tipo objeto 00:14:25
es una dirección que lleva una 00:14:28
porción de memoria donde está el contenido 00:14:30
pues por eso es por lo que nos ha quedado 00:14:32
ya clarísimo y no se nos puede olvidar 00:14:34
Que si nosotros tratamos de comparar 00:14:36
La igualdad de esas dos cadenas de ahí 00:14:39
Este hola y este hola 00:14:41
Tratamos de compararlo 00:14:43
Con esto, me va a decir 00:14:45
False 00:14:47
Porque esta dirección 00:14:48
Es una y esta dirección es otra 00:14:51
Otra, que contienen lo mismo 00:14:53
Sí, contienen lo mismo 00:14:55
Pero son diferentes 00:14:56
Y el equals precisamente 00:14:58
Lo que te hace es 00:15:00
Comparar el contenido 00:15:02
El equals es el que hace ese trabajo 00:15:04
Puedo irse aquí, mirar el contenido 00:15:06
Irse aquí, mirar el contenido, etc 00:15:07
Bueno, pues si uno se olvida y escribe así 00:15:09
Rápidamente 00:15:11
Y lo vuelve a hacer 00:15:12
Vale 00:15:14
Esta vez ha salido bien 00:15:17
Vale, ha salido falso 00:15:21
No, no, no, perdón, perdón 00:15:23
Ha salido falso pero lo he cambiado 00:15:25
Vale 00:15:26
Olvidaos de esta ejecución, esta ejecución no ha existido 00:15:28
Vale 00:15:31
Es que no me había dado cuenta que lo había 00:15:32
Vale, yo he puesto hola y he puesto hola 00:15:35
Y ahora me he equivocado y he puesto esto mal. 00:15:37
¿Vale? 00:15:41
Me he equivocado y he puesto esto mal. 00:15:41
Venga, pues ahora ya sí lo volvemos a ejecutar. 00:15:43
Lo volvemos a ejecutar. 00:15:47
¡Ostras! 00:15:51
Y sale true. 00:15:51
Y entonces decís, pues me han mentido. 00:15:54
Me han mentido. 00:15:57
Y entonces llegáis a la conclusión errónea. 00:15:58
Anda, pues entonces los tipos objeto, entre ellos los string. 00:16:02
vaya rollo moruno que me han contado 00:16:05
los puedo comparar 00:16:08
con doble igual, ¿no? 00:16:09
porque es que he hecho la ejecución y ha salido 00:16:11
que son iguales, y no es verdad 00:16:13
con lo que me han contado, no es verdad 00:16:15
¿vale? 00:16:17
pero es que esto es, bueno 00:16:19
uno de los montón de 00:16:21
pequeñas cosas que hace Java 00:16:23
por dentro para evitarse la vida 00:16:25
que se puede manifestar a veces, y esta en particular 00:16:27
os la cuento como anécdota 00:16:30
os la cuento como anécdota 00:16:31
A ver, ¿qué hace Java por dentro en realidad? Tú declaras una cadena de buenas a primeras y le asignas un valor. Y luego de repente declaras otra y le asignas el mismo de la de arriba. Esa es una situación muy concreta, ¿no? Muy concreta. 00:16:33
Pues entonces lo que hace es 00:16:49
Dice, oye, pues mira 00:16:51
En lugar de hacer otro espacio de memoria 00:16:54
Y poner el hola 00:16:55
Voy a hacer que esta dirección de memoria 00:16:56
Voy a hacer que esta cadena 2 00:17:00
En lugar de crearle un espacio de memoria 00:17:02
Pues no lo creo 00:17:04
¿Dónde tengo el borra por ahí? 00:17:05
Claro 00:17:08
Bueno, no sé dónde está el borrador 00:17:08
Pero da igual 00:17:11
Esto 00:17:13
Dice, ¿para qué voy a hacer? 00:17:14
¿Para qué voy a hacer una esta? 00:17:17
Bueno, no hago una de estas, me hago otra cadena 2, porque tengo dos variables string, pero la hago que apunte al mismo sitio, ¿vale? 00:17:19
Entonces, claro, entonces él gestiona una especie de buffer interno hasta cierta cantidad, que no sé si son 2048, no sé qué son. 00:17:30
Si empezáramos a hacer un montón de string, hola, hola, hola, hola, llegaría un momento en que ya no, ¿vale? 00:17:39
Y eso lo he hecho así porque hemos inicializado la variable string de esta manera. 00:17:45
Y esto es un atajo. 00:17:51
En realidad, cuando uno crea un tipo objeto, no lo hace así. 00:17:52
Fijaos cómo hemos hecho el escáner. 00:17:57
Yo he dicho, lector es una variable tipo objeto, por eso tiene este tipo de dato. 00:17:59
Y mirad cómo le hemos dado valor, con new scanner. 00:18:06
Pues a string también podríamos hacerlo hecho, podríamos haberlo hecho. 00:18:10
Podríamos haber hecho new. 00:18:13
string 00:18:15
hola. Y así es como 00:18:17
originalmente 00:18:20
se declaraban. Como es un objeto 00:18:21
yo tengo que hacer new string 00:18:24
y le doy su valor. Pero claro, 00:18:26
como la variable string se usa tantísimo, 00:18:28
la sintaxis de Java te permite 00:18:31
un atajo 00:18:32
y en ese atajo pues tú le pones 00:18:33
directamente hola. Y para otros es muy cómodo 00:18:36
porque es como si fuera una variable primitiva. 00:18:38
Es muy cómodo. ¿Vale? Bueno, pero 00:18:40
asumimos que no hacemos ese atajo, 00:18:42
sino que creamos esta variable objeto 00:18:43
como se crean las variables objeto que ya veremos en el futuro 00:18:46
esto lo estoy contando solo 00:18:48
como anécdota de que 00:18:49
porque me ha salido mal el doble igual 00:18:51
vale, pues entonces 00:18:54
imaginaos que no usamos ese atajo 00:18:56
y que lo hacemos creando el objeto 00:18:57
new string, un nuevo objeto 00:19:00
string, dale este valor 00:19:02
de inicio, etc 00:19:04
pues lo hacemos así 00:19:05
y ahora volvemos a ejecutar esto 00:19:07
Y ahora me da false 00:19:11
Y ahora me da false, ¿por qué? 00:19:16
Porque cuando lo hacemos así 00:19:18
Java no se hace este invento 00:19:20
El new dice que me obligas con new 00:19:22
Pues me hago otro espacio de memoria, con otra dirección 00:19:24
Entonces si creamos el objeto string 00:19:26
Con new, esto que yo he dicho 00:19:28
De hacer la trampilla y decir 00:19:30
¿Para qué me voy a hacer otro espacio de memoria? 00:19:32
Uso este y lo hago apuntar 00:19:34
¿Vale? 00:19:36
Pues no lo hace 00:19:37
Conclusión, es imposible 00:19:38
Todas estas cosas tenerlas bajo control 00:19:42
Es imposible, porque en matices 00:19:43
Como esto hay mil 00:19:46
¿Qué es lo más fácil? 00:19:47
Pues siempre con equals 00:19:49
Siempre con equals, ¿vale? 00:19:50
Siempre con equals cuando se comparan dos objetos 00:19:53
Y en este caso nosotros solo tenemos 00:19:55
El string, pues los strings siempre con equals 00:19:57
¿Vale? 00:20:00
Vale 00:20:02
Claro, vosotros ahora también 00:20:03
Después del rollo este que os he contado 00:20:07
Si me hubierais escuchado, que sí, que ya se lo habéis escuchado 00:20:09
Después del rollo este que os he contado 00:20:12
Me diríais 00:20:17
Hombre, pero en este código 00:20:18
String cadena 1, string cadena 2 00:20:20
Yo ahora puedo hacer 00:20:22
Cadena 2 igual a 00:20:23
Adiós 00:20:25
Y significa eso 00:20:27
Que entonces cadena 1 también cambia 00:20:29
Porque claro, con lo que yo os he dicho antes 00:20:31
Con esta declaración 00:20:34
Él ha dicho 00:20:36
¿Declaras cadena 2? 00:20:37
No me hago un espacio nuevo 00:20:39
Cuando ve que haces eso 00:20:40
Entonces ya le he dado un espacio a ella 00:20:42
Ya le he dado un espacio a ella 00:20:44
¿Vale? 00:20:45
Claro, porque entonces el programa perdería 00:20:47
Todo el sentido, uno declara dos variables 00:20:50
Para tener ahí dos cadenas 00:20:52
Si las hace siempre la misma 00:20:53
¿Vale? 00:20:55
Bueno, conclusión 00:20:59
Que cuando 00:21:00
Hay que ver si dos cadenas son iguales 00:21:03
Esto, horrible, horroroso 00:21:05
Aunque casualmente en algunas situaciones concretas 00:21:07
Pueda funcionar, pero por esto 00:21:09
Todo que os digo de fondo 00:21:11
Pero como esto 00:21:13
Uno no tiene por qué tenerlo presente 00:21:16
Pues 00:21:17
Se usa siempre el equals 00:21:20
Mucho mejor 00:21:21
Siempre equals 00:21:22
Bueno 00:21:27
¿Dudas? ¿Preguntas? 00:21:28
Algo de 00:21:34
Como un objeto puede contener dentro varios valores 00:21:34
Tú puedes usar el igual igual para comparar 00:21:43
Hay dos valores del mismo objeto 00:21:47
Sí, claro 00:21:49
Y que te diga que sí que pertenece 00:21:50
Claro, a ver, un objeto podría tener dentro 00:21:52
Un int y un char 00:21:54
Entonces, si tú quieres comparar 00:21:55
Tú puedes querer comparar los dos objetos enteros 00:21:58
Y eso significa que todo lo que contiene sea igual 00:22:00
O puedes querer comparar 00:22:02
Solo el int que contiene cada uno 00:22:04
Entonces, accederías a él y ya veremos cómo 00:22:05
Y ese ya sí que con doble igual 00:22:08
Porque son int 00:22:09
Vale 00:22:11
Venga, pues entonces 00:22:12
Nos vamos aquí 00:22:16
Un momento, espera, vamos a abrir el este de operadores 00:22:19
Porque en el este de operadores 00:22:23
Después de los 00:22:25
De los buleanos 00:22:28
Ya nos hemos puesto a hacer ejercicio 00:22:31
Si se han quedado cosas por ahí debajo 00:22:34
Pero vamos, esto solo mencionarlo 00:22:36
Y poco más 00:22:39
Vale, nos habíamos quedado 00:22:39
No, esto era esto de aquí 00:22:42
Los relacionales 00:22:43
que ya nos lo sabemos 00:22:54
y aquí era 00:22:56
lo último que habíamos visto y a partir de aquí 00:22:58
ya nos habíamos puesto a hacer ejercicios para practicar todo esto 00:23:00
¿vale? 00:23:02
entonces 00:23:05
el AND, el OR y el NOT 00:23:05
y la versión de AND y OR 00:23:08
con una símbolo y dos, ya lo sabemos 00:23:10
y sabemos por qué 00:23:12
este, bueno, queda aquí 00:23:12
ya puesto y simplemente 00:23:16
que sepáis que hay una operación 00:23:18
booleana, normalmente es más 00:23:20
raro que haya necesidad de usarla porque expresa 00:23:22
una idea muy extraña, pero que sepáis 00:23:24
que hay una acción booleana que es el 00:23:26
OR exclusivo 00:23:28
el OR exclusivo 00:23:29
este, el XOR 00:23:32
es, funciona 00:23:33
A, OR exclusivo 00:23:36
B, es cierto 00:23:38
¿vale? si 00:23:40
una de las dos es cierto y la otra 00:23:42
falsa 00:23:44
¿vale? pero si las dos son ciertas, no 00:23:45
o sea, es una diferencia con el OR normal, porque el OR 00:23:48
normal, las dos ciertas 00:23:50
una cierta y una falsa 00:23:52
todo eso hace cierto, es esta o esta 00:23:53
las dos ciertas o solo una de las dos 00:23:56
y luego ya sería falso si las dos son falsas 00:23:58
pero el oro exclusivo 00:24:00
es cierto solo si es cierta 00:24:01
una de las dos solamente 00:24:04
una de las dos 00:24:06
si las dos son ciertas es falso 00:24:07
entonces el oro exclusivo es 00:24:09
¿verdad? si solo una de las dos 00:24:11
y solo una es verdad 00:24:15
entonces bueno, hay veces que podemos 00:24:16
necesitar usarlo para expresar una condición 00:24:18
pero bueno, es un caso más raro 00:24:20
en la realidad es muy raro que tú quieras saber 00:24:22
si ocurre esto o esto 00:24:24
pero solo una de las dos 00:24:26
no las dos, es una situación real 00:24:28
rara, pero bueno aquí está y es este 00:24:31
símbolo, vale 00:24:33
vale, y luego aquí ya 00:24:33
vendrán los operadores 00:24:36
de bits, vale, esto pues 00:24:41
otros años los contábamos 00:24:43
pero es que esto no merece la pena porque 00:24:45
prácticamente no se usan 00:24:47
solamente que sepáis que hay 00:24:48
operadores a nivel 00:24:51
de bits que se llaman 00:24:53
nosotros hasta ahora todos los operadores 00:24:54
que estamos usando son como a nivel de variable 00:24:58
en conjunto, sumo una variable 00:24:59
a otra, las sumo enteritas 00:25:02
o las resto, o concateno 00:25:03
dos variables enteras 00:25:05
o hago un and entre dos variables 00:25:07
completas, hasta ahora todas las operaciones 00:25:09
que hemos hecho es, involucran las variables 00:25:11
enteras, sumarlas, restarlas 00:25:14
lo que sea, vale 00:25:16
las variables que son, ay esto de no tener 00:25:17
rotulador, vale 00:25:19
pues las variables que son 00:25:21
La tableta gráfica 00:25:23
Ya, lo que pasa es que 00:25:25
Si tengo que traer la tableta a ordenador 00:25:27
Me traigo un Serpa 00:25:29
A ver 00:25:31
Vamos a ver 00:25:32
Ah, si ya tenía el Word 00:25:36
Ese preparado, vale 00:25:37
Vale, una variable en realidad 00:25:39
¿Qué es? Ya sabemos lo que tiene dentro 00:25:45
Es una cosa, son ceros y unos 00:25:47
¿Vale? Es lo único que tiene una variable 00:25:49
Lo distinto 00:25:51
Lo que varía respecto a C-Synchor 00:25:53
es cómo se interpretan esos ceros y unos 00:25:55
si es un número entero 00:25:57
sabemos que se interpreta como el número entero 00:25:59
que en binario 00:26:01
se correspondería con esto 00:26:03
si es un float o un double 00:26:05
pues esto representa la codificación 00:26:07
double que no la conocemos 00:26:09
pero tiene sus matices por la parte decimal, patatín 00:26:11
la codificación double de ese número de double 00:26:13
si es un char 00:26:15
sabemos que es el boolean 00:26:16
el número de la tabla asti 00:26:18
y si es un boolean 00:26:21
pues un boolean true y false 00:26:23
Imagino que el false 00:26:25
Será todo ceros 00:26:28
Los 8 todo ceros 00:26:29
Y el true será cualquier otra cosa 00:26:30
Imagino, pero no sé exactamente cómo se codifica 00:26:33
El true y el false internamente 00:26:35
En los 8 bits 00:26:37
Seguramente el 0, false 00:26:38
Y cualquier otra combinación que no sea todo ceros 00:26:39
True 00:26:42
En definitiva, las variables 00:26:43
Lo que tienen dentro son ceros y unos 00:26:46
Pero nosotros trabajamos con su significado en conjunto 00:26:48
El número, el char, lo que sea que represente 00:26:51
Bueno, pues puede haber algunas aplicaciones 00:26:53
Que necesiten bits sueltos 00:26:56
Que necesiten bits sueltos 00:26:59
Pues yo que sé 00:27:00
Una operación de control 00:27:02
Que cada bit se asocia a un sensor 00:27:03
El sensor está activo 00:27:06
No está activo según si hay 0.1 00:27:08
Yo creo que el Boolean 00:27:10
No, porque 00:27:11
La capacidad, o sea 00:27:14
El almacenamiento mínimo de una variable es en 8 bits 00:27:16
No lo sé 00:27:18
Claro, pero como hay 8 bits 00:27:22
A ver, eso se podría comprobar fácilmente 00:27:31
Haciendo un casting de un int a boolean 00:27:32
Pero bueno, vamos a dejarlo 00:27:34
Nos da igual 00:27:35
Una variable boolean, le asignamos true o false 00:27:37
Como lo codifique por dentro 00:27:41
Nos da igual, usa 8 bits 00:27:42
Como los usa 00:27:44
No nos metemos en ello 00:27:45
Vale 00:27:47
Pero bueno, cuando uno tiene una variable 00:27:49
del tipo que sea 00:27:52
una variable del tipo que sea, sabe que lo que tiene son bits 00:27:53
ceros y unos, en el caso más 00:27:56
pequeño, en el caso de tener una variable 00:27:58
byte, o tener una variable char 00:28:00
o tener una variable, no char no 00:28:02
tener una variable byte o boolean, pues son 8 00:28:03
si tiene short, pues son 16 00:28:06
si tiene, vale, pero en cualquier caso 00:28:08
es un conjunto como mínimo 00:28:10
de 8 bits, como mínimo 00:28:12
vale, bueno, pues hay aplicaciones 00:28:14
que a lo mejor les interesa 00:28:16
trabajar con bits sueltos 00:28:18
con bits sueltos, para eso no tenemos 00:28:20
variables que nos permitan trabajar 00:28:22
con bits sueltos, lo mínimo son 8 bits 00:28:24
¿qué aplicaciones les puede 00:28:26
interesar trabajar con bits sueltos? aplicaciones muy 00:28:28
raras, aplicaciones pues eso 00:28:30
que sean diferentes sensores, yo tengo 00:28:32
8 sensores y tengo una única variable 00:28:34
de 8, un byte, una variable 00:28:36
byte y cada bit de la 00:28:38
variable byte pues 00:28:40
controla un sensor por ejemplo 00:28:42
en ese caso yo necesito poder 00:28:43
modificar los bits 00:28:46
uno a uno 00:28:47
necesitaría poderlos leer 00:28:48
uno a uno, modificar uno a uno 00:28:52
bueno, pues para eso 00:28:53
hay operadores 00:28:55
de estos de nivel de bits 00:28:58
que te hacen estas cositas 00:28:59
te permiten desplazar a la izquierda 00:29:02
a la derecha, entonces tú coges el que te sale 00:29:04
no sé qué, bueno, cosas 00:29:06
muy específicas a nivel de bits 00:29:07
no las vamos a contar 00:29:09
ni vamos a examinar de ellas 00:29:11
pero que sepáis que existen operadores 00:29:14
Para trabajar a nivel de bit de uno en uno 00:29:16
¿Vale? Por si una aplicación lo necesita 00:29:18
¿Alguna vez lo vais a usar? 00:29:20
Seguramente nunca jamás en la vida 00:29:22
Pero que sepáis que está ahí 00:29:23
Yo creo que no, pero bueno 00:29:26
Vale, pues ahora ya sí que sí 00:29:27
Hemos terminado este fichero 00:29:31
A falta de 00:29:32
Este 00:29:33
Cuadrito final 00:29:35
Que recoge la precedencia de los operadores en general 00:29:40
¿Vale? 00:29:42
Que recoge la preferencia 00:29:45
Bueno, pues ya está 00:29:46
Aquí está la precedencia de operadores 00:29:49
Pero bueno, más o menos 00:29:50
La regla general es multiplicaciones y divisiones 00:29:51
Antes que sumas y restas 00:29:55
Y los aritméticos 00:29:56
Antes que los relacionales 00:30:01
Cuando tenemos menor o igual 00:30:03
O sea, a más b, menor o igual 00:30:05
Pues primero hacemos el a más b 00:30:06
Luego menor o igual, en general 00:30:08
Y ya está, y luego todos esos 00:30:09
Antes que los booleanos 00:30:13
Y luego ya la asignación 00:30:14
Vale, tampoco hay que liarse con esto 00:30:16
Porque es lo que estamos haciendo 00:30:20
Y es lo intuitivo 00:30:21
Bueno, pues nada, damos ya ese fichero 00:30:23
De operadores, los operadores por cerrado 00:30:26
A falta de seguirlos practicando con el uso 00:30:27
Y ahora ya 00:30:30
Sí que sí 00:30:32
Vale, nos vamos a esto 00:30:33
Vale, incorporar otra sentencia más 00:30:38
Bueno 00:30:40
Pues entonces, hasta ahora hemos hecho 00:30:42
Simplemente programas 00:30:46
Que leen valores 00:30:47
operan 00:30:48
con los operadores que conocemos 00:30:51
operan, esos resultados van 00:30:53
a variables 00:30:55
y luego ya con esas variables los mostramos 00:30:55
o sea hemos hecho, hemos formado 00:30:59
expresiones para conseguir valores 00:31:01
y asignar esos valores a las variables 00:31:03
y la única 00:31:05
cosa que ha complicado 00:31:07
es un pelín 00:31:09
es que el valor que yo asigno 00:31:10
a una variable 00:31:13
pues lo puedo hacer depender de una condición 00:31:14
Lo puedo hacer dependiendo de las condiciones 00:31:16
Es la única modificación a eso que hemos visto 00:31:18
¿Vale? 00:31:21
Bueno, pues si solo pudiéramos hacer ese tipo de sentencias 00:31:22
No podríamos hacer 00:31:24
Ningún programa 00:31:26
Que haga algo mínimamente más complicado 00:31:27
Y sofisticado 00:31:30
¿Vale? 00:31:32
¿Entonces significa eso que hay que introducir tropecientas mil 00:31:33
Sentencias más? 00:31:36
No, hay que introducir dos más y se acabó 00:31:37
¿Vale? 00:31:40
Y para esas dos más solamente necesitáis 00:31:41
Pues tres o cuatro años más de estudio 00:31:43
Claro 00:31:44
Vale, entonces 00:31:46
Que solo hace falta introducir dos más 00:31:49
¿Quién lo dice? 00:31:52
¿Lo digo yo? Pues no 00:31:54
Yo lo digo ahora 00:31:55
Pero yo emulo a mis mayores 00:31:58
Vale, bueno 00:32:01
Esto es un resumencillo que repito 00:32:06
Esto no son apuntes de estudiar 00:32:07
Es un resumen para situaros 00:32:09
Sobre que estamos viendo en cada momento 00:32:12
Vale, pues esto de que 00:32:14
Hacen falta solo dos más 00:32:18
No lo, ábrete, o ya se ha abierto 00:32:20
Así 00:32:22
No lo digo yo 00:32:22
¿Vale? 00:32:24
Lo dice quién 00:32:27
Este 00:32:28
¿Vale? 00:32:30
Vamos a verlo en Wikipedia 00:32:36
Que es muy lista 00:32:38
Ah, teorema del programa 00:32:39
Claro 00:33:07
no, no es lo mismo 00:33:08
lo que pasa es que yo en los apuntes 00:33:10
lo he reducido 00:33:12
ah, que era otro 00:33:12
bueno, pues el teorema ese 00:33:14
como vosotros sois aficionados a las matemáticas 00:33:17
pues por eso 00:33:19
pues lo que yo he llamado 00:33:20
el teorema de la estructura 00:33:24
pues bueno, Wikipedia lo llama 00:33:26
el teorema del programa estructural 00:33:27
¿de cuándo es este teorema? 00:33:29
que es el cual 00:33:31
nace todo 00:33:32
la programación tal y como la conocemos ahora 00:33:35
Pues de hace un huevo de tiempo 00:33:37
¿Vale? 00:33:40
Dice, lo acreditan a un artículo 00:33:43
Del 66 00:33:46
Fijaos, no había nacido ni yo 00:33:47
¿Y quién es estos tíos que no los conoce nadie? 00:33:50
¿Vale? 00:33:55
Pero bueno, no está muy claro 00:33:57
Porque desde la arquitectura de Von Neumann 00:33:58
Que es así que la contamos 00:34:00
Pues más o menos se ha venido a 00:34:01
Concluir este teorema 00:34:04
¿Y qué dice este teorema? Dice que cualquier algoritmo, cualquier acción, cualquier problema que uno necesite resolver mediante un ordenador como lo conocemos con la arquitectura de Von Neumann, un procesador, le pasas operaciones, le haces sumas y restas y te lo devuelve. 00:34:06
vale, pues cualquier algoritmo que queramos programar 00:34:27
cualquiera, solo necesita 00:34:30
tres tipos de instrucciones 00:34:32
las asignaciones, que ya las hemos visto 00:34:33
bueno, el tema de la estructura dice dos 00:34:36
porque las asignaciones las da por sentado 00:34:38
yo lo incorporo para que nos situemos mejor 00:34:40
¿qué tendremos? 00:34:42
que dar valores a variables, está claro 00:34:44
dar valores a variables, si no, no tenemos datos 00:34:46
y luego, a partir de ahí, una vez que ya tenemos valores 00:34:47
en los variables, contener 00:34:50
decisiones y bucles 00:34:51
todo eso tantas veces 00:34:54
es como haga falta. Cuatro decisiones, tres 00:34:56
bucles. Pues con tener decisiones 00:34:58
y bucles se puede construir 00:35:00
cualquier algoritmo. Se puede 00:35:02
programar cualquiera. No hace falta 00:35:04
absolutamente ninguna sentencia más. 00:35:06
Por eso la programación estructurada tiene 00:35:08
exclusivamente, aparte de asignaciones 00:35:10
de datos a variables, 00:35:12
porque eso es inevitable, aparte de eso 00:35:14
tiene decisiones y bucles. Y no tiene absolutamente 00:35:16
nada más. Nada más. 00:35:18
A partir de ahí, ¿qué es lo que tiene? 00:35:20
¿Cómo coloco el código? Punto pelota. 00:35:22
no tiene nada más que eso, cualquier 00:35:24
lenguaje de programación al que podáis 00:35:26
acudir, siempre y cuando 00:35:28
nos vayáis a redes neuronales, a sistemas 00:35:30
de computación de inteligencia artificial, pero es que estos 00:35:32
son todos modelos, no tienen nada que ver con un ordenador 00:35:34
de esos, vale 00:35:36
estamos hablando de cualquier 00:35:37
programa de ordenadores 00:35:40
de tablets, de móviles, de dispositivos 00:35:42
normales y corrientes 00:35:45
pues cualquiera de esos 00:35:46
solamente tiene 00:35:48
leo datos y van a variables 00:35:50
Decisiones y bucles y ya está, no tiene nada más 00:35:52
Que lo tengamos colocado de una manera o de otra 00:35:54
Lo tenemos colocado de una manera u otra, pero no tiene nada más 00:35:56
¿Vale? Entonces menos mal 00:35:58
Porque así no tenemos que hacer programas muy raros 00:36:01
Porque antiguamente 00:36:03
Se usaba mucho el famoso 00:36:04
Go to 00:36:07
Que bueno, los programas de muchos lenguajes 00:36:07
Los siguen incorporando 00:36:11
Para 00:36:12
Por comodidad 00:36:13
Que es, vete a esta línea, punto y pelota 00:36:15
Y te mandaba esa línea 00:36:18
y lo que había antes, ¿qué? 00:36:19
O sea, eso hacía programas que se llamaban 00:36:21
desestructurados completamente 00:36:23
porque se perdía el flujo 00:36:25
del hilo. Me voy aquí 00:36:27
en virtud de que me voy aquí por una condición 00:36:29
o porque te da la gana, entonces 00:36:31
es una forma de programar cómoda 00:36:33
porque yo hacía un chorizo, luego cambiaba de idea 00:36:35
Ah, no, quiero seguir por aquí, pues go to potatín 00:36:37
Programas desestructurados completamente 00:36:39
Entonces se dijo, vamos a quitar todo lo que no haga falta 00:36:41
Y quitando todo lo que no haga falta 00:36:43
se quitó todo 00:36:46
salvo las decisiones y los bucles 00:36:47
Y ya está, y a partir de ahí vamos a hacer lenguajes de programación 00:36:49
Que solamente usen de sesiones y bucles 00:36:52
Aunque incorporen el GoTo o algo parecido 00:36:54
Que Java también lo incorpora por comodidad 00:36:58
Pero si no lo usamos, mejor, porque no es necesario 00:37:01
Bueno, pues entonces nosotros vamos a empezar ahora con esto 00:37:03
¿Vale? Venga, paramos 00:37:09
Qué pena, ¿verdad? 00:37:11
¿Verdad? 00:37:14
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
12
Fecha:
7 de octubre de 2024 - 18:28
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
37′ 15″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
180.88 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid