Saltar navegación

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

Clase 29-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 29 de septiembre de 2023 por Raquel G.

13 visualizaciones

Más información Transcripción

Descargar la transcripción

El otro día entonces finalizamos la clase, os quedasteis haciendo este primer ejemplito, ¿vale? Este primer ejemplito de programa en Java. 00:00:02
Bueno, pues ahora mismo, ahora mismo, situación en la cual las cosas no tienen por qué salirnos de corrido, ¿no? 00:00:14
Porque estamos todavía, pues aprendiendo a organizar nuestra cabeza y a ordenar nuestro pensamiento, ¿vale? 00:00:24
Si ordenamos nuestro pensamiento, nuestro programa nos quedará ordenado y finito, que así tiene que ser un programa, ¿verdad? Profe, dime. 3.250.920. O sea, hay millones de maneras. No sé, no entiendo la pregunta. 00:00:32
Yo dije, hay tres formas de hacerlo 00:00:54
Yo no dije, hay tres formas de hacerlo 00:01:03
No dije eso, lo que diría 00:01:04
Por ahí que está diciendo, le dije 00:01:06
Hombre, a ver, lo puedes hacer de esta otra manera 00:01:09
Pero como alternativa a la que estaba él usando 00:01:10
Eso mismo lo podía hacer de otra manera 00:01:13
Pero una misma cosa en programación 00:01:14
Se podía hacer de miles de cosas distintas 00:01:17
¿Vale? 00:01:19
No es que esto no es matemático, hay una solución 00:01:20
Aquí, en informática 00:01:23
En el desarrollo, ya lo hemos dicho 00:01:25
otras veces no hay una forma buena de hacer las cosas, una misma aplicación se puede 00:01:27
plantear con mil diseños distintos, mil formas diferentes, lo que pasa es que si seguimos 00:01:32
unas prácticas de programación más o menos estandarizadas, pues nuestros programas serán 00:01:36
más eficientes, más legibles, que es lo que perseguimos cuando programamos. 00:01:42
Bueno, pues entonces, más o menos esquema de pensamiento que uno podría haber utilizado 00:01:46
para plantear esto? A ver, primero uno tiene que tener muy claro, fase de análisis, fase de análisis es, ¿qué tiene que hacer el programa? 00:01:55
¿Cuál tiene que ser su resultado? ¿Qué tiene que hacer? Entonces de este enunciado automáticamente extraemos, a ver, lo que este programa va a hacer 00:02:08
va a ser mostrar un número, pero eso me tiene que quedar claro, el resultado final del programa, lo que tiene que hacer, lo que el usuario va a ver 00:02:16
Y lo que nos interesa es que el programa muestre un número 00:02:25
Eso es lo primero que tenemos que tener claro en la cabeza 00:02:28
Entonces nuestro programa 00:02:30
En algún momento tendrá que terminar 00:02:31
Con algo así 00:02:34
Mostrando ahí un número 00:02:35
Y para mostrar un número 00:02:39
Lo que tenemos que mostrar es una variable que guarde ese número 00:02:40
Hasta ahí está claro 00:02:44
Si queremos mostrar un número 00:02:46
Porque ese es el resultado final del programa 00:02:47
Ahí es hasta donde tenemos que llegar 00:02:49
Tenemos que llegar a que el programa me muestre un número 00:02:51
Porque después de haberle enunciado varias veces, después de leerlo, ya me doy cuenta de que su objetivo final es hacer esto, es mostrar un número. 00:02:53
Vale, a partir de ahí uno ya va empezando a tirar. 00:03:04
Bueno, mostrar un número significa, ¿qué número? 00:03:07
Depende, depende de los datos de entrada, por supuesto. 00:03:11
Entonces, como el número que yo vaya a mostrar depende de los datos de entrada, el objetivo no es, muéstrame el número 7. 00:03:15
Si en la aplicación fuera 00:03:21
Muéstrame el número 7 00:03:23
Pues ala, obviamente estaría muy fácil 00:03:24
Ya está, ya te he mostrado el número 7 00:03:26
Pero es que este programa no me dice 00:03:28
Muéstrame el número 7 00:03:30
Me dice muéstrame un número 00:03:31
Y claro, ese número 00:03:33
Leyendo el resto de enunciado 00:03:35
Vemos que ese número es variable 00:03:36
O sea, dependerá de los datos 00:03:38
A veces será uno, a veces será otro 00:03:39
Dependerá de los datos de entrada 00:03:41
Entonces este System.out.println 00:03:43
Me tendrá que mostrar 00:03:45
El contenido de una variable 00:03:47
me tendrá que mostrar el contenido 00:03:49
de una variable, vale 00:03:51
luego este es el punto final 00:03:53
vale 00:03:54
entonces 00:03:56
cuando penséis un programa 00:03:58
antes de empezar a programar 00:04:01
hay que leerlo entero 00:04:03
y ya 00:04:05
verlo en su conjunto antes de empezar 00:04:06
a escribir, no vale que uno 00:04:09
haga, programa que solicite y lea 00:04:11
dos números y no se que, y ya automáticamente se puede programar 00:04:13
vale, solicito y leo dos números, ahora que tengo 00:04:15
que hacer, y luego haga no sé qué 00:04:17
ah vale, ahora hago no sé qué, no 00:04:19
porque para saber ese no sé qué, tengo que tener entendido 00:04:21
todo lo siguiente, entonces primero 00:04:23
varias, este 00:04:25
enunciado es muy sencillo, claro, pero bueno 00:04:27
hay enunciados, habrá enunciados 00:04:29
lógicamente, más largos 00:04:31
y las aplicaciones ya en general 00:04:33
tienen enunciados muy largos 00:04:35
entonces, primer paso imprescindible 00:04:36
que lo leamos entero una y otra vez 00:04:39
hasta que entendamos el conjunto 00:04:41
de su funcionamiento 00:04:43
y yo no me pongo a escribir ni una sola línea de código 00:04:44
hasta que no he entendido el conjunto del funcionamiento 00:04:47
y que va a ocurrir 00:04:49
que cuando yo escriba esas líneas de código 00:04:51
casi seguro que las escribo del final para atrás 00:04:53
y las voy escribiendo 00:04:55
como veremos cuando veamos estructuras 00:04:57
pues primero hago un esqueleto con cajas negras 00:04:58
y luego voy rellenando las cajas negras 00:05:01
así es como iremos escribiendo el código 00:05:03
porque así es como vamos pensando 00:05:05
¿vale? vamos pensando 00:05:06
de lo general a lo concreto 00:05:09
¿vale? uno piensa 00:05:11
yo me voy a Francia, muy bien 00:05:13
Ese es el pensamiento general, me voy a Francia 00:05:14
Ahora ya empiezo a detallarlo 00:05:16
Vale, compro el billete de avión 00:05:18
Voy al aeropuerto, me monto el avión y aterrizo 00:05:21
Vale, pues ya 00:05:23
Esa caja negra ya la he detallado un poquito más 00:05:24
Ahora tiene tres cajas negras, compro el billete de avión 00:05:26
Me toca detallarla, ah vale 00:05:29
Busco en páginas 00:05:30
De agencias de viajes, etc 00:05:32
Pues ese pensamiento de lo general 00:05:34
A lo concreto 00:05:37
Refinando, es el mismo pensamiento 00:05:38
Que tenemos que llevar cuando programamos 00:05:41
y para llevar ese pensamiento tenemos que tener entendido muy bien el funcionamiento general de la aplicación 00:05:42
antes de empezar a programar nada, no sé que el resultado final de un programa 00:05:47
sea una secuencia de sentencias ordenada, no significa que nuestro pensamiento vaya en secuencia ordenado 00:05:53
no va a ir nunca así, no puede ir así, nuestro pensamiento tiene que ir en iteraciones que van refinando 00:06:01
de forma progresiva 00:06:07
vale, yo me planteo el programa 00:06:09
general, y para eso he leído 00:06:11
muy bien enunciado, vale, tengo que 00:06:13
hacer esto, ahora voy separando en partes 00:06:15
en tareas, esas partes ahora 00:06:17
se quedan todavía sin refinar 00:06:19
ahora ya me voy metiendo en cada una de ellas 00:06:21
las voy refinando, así hasta que construyo 00:06:23
un primer boceto del programa 00:06:25
y cuando tengo ese primer boceto 00:06:26
lo miro a ver más o menos si vale 00:06:28
tiene sentido o no, y empiezo a hacer las pruebas 00:06:31
vale, pero así es como 00:06:34
pensamos, bueno pues entonces 00:06:35
después de analizar 00:06:37
todo esto, hemos llegado a la conclusión 00:06:40
de que el destino final de mi código 00:06:42
es hacer esto, mostrar un número 00:06:43
y mostrar un número que es variable 00:06:46
que depende de los datos de entrada 00:06:47
luego mi sistema de println tendría que estar mostrando 00:06:49
una variable, no hay tutía, porque la variable 00:06:51
es la estructura de programación 00:06:53
que me permite guardar cosas 00:06:55
variables, como su nombre indica 00:06:57
vale, pues entonces yo tendré que tener 00:06:59
de alguna manera una variable 00:07:02
para guardar ese resultado final 00:07:04
una variable para guardarla, ¿no? 00:07:07
entonces, ese es el objetivo final de mi programa 00:07:09
mostrar un resultado 00:07:11
vale, hasta ahí está claro 00:07:12
ahora ya tengo que empezar a meterme en esta caja negra de aquí 00:07:14
que es, vale, ¿y cómo hago yo 00:07:17
para darle valor a n? 00:07:19
¿cómo hago yo para darle valor a n? 00:07:21
vale, porque ese es el problema 00:07:23
ahora, el problema ahora es este 00:07:25
es decir, a ver, si voy a mostrar 00:07:27
el contenido de mi 00:07:29
para empezar a 00:07:31
Bueno, a dar nombres de variables con un poco más de sentido 00:07:32
En lugar del n famoso, vamos a llamarlo resultado 00:07:35
¿Vale? Mucho más bonito 00:07:37
Vamos a llamarlo resultado 00:07:41
Bueno, pues ese es el objetivo, ¿no? 00:07:42
Mostrar el resultado 00:07:47
Entonces, para mostrar el resultado voy a necesitar 00:07:48
Hacer una asignación 00:07:52
Obviamente 00:07:54
Si no hago una asignación 00:07:55
No puedo mostrar 00:07:57
Entonces, este es el meollo del asunto 00:07:59
¿cómo saco yo el valor que tengo que mostrar? 00:08:02
¿qué es lo que me pide el programa? 00:08:06
pues traigo un valor 00:08:08
vale, pues ahora sigo refinando y sigo analizando el enunciado 00:08:08
me dice, anda pues tendrás que pedir dos valores 00:08:12
y asignar a resultado el que sea mayor de los dos 00:08:15
entonces ahora ya el programa empieza a cobrar más sentido 00:08:20
porque ya tenemos una primera estructura 00:08:23
tenemos una primera estructura 00:08:25
sabemos que tenemos que mostrar una variable 00:08:27
Y a esta variable habrá que darle un valor. Y este es lo complicado. ¿Y qué valor le doy? Pues es cuando vienen las siguientes lecturas que nos permiten ir acotando. Las siguientes lecturas nos dicen, oye, lee dos números y dale el mayor de los dos. 00:08:30
Vale, ya lo tengo un poco más claro, voy a leer los dos números, ahora ya sí me pongo a escribir los dos números y ahora ya pienso qué tipo de asignación hago para asignar a este el mayor de los dos, porque eso es lo que tengo que hacer y ya está, y programa finiquitado, ¿vale? 00:08:47
Pero insisto, no se lee y se va haciendo lo que el enunciado te dice 00:09:04
Eso nunca, no tiene ningún sentido 00:09:09
Se lee todo en conjunto, se entiende, se piensa, se analiza 00:09:10
Y luego ya se va programando, no de arriba a abajo 00:09:15
Se va programando de abajo a arriba 00:09:21
De cajas según vaya yo dando las sucesivas iteraciones 00:09:23
Que me van conduciendo al resultado final 00:09:28
Bueno, pues entonces, ahora ya leer los datos 00:09:30
Ya tengo que hacer y sé cómo hacerlo 00:09:35
Porque hemos aprendido ya a leer números enteros del teclado 00:09:38
Bueno, pues como hemos aprendido a leer números enteros del teclado 00:09:43
Eso lo podemos hacer ya sin pensar 00:09:48
Ahora ya es la parte en la cual 00:09:50
Aquí uno no tiene que perder ni medio segundo 00:09:51
Porque ya él memorizó en su cabeza 00:09:54
que leer del teclado es tan fácil 00:09:58
como crear una variable de tipo objeto 00:10:00
y usar las 00:10:02
sentencias que os dije, entonces como ya está en la cabeza 00:10:04
ahí el segundo 00:10:06
que se pierde es cero 00:10:08
no se pierde tiempo 00:10:10
si uno no almacena 00:10:11
las cosas en la cabeza, entonces ni siquiera 00:10:16
sabe de que recursos dispone, no los 00:10:18
tiene a mano para sacarlos de ahí 00:10:20
entonces si no los tiene a mano para sacarlos de ahí 00:10:21
es que construir el programa va a ser una locura 00:10:23
¿vale? porque uno tiene que decidir 00:10:25
qué ladrillos usar, y para decidir 00:10:28
qué ladrillos usar, toda esa caja de ladrillos 00:10:30
tiene que estar aquí, y luego ya nos ponemos 00:10:32
a ordenarla, esa caja de ladrillos no puede 00:10:34
estar en Google, en Internet, ni en nada 00:10:35
bueno, pues como me han dicho, leer por teclado 00:10:37
así yo sé perfectamente cómo es por teclado 00:10:39
pues venga, leer por teclado 00:10:41
entonces, declarábamos 00:10:43
una variable que yo llamé 00:10:46
objeto, aún sin entender lo que significa 00:10:48
la variable objeto, y os dije, os lo tenéis que creer 00:10:49
ahora, no hay más remedio, pues nada 00:10:52
lo creéis, y esto lo hacíamos 00:10:53
de esta manera 00:10:55
lo hacíamos así, eso implicaba que teníamos que poner esta línea aquí y ahora ya leer dos números enteros con esta variable que me permite leerlo, vale, si yo voy a leer dos números enteros, necesito dos espacios en memoria para guardarlos, lógicamente, bueno, pues entonces ya me viene la siguiente vuelta para arriba, 00:10:56
Venga, pues voy a declarar dos variables enteras más 00:11:29
Para guardar esos dos numeritos 00:11:32
Dato uno 00:11:34
Dato dos 00:11:36
Ala 00:11:38
Vale, ahora ya tengo 00:11:39
Estas dos cajitas para los dos números 00:11:42
Que voy a leer, ahora ya los leo 00:11:44
Porque ya sé perfectamente que lo tengo en la memoria 00:11:45
Como sobre un lato, entonces todo eso tiene que estar 00:11:47
Nadie puede hacer una pregunta 00:11:49
Porque ha puesto mal esta sentencia 00:11:51
Y le da error y porque nadie 00:11:53
Debería hacer una pregunta de esas, porque ya 00:11:55
tiene todo el mundo que saber como se lee 00:11:57
del teclado con escáner 00:11:59
bueno 00:12:00
y lo hacíamos así ¿verdad? 00:12:02
poníamos aquí la variable con el nombre 00:12:05
que nos hubiera dado la gana ponerle 00:12:07
y poníamos 00:12:09
esta llamada 00:12:11
y ya sabíamos que esto lo que 00:12:12
hacía era quedarse esperando un 00:12:15
dato y mandarlo a la variable que le 00:12:17
dijéramos, para que el programa no fuera 00:12:19
tan desagradable 00:12:21
para el usuario y diera información 00:12:23
pues solíamos poner un mensajito 00:12:25
donde le decíamos introduzca 00:12:28
el primer número 00:12:30
no pongo tildes a propósito 00:12:35
porque no en la consola 00:12:38
la codificación que tiene me las pone feas 00:12:40
vale 00:12:42
ahora introduzca el segundo número 00:12:44
vale pues ya tenemos esta parte 00:12:46
que es la más fácil 00:13:04
leer por teclado 00:13:05
como ya nos sabemos de memoria 00:13:06
como leer por teclado 00:13:08
esta parte ya la tenemos 00:13:09
y ahora nos queda este agujero negro de aquí 00:13:10
nos queda este agujero negro 00:13:13
que este agujero negro es 00:13:15
a ver 00:13:18
lo que yo tengo que mostrar 00:13:18
porque mi objetivo final en este código 00:13:20
es esto, es mostrar esto 00:13:23
lo que yo tengo que mostrar 00:13:25
tiene que recibir un valor 00:13:27
que depende 00:13:28
el valor que reciba de si este 00:13:31
es mayor que este 00:13:33
o de si este es mayor que este 00:13:34
luego automáticamente como yo ya me lo he estudiado todo 00:13:36
y lo tengo en la cabeza y sé que existe 00:13:39
una asignación condicionada 00:13:41
pues me doy cuenta de que lo que me estoy 00:13:42
diciendo es exactamente 00:13:45
la definición de asignación condicionada 00:13:47
que hemos estudiado y que tenéis ahí 00:13:49
grabada 00:13:51
la definición de asignación condicionada 00:13:51
es una asignación 00:13:55
en la cual tú puedes dar 00:13:57
dos valores 00:13:59
o uno 00:14:00
u otro 00:14:03
y esos dos valores 00:14:06
y tú darás uno u otro en función de una condición que pongas ahí. 00:14:08
Entonces eso ya lo sabemos, de nuevo está en nuestra memoria. 00:14:15
Entonces justo el problema que se nos plantea con esta asignación 00:14:18
automáticamente conectamos y nos damos cuenta de que nos lo resuelve esa asignación. 00:14:21
Si eso no está en la memoria nuestra, sino que está en Google, 00:14:26
pues aquí nos hemos plantado y estamos 3 horas, 4 horas tratando de resolver el ejercicio. 00:14:30
pero si está nuestra cabeza grabado 00:14:34
automáticamente hacemos la conexión y decimos, claro 00:14:37
si yo al resultado 00:14:38
le tengo que asignar dato 1 o dato 2 00:14:40
es decir, uno de los dos 00:14:43
en función de si dato 1 es mayor que dato 2 00:14:44
o no, pues justo 00:14:47
me estoy diciendo la definición de asignación 00:14:49
condicionada, justo me estoy diciendo eso 00:14:51
pues ya está, tiro de ese recurso 00:14:53
y lo pongo 00:14:55
¿vale? bueno, pues lo vamos a cascar tal cual 00:14:56
el recurso era, a esta variable 00:14:59
resultado, o le doy dato 1 00:15:01
o le doy dato 2 00:15:03
y en función 00:15:05
de qué condición 00:15:11
le doy o dato 1 o dato 2 00:15:12
pues en función de si dato 1 00:15:15
es mayor que dato 2 o no 00:15:17
o sea, las condiciones 00:15:19
o se cumplen o no se cumplen 00:15:20
¿vale? 00:15:23
entonces, esa condición 00:15:25
dato 1 ser mayor que dato 2 00:15:26
es una condición sencilla 00:15:28
que sabemos expresar 00:15:30
porque el mayor que, menor que 00:15:32
esos dos solamente 00:15:34
luego hay muchos más operadores relacionales que ya veremos 00:15:36
pero el mayor que y el menor que 00:15:38
los podemos usar desde ya 00:15:40
porque son operadores con los que estamos familiarizados 00:15:42
que hemos usado toda la vida 00:15:44
entonces 00:15:45
si dato 1 00:15:47
es mayor que dato 2 00:15:50
esta es la condición que yo quiero expresar 00:15:52
¿vale? y entonces este operador 00:15:55
el mayor que y el menor que 00:15:56
un operador relacional 00:15:58
lo podemos usar siempre 00:15:59
con variables numéricas, está claro 00:16:02
porque los números tienen un orden natural 00:16:04
y Java si orden natural lo respeta 00:16:05
¿vale? entonces 00:16:08
que nos quede ya desde ya 00:16:09
está 00:16:11
este conocimiento 00:16:13
el conocimiento de que las variables numéricas 00:16:14
sean float 00:16:18
sean enteras, sean decimales 00:16:19
sean enteras, las podemos comparar 00:16:22
con el operador relacional mayor que y menor que 00:16:24
que nos quede desde ya 00:16:25
hay más operadores 00:16:27
relacionales pero 00:16:29
ya cuando nos centremos ya en 00:16:31
ver todos los operadores que tenemos, ya lo veremos 00:16:33
bueno, pues ya está, ya he terminado 00:16:36
ya he terminado el programa 00:16:37
y como veis, no he programado en línea 00:16:39
no, en línea no 00:16:42
he ido saltando de arriba a abajo 00:16:43
¿vale? según me he ido aproximando 00:16:45
a la solución, ¿vale? 00:16:47
luego, primera conclusión, así es como tenéis que programar 00:16:49
entendiendo 00:16:52
todo en 00:16:54
en conjunto el funcionamiento 00:16:55
lo que pide el ejercicio 00:16:58
para lo cual 00:17:00
se lee una, dos, tres veces 00:17:01
las veces que haga falta 00:17:04
y si después de leerlo tres, cuatro, cinco veces 00:17:05
las veces que haga falta 00:17:08
sigue sin estar claro lo que pide 00:17:09
pues puede ocurrir que el enunciado 00:17:12
esté un poco afortunado 00:17:14
esté mal escrito 00:17:16
pues en ese caso habrá que pedirle cuentas 00:17:17
a quien haya escrito ese enunciado 00:17:20
y decirle, haberlo leído siete veces 00:17:22
y no entiendo lo que quieres decir 00:17:24
bueno 00:17:26
pues una vez que ya se ha entendido 00:17:27
lo que se quiere decir, se ha leído 6, 7, 8 veces 00:17:29
ahora ya empieza esta otra parte 00:17:32
que es, a ver, ¿cuál es el objetivo final? 00:17:35
este, ¿cómo lo puedo ir construyendo? 00:17:38
pues voy usando los ladrillos que tengo en mi cabeza 00:17:40
no en otro sitio, que los tengo todos ahí 00:17:43
todos los que hemos visto hasta ahora tienen que estar ahí 00:17:45
hemos usado el ladrillo de leer por teclado 00:17:48
que lo tenemos en la cabeza 00:17:50
hemos usado el ladrillo de la asignación condicional 00:17:51
que lo tenemos en la cabeza 00:17:54
por supuesto el de cómo mostrar por consola 00:17:55
el de cómo declarar variables 00:17:58
si para hacer algo de esto 00:18:00
hemos necesitado mirar en Google 00:18:02
o algo, es que tenemos 00:18:05
que estudiar más historia 00:18:07
más codos, hay que estudiar más 00:18:08
más codos, ¿vale? 00:18:11
habrá situaciones 00:18:14
en las cuales sí, o sea, hay pequeños espacios 00:18:15
de conocimiento que uno sabe, ah, vale 00:18:17
con esto se puede hacer esto 00:18:19
pero los detalles no tiene sentido 00:18:20
memorizarlos, pues entonces ya, yo almaceno 00:18:22
en mi cabeza que tengo esta herramienta para 00:18:25
hacer esto y cuando la necesite 00:18:27
ya si busco los detalles a lo mejor 00:18:29
en internet o en la documentación 00:18:30
pero hasta ahora todo lo que hemos visto aquí 00:18:32
es no 00:18:35
lo podemos tener todo en la cabeza y no pasa nada 00:18:35
bueno pues 00:18:40
entonces esto conduciría al primer 00:18:42
boceto de mi ejercicio, al primer boceto 00:18:44
ahora ya es 00:18:46
cuando yo ya sobre el escrito 00:18:48
pues empiezo a mirarlo, a pensarlo 00:18:50
a ver si, uy se me ha escapado 00:18:53
esta cosita, cuando 00:18:54
lo tenga más o menos claro hacer pruebas 00:18:56
etcétera, ya me pongo, ya está 00:18:58
pero ya tengo un primer boceto del ejercicio 00:19:00
y además sin errores de compilación 00:19:02
y sobre él ya, pues puedo detectar a lo mejor 00:19:04
cosas que no he tenido en cuenta, etcétera 00:19:06
¿vale? 00:19:09
pero bueno, esto que hemos 00:19:11
hecho a todo el mundo le suena con sentido, ¿no? 00:19:12
bueno, se ha quedado claro 00:19:18
claro, claro, claro 00:19:19
como tenéis que pensar 00:19:20
luego ya cada uno obviamente tiene sus propios 00:19:22
mecanismos, sus propias formas de programar 00:19:24
Y luego cada uno obviamente tiene 00:19:27
Más o menos experiencia en programación 00:19:31
O incluso ninguna 00:19:33
¿Vale? 00:19:35
Yo, mi punto de partida 00:19:37
O sea 00:19:39
Mi clase es para los que no tienen 00:19:41
Ni idea de programación 00:19:43
¿Vale? Para los que no tienen ni idea 00:19:45
Porque esa es la responsabilidad nuestra 00:19:47
Los que sepan más 00:19:50
Pues maravilloso 00:19:52
Porque les 00:19:52
lo tendrán, vamos, le será 00:19:53
todo más cómodo 00:19:56
bueno, pues entonces ahora estamos en la fase 00:19:58
de mirar esto un poquito y decir, vale, esto 00:20:00
que he hecho tiene sentido, tiene buena pinta 00:20:02
podríamos empezar a sacarle peros 00:20:03
¿alguien le sacaría 00:20:06
algún pero a este código 00:20:08
de aquí? seguro que sí, ¿verdad? 00:20:10
¿a qué alguien le podría sacar algún pero? 00:20:13
al funcionamiento 00:20:19
¿alguien se pone ahora ya? nosotros le damos 00:20:20
este código, le damos este código al cliente 00:20:22
que nos ha pedido esa aplicación 00:20:24
y el cliente se pone a usarlo 00:20:25
y es probable que el cliente 00:20:27
en algún momento nos dé un toque y nos diga 00:20:29
uuuh, oye, es que no me está 00:20:31
no es exactamente el funcionamiento 00:20:33
completo y correcto, ¿qué pero me podría 00:20:35
sacar el cliente? 00:20:37
efectivamente 00:20:43
efectivamente, el cliente le puede decir 00:20:44
oye, si meto dos números iguales 00:20:46
entonces yo ahora pienso y digo, anda, claro 00:20:48
es que si meto dos números iguales 00:20:50
esta condición es 00:20:53
falsa, obviamente 00:20:55
entonces al ser falsa 00:20:56
asigna el dato 2 00:20:58
entonces si meto dos números iguales 00:20:59
el programa siempre me muestra el segundo 00:21:02
¿verdad? 00:21:04
entonces hombre, ese es un funcionamiento 00:21:06
subóptimo, otra cosa es que yo le diga 00:21:08
al cliente, oye te echo un programa 00:21:10
en el que si los dos son iguales te muestra el segundo 00:21:12
¿eso te vale? 00:21:14
porque vas a introducir dos datos iguales 00:21:16
alguna vez, ¿eso te importa? ¿no te importa? 00:21:18
y si le importa 00:21:21
pues habrá que arreglarlo 00:21:22
¿vale? si le importa habrá que arreglarlo 00:21:24
arreglarlo, entonces hombre 00:21:27
aquí podríamos empezar a refinar 00:21:28
anidando condiciones, etc 00:21:30
ahora mismo es lo que menos me importa 00:21:32
pero podríamos 00:21:34
empezar a hacerlo, pero bueno 00:21:36
está claro, por lo que tiene claro 00:21:40
que este programa, si los dos son iguales 00:21:43
en ese caso de prueba, me daría el segundo 00:21:45
entonces antes de 00:21:47
entregárselo al cliente, uno habría 00:21:49
probado este código 00:21:51
y lo habría probado dando 00:21:52
datos concretos, que eso es lo que se llama 00:21:55
casos de prueba, conjuntos de datos concretos 00:21:57
y viendo lo que da, a ver si tiene sentido o no 00:21:59
esas pruebas no las hemos 00:22:01
hecho nosotros, vamos a hacerlas 00:22:03
vale, vamos a hacer un caso de prueba 00:22:05
en el cual el primero 00:22:08
es mayor que el segundo 00:22:10
vale, este caso de prueba lo ha pasado con éxito 00:22:12
ha funcionado 00:22:15
vamos a hacer otro caso de prueba 00:22:16
en el cual el primero 00:22:19
es menor 00:22:21
que el segundo 00:22:23
que es el opuesto que he metido antes 00:22:25
vale, este caso de prueba lo ha pasado 00:22:27
vale, entonces si uno 00:22:30
es un buen tester y hace 00:22:32
un buen conjunto 00:22:34
de casos de prueba, habría 00:22:36
metido ese otro 00:22:38
habría metido ese otro caso de prueba, habría dicho 00:22:39
vale, y si yo meto dos números iguales 00:22:42
me muestra el segundo 00:22:44
entonces 00:22:47
esto le puede importar al cliente o no 00:22:49
repito, le puede importar, a lo mejor el cliente me dice 00:22:51
Está bien, está bien porque el mayor de los dos es los dos, es lo mismo, vale, está bien, puede decir sí, sí, vale, me vale. 00:22:54
O puede pedirnos, no, si son iguales, pues entonces tienes que mostrarme otra cosa, tienes que mostrarme otra cosa. 00:23:05
Entonces aquí ya sí que tendríamos que empezar a refinar esto. 00:23:14
Y se complicaría, porque si son iguales, entonces yo aquí, mi sentencia final no es un system out que muestra un numerito, sino que mi sentencia final sería, muestra un mensaje, son iguales. 00:23:19
entonces esto ya con las herramientas que tenemos 00:23:33
hasta ahora, no podemos 00:23:36
incluirlo, no podemos incluirlo 00:23:38
tendríamos aquí ya que sí que meter un if 00:23:40
porque esto ya no es una asignación 00:23:42
condicionada, yo no puedo meter al 00:23:44
resultado que es un entero 00:23:46
meterle una cadena 00:23:48
son iguales y que entonces 00:23:50
resultado me muestre o el número 00:23:52
o me muestre la cadena son iguales que contiene 00:23:54
no, esa variable solo puede tener números 00:23:56
entonces 00:23:58
con las herramientas 00:23:59
conocemos hasta ahora, ese refinado 00:24:02
no podríamos hacerle 00:24:04
¿vale? pero 00:24:06
en cuanto ya incorporemos el 00:24:08
if, que me permite hacer un conjunto 00:24:10
de sentencias o hacer otro en función 00:24:12
de la condición, pues ya está 00:24:14
podríamos modificar ese 00:24:16
esa 00:24:18
este pequeño mal funcionamiento 00:24:21
si es que al cliente le parece mal 00:24:25
funcionamiento ¿vale? 00:24:26
¿vale? ¿alguna duda 00:24:29
pregunta o algo similar? 00:24:32
nada de nada 00:24:34
todo está claro 00:24:36
¿habéis estudiado en casa 00:24:40
las tres tardes que teníais? 00:24:41
solo ha contestado uno 00:24:46
¿quién ha contestado? 00:24:47
al que menos creo, fíjate 00:24:48
si has estudiado, ¿no? 00:24:50
vale, y los demás no contestan 00:24:53
pues porque normalmente las preguntas que hacen 00:24:55
los profesores no se contestan 00:24:56
bueno, era una pregunta retórica 00:24:58
asumo que lo hayáis hecho 00:25:01
vale 00:25:02
Antes de que sigáis haciendo algún ejercicio más y todo eso, unos pequeños matices más para poder ir haciendo programas un pelinín más sofisticados. 00:25:04
Bueno, a la hora de hacer asignaciones, esto me va a quedar así un poco feo, vale, estábamos con variables y asignaciones a variables, ¿verdad? 00:25:18
Ese ha sido todo nuestro rollo hasta ahora, variables y asignaciones a variables. 00:25:31
Y para asignar valores a variables, habíamos usado algunos operadores, pero algunos muy básicos. 00:25:35
Los aritméticos, más menos multiplicación y división, siempre los podéis usar con su significado natural que conocéis. 00:25:44
Siempre los podéis usar con variables numéricas, sin ningún problema, ¿verdad? Los aritméticos. 00:25:52
Y luego además, es lo único que hemos incorporado en realidad para construir expresiones que operen con variables. 00:25:57
y luego además este, menor que, mayor que 00:26:02
para comparar 00:26:05
números y 00:26:07
de esa manera obtener condiciones 00:26:09
¿vale? 00:26:11
y las condiciones que peculiaridad tienen 00:26:13
que se pueden asignar a variables 00:26:15
boolean 00:26:17
¿no? entonces en relación a lo que 00:26:18
preguntabas tú, ¿de cuánta 00:26:21
forma se puede hacer este programa? 00:26:22
hombre, como se puede hacer de tropecientas 00:26:25
siempre y cuando haga esto, por ejemplo 00:26:26
por ejemplo 00:26:28
esto es una condición 00:26:29
luego al ser una condición 00:26:32
se puede asignar a una variable boolean 00:26:33
entonces a lo mejor 00:26:36
a mi me resulta más fácil 00:26:38
meter esa condición 00:26:40
en una variable boolean intermedia 00:26:41
por ejemplo la variable boolean 00:26:43
que la llamo así 00:26:48
y a esta variable boolean 00:26:49
le asigno 00:26:52
esta condición 00:26:53
y esta es una condición 00:26:56
perfectamente bien hecha 00:26:58
porque compara con este operador relacional 00:27:00
dos numeritos, es una condición muy bien hecha 00:27:02
su valor será true o false 00:27:04
y ese valor va a parar 00:27:06
cae a una variable booleana 00:27:08
que las variables booleanas solo pueden recibir 00:27:10
verdad o mentira, resultados de evaluar 00:27:12
condiciones, es lo único que pueden recibir 00:27:14
o cascarle a capón true o false 00:27:16
bueno, pues entonces si yo me hago 00:27:19
una variable booleana intermedia, pues hombre 00:27:22
entonces puedo poner 00:27:24
esto aquí 00:27:26
que era lo que estábamos comentando ahí 00:27:27
el martes 00:27:32
entonces lo que es el código 00:27:34
el código luego se puede poner de mil formas 00:27:36
distintas, se puede poner de mil maneras 00:27:38
¿vale? entonces 00:27:40
lo que yo he hecho antes, lo que tenía escrito antes 00:27:42
y esto es lo mismo 00:27:44
en realidad, es lo mismo 00:27:47
lo que pasa es que con esto uso una variable 00:27:48
intermedia 00:27:51
que el único efecto 00:27:52
podría ser en este caso 00:27:54
que a lo mejor el código quede más claro 00:27:56
porque 00:27:58
en este caso esta condición es fácil 00:28:00
sencilla, pero hay veces que la condición 00:28:02
a poner aquí es una condición muy grande 00:28:04
entonces poner ahí una pedazo de condición 00:28:06
pues a lo mejor me hace perder ya un poco 00:28:08
la estética del programa 00:28:09
entonces ponerlo con una 00:28:11
booleana intermedia pues a lo mejor hace que 00:28:14
la estética, la elegibilidad 00:28:16
del código sea un poquito mejor 00:28:18
y como esto podría yo poner 00:28:19
obviamente mil 00:28:22
pequeños cambios en el código 00:28:23
por ejemplo, podría 00:28:26
declarar a la vez que 00:28:28
inicializo, ¿vale? digo 00:28:30
oye, voy a quitar esto de aquí, venga, y lo declaro a la vez, y así no tengo tanto lío de líneas, bueno, pues otro cambio de código que podría hacer, 00:28:31
¿verdad?, recordad que a la vez que damos el primer valor a una variable, a la vez que le damos el primer valor, yo ya la puedo declarar en ese momento, 00:28:40
que es la, bueno, pues otro pequeño cambio que puedo hacer, en lugar de declararla, dejarla asignada, y luego asignarle, puedo declararla y a la vez asignarle su primer valor, 00:28:48
pues si quiero, y así esta línea se hace más cortita 00:28:58
¿vale? entonces este primer valor que yo asigno 00:29:02
me da igual que sea un valor fijo 3, 7 00:29:06
o lo que yo quiera, siempre y cuando sea un valor, y esto es un valor, lo que pasa es que ese valor 00:29:10
no se va a resolver hasta que alguien ponga un número en el teclado 00:29:14
y ese número caiga en dato 1, ¿vale? entonces cambios en el código 00:29:18
pues muchas, muchas combinaciones, bueno este no tiene muchas líneas 00:29:22
un mismo código que hace lo mismo 00:29:26
se puede escribir de muchas maneras 00:29:28
y la idea es que sea 00:29:31
lo más legible posible 00:29:33
para el que no lo ha hecho lo vea 00:29:35
lo entienda, no vea ahí líneas enormes 00:29:36
que no sabe de donde han salido 00:29:39
que le cuesta ligarlas con otra 00:29:40
vale 00:29:42
bueno, pues a ver 00:29:44
estamos con asignaciones de variables 00:29:48
vamos a ponerlo aquí en 00:29:55
esto estaba 00:29:57
en la esta de ejercicio 00:29:59
voy a hacer otra clase que sea 00:30:07
ejemplo con cadenas 00:30:12
para incorporar 00:30:14
ejemplos con 00:30:17
cadenas 00:30:22
ah no, un proyecto no, perdón, una clase 00:30:24
clase ejemplos 00:30:31
con cadenas 00:30:40
vale, pues venga, vamos a ver 00:30:43
bueno, pues variables, tipos de variables 00:30:53
que hemos visto 00:31:09
tipos de variables primitivos, ya de nuevo los tenemos 00:31:10
también todos en la cabeza, números enteros 00:31:13
by, short, int y long, depende de lo grandote 00:31:15
que quiero que sea el número 00:31:17
números decimales, float y double 00:31:18
dependiendo de la precisión 00:31:20
en la cantidad de cifras decimales 00:31:22
booleano, si quiero guardar una condición 00:31:25
o algo que es true o false 00:31:27
y char si quiero guardar un único carácter 00:31:28
con los matices que vimos 00:31:31
en la asignación, que si yo asigno 00:31:33
algo a un char 00:31:35
cuando si doy un número 00:31:36
para java es lo mismo 00:31:39
lo busca en la tabla y ya está 00:31:41
entonces si java ve que ahí necesita 00:31:42
tiene un hueco para un char 00:31:45
y le estamos dando un número, no le molesta 00:31:47
no le molesta porque coge ese número, se va a la tabla 00:31:49
y lo sustituye por el carácter correspondiente 00:31:51
si le damos el carácter directamente entre comillas simple 00:31:53
pues se lo ponemos más fácil, da un poco igual 00:31:55
esos eran los matices que estábamos viendo 00:31:57
vale, bueno pues 00:31:59
obviamente esas variables 00:32:01
se quedan cortas 00:32:04
y por eso aparecen las variables objeto 00:32:05
en las que ya nos detendremos durante mucho tiempo 00:32:07
para aprender a construirlas 00:32:10
pero desde ya, desde ya 00:32:12
vamos a necesitar 00:32:14
un tipo de variable adicional 00:32:15
a estos tipos primitivos que hemos visto 00:32:17
porque desde ya, desde ya 00:32:19
es que lo estamos usando, de hecho lo estamos usando 00:32:21
a veces incluso sin saber como se llama 00:32:24
que son las cadenas 00:32:26
de caracteres enteras, vale, o sea 00:32:28
un char solo me guarda un carácter 00:32:30
yo con un carácter no hago nada, con un carácter 00:32:32
yo no puedo guardar un nombre, no puedo guardar 00:32:34
una descripción, en un carácter no puedo guardar 00:32:36
nada, tendría que tener un montón de char para cada carácter 00:32:38
de ese nombre, es una locura 00:32:40
entonces, desde ya 00:32:42
desde ya, aun sin entender 00:32:44
algunas de las cosas que implica, desde ya 00:32:46
vamos a tener que usar variables 00:32:48
que sirvan para guardarme 00:32:50
cadenas de caracteres 00:32:52
enteras, no solo un carácter 00:32:54
Bueno, pues ese tipo de dato, ¿cómo se llama? 00:32:56
Ese tipo de dato se llama así, como uno podría imaginar, con la S mayúscula, ¿vale? 00:33:01
Con la S mayúscula, no con la S minúscula, con la S mayúscula. 00:33:08
Entonces, si yo declaro un dato de este tipo, porque yo sé que va a contener una cadena de caracteres, 00:33:14
Lo declaró de tipo string 00:33:22
Y ahora cadena sirve para contener 00:33:24
Toda una cadena de caracteres 00:33:27
¿Vale? 00:33:29
Porque su tipo es string 00:33:31
Entonces ya apreciamos 00:33:32
Una primera diferencia 00:33:35
Los tipos primitivos y indavelchar 00:33:36
Todos empezaban con minúscula 00:33:38
Y string 00:33:40
Ya empieza con mayúscula 00:33:42
Eso no es casual 00:33:44
Tiene una razón de ser 00:33:46
Y es que string no es lo que hemos llamado tipo primitivo 00:33:47
Es también como escáner 00:33:50
que Scanner si recordáis también empezaba con mayúscula y no es casual 00:33:52
es un tipo objeto también 00:33:55
entonces que sea un tipo objeto 00:33:58
tiene un montón de implicaciones 00:34:00
que de nuevo ahora mismo no podemos entender 00:34:02
porque no sabemos exactamente que son los objetos 00:34:05
no podemos entenderlo 00:34:07
tiene un montón de implicaciones 00:34:08
esas implicaciones ya las veremos 00:34:10
pero aun sin conocer todas esas implicaciones 00:34:12
podemos usar este tipo de datos 00:34:14
podemos usarlo 00:34:17
podemos hacer un primer uso sencillo 00:34:18
Porque, hombre, nombres y cadenas y textos necesitamos desde ya para mostrar contenidos, para mostrar cosas. 00:34:21
Vale, bueno, pues entonces, a las variables string, ¿qué tipo de valor les asignamos? 00:34:30
Hombre, pues ya lo hemos dicho. 00:34:35
Las variables string están pensadas para recibir cadenas de caracteres, no un solo carácter. 00:34:37
Y las cadenas de caracteres para Java las espera como el texto que sea entre comillas dobles. 00:34:44
a diferencia de un único char que es entre comillas simples 00:34:51
vale 00:34:54
pues esta es una asignación 00:35:02
perfectamente 00:35:04
válida de una cadena de caracteres 00:35:06
porque está entre 00:35:08
comillas dobles 00:35:10
obviamente esto nunca 00:35:11
lo pondría entre comillas simples 00:35:14
porque Java me diría 00:35:15
no, las comillas simples son para 00:35:18
un único char, cuando tú lo asignas a un char 00:35:20
esto como es una cadena 00:35:22
lo pondría entre comillas dobles 00:35:24
vale, entonces bueno 00:35:25
podemos trabajar con este tipo de dato 00:35:30
casi 00:35:32
como si fuera un tipo de dato primitivo 00:35:33
normal, que no lo es 00:35:36
y eso tiene muchas implicaciones 00:35:38
en su uso 00:35:40
pero no las podemos entender ahora, pero para un uso 00:35:40
básico podemos usarlo como si fuera 00:35:44
un tipo de dato primitivo 00:35:46
entonces, que yo quiero mostrar una variable 00:35:47
stream por teclado 00:35:50
por consola 00:35:52
pues como muestro 00:35:54
cualquier otra 00:35:56
la paso al system.out.print.dln 00:35:56
Y ya está, y mostrará el contenido de la variable, y en este caso, pues ha mostrado el contenido de la variable cadena, ¿vale? El contenido de la variable cadena, ¿vale? 00:35:59
esto que nos abre 00:36:15
bueno nos abre 00:36:19
ahora nos abre la pregunta 00:36:21
de igual que yo puedo 00:36:23
operar 00:36:26
con variables primitivas 00:36:28
que hemos visto que podemos operar 00:36:29
con variables numéricas para sumarlas 00:36:31
restarlas 00:36:34
igual que puedo 00:36:35
operar con variables 00:36:37
para hacer expresiones 00:36:39
y esas expresiones asignarlas 00:36:41
puedo operar con cadenas también 00:36:43
para asignar a una variable string 00:36:45
asignar el resultado de una expresión 00:36:49
que involucre cadenas 00:36:51
en realidad también podemos operar con cadenas 00:36:52
pero operar con cadenas 00:36:55
¿qué es la única operación interesante con cadenas? 00:36:56
concatenarlas 00:36:59
vale, concatenarlas 00:37:00
bueno, pues podemos concatenar cadenas 00:37:02
construir una expresión 00:37:04
que sea el resultado de concatenar cadenas 00:37:06
es decir, si aquí declaramos 2 00:37:09
por ejemplo 00:37:13
vale, entonces a la cadena 2 00:37:14
le ponemos un espacio 00:37:29
y yo también 00:37:34
vale 00:37:37
bueno, pues podríamos 00:37:38
por ejemplo hacer algo así 00:37:42
y es 00:37:47
vamos a hacer a la cadena 1 00:37:49
una asignación 00:37:51
a la cadena 1 vamos a hacerle 00:37:52
otra asignación más 00:37:54
otra asignación más 00:37:56
Y esta asignación que sea el resultado de concatenar otras dos cadenas, porque es una operación que podemos hacer perfectamente entre cadenas, concatenar dos cadenas. ¿Y cómo se concatenan? Con el operador más, con el operador más. 00:37:58
entonces yo puedo hacer esto 00:38:14
cadena1 00:38:16
más 00:38:19
cadena2 00:38:20
y esta es una expresión 00:38:22
perfectamente válida en Java 00:38:25
perfectamente válida 00:38:27
esto es una suma 00:38:29
es un operador suma 00:38:31
pero el operador suma cuando trabaja 00:38:32
con operadores que son 00:38:35
cadenas 00:38:37
entonces no funciona 00:38:38
como la suma algebraica que conocemos 00:38:41
sino que funciona como la concatenación 00:38:43
entonces este operador es un operador 00:38:45
que en función de las variables 00:38:48
que le pongamos a los lados 00:38:50
o bien es la suma algebraica 00:38:51
o bien es la concatenación 00:38:54
y eso para Java 00:38:56
es perfectamente distinguible 00:38:58
dice, ah, me has puesto 00:39:00
el operador suma, ¿qué tengo a los lados? 00:39:02
tengo cadenas, ah, vale, pues lo que quieres es que concatene 00:39:04
pues ya está, entonces evalúa 00:39:06
esta expresión y el resultado 00:39:08
de esa expresión será la concatenación 00:39:10
y el resultado va a cadena 1, que es perfectamente compatible 00:39:11
porque como la concatenación de dos cadenas es también una cadena 00:39:16
pues puede ir a cadena 1, que es una cadena 00:39:19
recordad que las asignaciones, el resultado de la expresión 00:39:22
tiene que ser del mismo tipo de la variable a la que asigno 00:39:26
salvo con el matiz de la promoción automática que ya hemos visto 00:39:31
que también tenéis memorizado en la cabeza 00:39:35
vale, entonces si mostramos el resultado de cadena 1 otra vez 00:39:37
cadena 1 aquí 00:39:41
ha quedado pisoteada 00:39:43
el valor que tenía de antes, que era este 00:39:45
ha quedado pisoteado 00:39:47
por el nuevo 00:39:49
¿vale? o sea, para construir el nuevo 00:39:50
hemos usado 00:39:56
el valor que tenía, claro, porque el orden 00:39:58
que sigue la máquina virtual cuando ve una asignación 00:40:00
el orden es 00:40:02
primero, me voy a la derecha 00:40:04
y evalúo la expresión 00:40:06
la evalúo con el valor que tuviera 00:40:08
cadena 1 en ese momento 00:40:10
con el valor que tuviera, ¿cuál tiene? 00:40:11
Este, vale, pues la evalúo. 00:40:14
¿Y cuál tiene cadena 2? Este, vale. 00:40:16
Una vez que ya he construido el valor final, voy y se lo asigno a la variable que hay aquí, 00:40:18
pisando el que tuviera de antes, pisando. 00:40:25
Entonces cadena 1 aquí ha perdido su valor original y se ha quedado con el nuevo. 00:40:27
De hecho, si lo ejecutamos, pues este es el primer valor que tenía cadena 1 00:40:33
y este es el segundo valor con el que se ha quedado después de hacer esta asignación. 00:40:38
vale 00:40:44
entonces podemos hacer 00:40:45
podemos usar cadenas de texto 00:40:50
en nuestros programas 00:40:52
a nivel muy básico 00:40:54
sabiendo estas cosas 00:40:58
y a veces lo necesitamos desde ya 00:40:59
luego string, repito, tiene muchas 00:41:01
implicaciones por debajo 00:41:04
porque es un objeto, entonces tiene muchas cosas 00:41:05
pero esas ya las iremos incorporando 00:41:08
vale 00:41:09
vale, entonces 00:41:11
como somos curiosos 00:41:14
y nos van surgiendo preguntas, ahora diríamos. 00:41:16
Vale, entonces, operador más, ya empezamos a liarla. 00:41:19
Si involucra números, es la suma algebraica, no hay duda, 00:41:23
y el resultado va a un número. 00:41:26
Si involucra cadenas, no hay duda, es la concatenación, 00:41:28
y el resultado es una cadena. 00:41:32
¿Y si involucra un número y una cadena? 00:41:34
¿Se puede? ¿Lo deja Java? 00:41:38
Pues vamos a verlo. 00:41:41
Vamos a declarar ahora un numerito, 00:41:42
y vamos a leerlo por teclado 00:41:44
el numerito 00:41:48
voy a copiar y pegar el escáner este 00:41:50
lo voy a poner aquí arriba 00:41:53
para que no moleste 00:41:59
algo tan feo ahí en medio 00:42:01
y ahora 00:42:02
y este numerito N 00:42:05
vale, ahora paramos 00:42:12
cuando terminemos esto 00:42:17
vale, este numerito N 00:42:18
lo declaro y a la vez que lo declaro 00:42:21
le doy ya su primer valor, lo inicializo 00:42:24
con un valor leído por teclado 00:42:26
O sea, el programa cuando llegue aquí se va a quedar esperando 00:42:27
De nuevo, como es un poco feo 00:42:30
Vamos a ponerle un mensajito antes 00:42:32
Para que el usuario sepa 00:42:34
Que tiene que introducir un número 00:42:35
¿Vale? Por ejemplo así 00:42:38
Vale 00:42:46
Se muestra el mensaje 00:42:48
El programa se queda ahí esperando 00:42:49
Cuando ya hemos metido el numerito, sale el numerito 00:42:50
Y va la variable n 00:42:53
Y ahora ya 00:42:54
Nos podríamos plantear hacer esto 00:42:57
Cadena 1 igual 00:42:58
Vamos a conquetar 00:43:01
El valor leído es 00:43:03
Esto es una cadena 00:43:09
Y la voy a concatenar con un valor entero 00:43:12
Vale, pues Java me ha dejado 00:43:15
Dejarme sin errores de compilación me ha dejado 00:43:19
O sea, me ha dejado usar el operador más 00:43:22
Mezclando tipos 00:43:25
Mezclando la cadena string y mezclando el número 00:43:27
no poniendo solamente dos cadenas como es el caso 00:43:31
o no poniendo solo dos números como hemos hecho hasta ahora 00:43:37
me deja mezclarlos 00:43:40
vale, bueno, pues en el caso de que mezclemos y el operador tenga 00:43:42
a un lado una cadena y a otro lado un número 00:43:47
¿qué es lo que hace Java? dice, ah, pues gana la cadena 00:43:50
siempre gana la cadena, entonces lo que hace Java es 00:43:54
convierte este numerito 00:43:58
a la cadena 00:44:01
que lo representa 00:44:04
si hemos metido 37 00:44:05
lo convierte a la cadena 37 00:44:07
que representa 00:44:09
y ahora ya que tiene la cadena 00:44:10
la concatena con esta 00:44:13
¿vale? luego cuando el operador 00:44:14
más mezcla números y cadenas 00:44:17
la que tiene mayor 00:44:20
peso es la cadena, da igual que esté antes 00:44:21
o que esté después, da igual 00:44:23
aunque yo lo concatene en otro orden 00:44:25
la que tiene mayor peso es la cadena 00:44:27
y lo que hace es, saca el valor de la variable 00:44:29
512 00:44:32
y dice, pues voy a transformarlo 00:44:33
no me queda más remedio, a una cadena 00:44:35
que represente 512 00:44:37
que no es lo mismo 00:44:39
el número binario 512 00:44:41
que está dentro de n 00:44:44
el número binario 512 00:44:45
que la sucesión de caracteres asti 5, 1 y 2 00:44:46
son dos cosas muy distintas 00:44:50
pues esa conversión la hace 00:44:51
la máquina virtual, ahí, porque necesita 00:44:53
una cadena, la necesita, porque la cadena ha ganado 00:44:55
la necesita, pues se va 00:44:57
al número n, saca lo que hay dentro 00:44:59
y obtiene 00:45:01
los caracteres asti que representan 00:45:03
el numerito binario que hay ahí 00:45:06
512, lo que sea 00:45:07
y ahora ya lo concatena, ahora ya que ya lo tiene 00:45:08
convertido en cadena, concatena 00:45:11
y ya 00:45:14
esa concatenación lo asigna 00:45:15
a una variable de tipo compatible 00:45:17
tiene que ser cadena sí o sí 00:45:19
vale, tiene que ser cadena 00:45:21
sí o sí, y ahora ya 00:45:23
si mostramos cadena 1 00:45:25
pues esto nos dirá 00:45:30
el valor leído es 00:45:31
el que hayamos leído 00:45:33
vamos a comprobarlo 00:45:37
vale, me muestra el primero 00:45:40
que teníamos arriba, me muestra el segundo 00:45:45
me muestra el mensaje, efectivamente 00:45:47
se ha quedado esperando, porque aquí no aparece 00:45:49
el terminate de este ni nada 00:45:51
está ahí esperando, el programa no ha acabado, está esperando 00:45:53
vale, le meto un numerito 00:45:55
y ya está 00:45:57
y de eso me informa, el valor leído es 00:45:58
con catena 00:46:01
con la transformación 00:46:02
a cadena de caracteres 00:46:04
de ese número 00:46:07
y luego me muestra esto 00:46:08
luego este primer uso básico de cadenas 00:46:12
ya nos permite hacer programas 00:46:16
un poquito más 00:46:17
un poquito más prácticos 00:46:18
¿vale? 00:46:24
entonces cuidado, no os liéis 00:46:29
que la máquina virtual haya necesitado 00:46:30
convertir esto a cadena 00:46:33
no significa para nada que la variable n 00:46:34
el valor que tenga haya cambiado 00:46:37
no, porque cuando se coge 00:46:38
un valor para construir una expresión 00:46:41
la máquina virtual 00:46:43
va a la variable y saca su valor 00:46:44
saca una copia y la variable se queda ahí 00:46:46
con lo que tenía tan feliz, no la toca 00:46:48
saca una copia de su valor 00:46:50
y hace todo lo que tenga que hacer 00:46:52
para construir el resultado 00:46:54
¿vale? 00:46:55
pero lo que tenía esa variable ahí sigue, no se toca 00:46:58
ese valor no va a cambiar 00:47:01
hasta que no le hagamos una asignación 00:47:02
a ella, hasta que no hagamos un n igual 00:47:04
¿vale? 00:47:06
eso tiene que estar claro, cuando las variables 00:47:08
aparecen en la parte derecha en las expresiones 00:47:10
se coge una copia 00:47:13
de su valor para operar 00:47:14
pero la variable sigue teniendo lo que tuviera y eso no ha 00:47:16
cambiado, el n sigue teniendo 00:47:18
el valor numérico 875 00:47:20
pero la máquina virtual 00:47:21
ha cogido una copia del 875 00:47:23
lo ha transformado en la cadena 00:47:26
de caracteres así 8, 7 y 5 00:47:29
lo ha concatenado 00:47:31
y ha hecho todo eso para obtener un valor 00:47:32
y asignárselo a cadena 1 00:47:34
¿vale? 00:47:36
vale, pues 00:47:39
sí 00:47:40
aquí 00:47:42
sí, a ver, lo puedes poner 00:47:45
como es una declaración de variable más 00:47:49
lo puedes poner en cualquier sitio 00:47:51
antes de usarlo, por supuesto, antes de usarlo 00:47:52
podría haber puesto aquí arriba 00:47:55
pero bueno, es más fácil para no meter 00:47:56
cosas raras en medio, si uno sabe 00:47:59
que va a usar el escáner, lo pones en la primera línea 00:48:01
y ya está 00:48:03
vale, vamos a parar aquí 00:48:04
un momentito entonces 00:48:06
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
13
Fecha:
29 de septiembre de 2023 - 13:39
Visibilidad:
Público
Centro:
IES ROSA CHACEL
Duración:
48′ 09″
Relación de aspecto:
1.78:1
Resolución:
1280x720 píxeles
Tamaño:
919.05 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid