Saltar navegación

20240919 ProgrEstruct-Variables_6 - 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 19 de septiembre de 2024 por Raquel G.

10 visualizaciones

Más información Transcripción

Descargar la transcripción

que como se pone 00:00:00
pues depende de tu teclado 00:00:02
yo lo tengo en 00:00:03
yo lo tengo en los numeritos arriba 00:00:05
con lo cual tengo que poner el shift 00:00:08
vale 00:00:09
bueno pues repito 00:00:14
entonces estos son los operadores aritméticos 00:00:16
que podemos usar con enteros 00:00:18
conociendo 00:00:19
su significado 00:00:21
entonces este es el operador 00:00:23
resto de dividir 00:00:26
este entre este 00:00:28
¿Vale? Pues los cuatro, los cinco operadores aritméticos básicos 00:00:29
Y operadores aritméticos no hay más 00:00:34
Cualquier otra cosa que uno quiera hacer de aritmética 00:00:36
Porcentajes, factoriales, lo que sea 00:00:39
Tendrá que hacer una función para ello 00:00:41
Si es que no hay una ya hecha que la podamos llamar 00:00:43
No, no hay un operador exponente 00:00:45
Esta no existe, ¿vale? 00:00:49
Que uno quiere hacer esto elevado a esto 00:00:51
O programa una función que lo haga 00:00:54
Que eso ya es otra cosa, funciones 00:00:56
o usa una función que ya esté hecha de alguien que lo haga. 00:00:58
Pero hay que programarlo. 00:01:01
Los únicos operadores que no hay que programar 00:01:03
porque ya te hacen la operación, aritméticos, son estos 5. 00:01:05
Y los podemos usar para expresiones. 00:01:09
Y esas expresiones con paréntesis y teniendo en cuenta 00:01:11
si necesitamos la prioridad de los operadores que hemos dicho. 00:01:14
Bueno, entonces, vamos, aunque sea feo, 00:01:18
para que no estemos, en los programas de prueba que hacemos 00:01:23
se quedan un rollo así, si estamos todo el rato 00:01:26
metiéndolo a capón, vamos a poner 00:01:28
la sentencia para leer 00:01:30
del teclado y así podemos probar 00:01:32
nuestros programas metiendo cada vez 00:01:34
un dato distinto y viendo lo que hace 00:01:36
y no tenemos que estar todo el rato cambiando 00:01:38
el código y metiendo aquí el numerito 00:01:40
¿no? si yo puedo cambiar esta sentencia 00:01:41
para que esta sentencia sea lee del 00:01:44
teclado, cuando ejecute mi 00:01:46
programa, el mismo programa sin 00:01:48
cambiar el código le podré cambiar cada vez 00:01:50
el dato y es mucho más 00:01:52
operativo y próximo al 00:01:54
uso habitual del código ¿no? 00:01:56
Vale, pues entonces esta clase que se ha quedado aquí chuchurría, ejemplo variables, vamos a hacer otra para en la que vamos a meter cómo es la sentencia de entrada-salida por teclado. 00:01:58
Entonces, si queréis cambiar el nombre de una clase, por ejemplo, yo voy a cambiar esta, como esta ya la voy a dejar así sin tocar y sin meterle más basura, porque la voy a dejar entonces solo ejemplo variables enteras, me interesa cambiarle el nombre, que sea de variables enteras. 00:02:13
entonces, o bien, cambiéis aquí el fichero 00:02:25
y luego os venís aquí 00:02:28
a cambiar el nombre 00:02:30
entonces tenéis que cambiar los dos sitios 00:02:31
si es que es public, si no, no 00:02:33
o podéis 00:02:35
aquí si queréis 00:02:37
cuando queréis cambiar el nombre 00:02:41
de una de estas 00:02:43
porque, pues, botón 00:02:44
derecho, lo digo 00:02:47
porque buscaréis el rename directamente y no existe 00:02:49
botón derecho, refactor 00:02:51
rename 00:02:53
vale, el refactor viene 00:02:55
que está refactorizando, que ahora tampoco entendemos 00:02:58
pero ya entenderemos, si queréis cambiar el nombre 00:03:00
entonces yo ahora voy a cambiar el nombre porque esta clase 00:03:02
la voy a dejar ahí solamente 00:03:04
como clase de ejemplo que hemos usado para variables enteras 00:03:05
pues le voy a cambiar el nombre 00:03:08
y la voy a llamar ejemplo variables 00:03:10
enteras 00:03:12
le cambio el nombre 00:03:13
finish 00:03:16
y ya está, me dice 00:03:17
esto implica bla bla bla, así finish 00:03:20
ala, me ha cambiado 00:03:22
el nombre del fichero y me ha cambiado este 00:03:24
también, bueno pues venga 00:03:26
ya esta clase la dejamos ahí abandonada 00:03:30
como clase que hemos usado 00:03:32
para poner, para ver 00:03:33
como funcionan los tipos de dato entero 00:03:36
byte, short, int y long 00:03:38
byte y short, no hemos declarado 00:03:39
variables byte y short pero se declararían igual 00:03:42
vale, yo puedo declarar una variable 00:03:44
byte, b 00:03:46
y ya está, vale, lo que pasa es que 00:03:49
cuidado con lo que pongo en b 00:03:51
cuidado con lo que pongo en b porque ya sabemos 00:03:53
lo que me va a caber en b, vale 00:03:56
le puedo poner un 1 00:03:57
pero cuidado 00:04:00
como me pase 00:04:03
de lo que me cabe en byte, ya me dice 00:04:05
eso no te cabe en un byte 00:04:06
efectivamente, entonces 00:04:08
cuidadito con 00:04:11
esto, me cabe en un byte 00:04:13
pero como me pase al 1000 00:04:15
ya no 00:04:17
bueno, pero funciona exactamente 00:04:18
igual, todo 00:04:21
lo que hemos dicho entre int y lo, pues igual 00:04:23
con las demás 00:04:25
Vale, pues venga 00:04:25
Vamos a hacer una clase para ver 00:04:30
Lo de la sentencia de leer por teclado 00:04:32
Y así podemos ya hacer programas de ejemplos 00:04:34
Que lean por teclado 00:04:36
Para probar nuestras cosas 00:04:37
Pues venga, me hago yo aquí una nueva 00:04:39
Otra más dentro del paquete 00:04:41
Dentro del paquete 00:04:43
New, class 00:04:46
Lectura 00:04:48
Teclado, por ejemplo 00:04:53
Venga, lectura teclado 00:04:55
Y le voy a poner el 00:04:56
main, le marco la esta 00:04:58
del main para que me lo escriba solo 00:05:01
porque yo me lo sé de memoria 00:05:03
si vosotros no lo sabéis de memoria 00:05:05
pues que nos lo marque y os obligáis a ponerlo 00:05:06
y así no se os olvide, vale 00:05:09
pues vamos a suponer que yo tengo un programa que 00:05:17
vamos a hacer 00:05:19
vamos a hacer un programita 00:05:21
que solicita 00:05:23
un número 00:05:27
entero por 00:05:29
teclado 00:05:37
y muestra 00:05:38
el doble 00:05:42
del valor 00:05:44
esto ya es un programa 00:05:46
bueno, hacer un programa para esto 00:05:50
porque tienes una calculadora 00:05:54
multiplicas por dos o incluso 00:05:56
si uno se sabe la tabla de multiplicar 00:05:58
no sería un problema para el cual 00:06:00
necesita hacer un programa si uno se sabe la tabla 00:06:02
de multiplicar 00:06:04
pero habrá veces 00:06:05
que nuestro problema 00:06:08
no lo podamos hacer de cabeza 00:06:10
entonces en esas situaciones te viene genial hacer un programita 00:06:12
bueno, pues esto ya es un programa 00:06:14
aunque no nos haga falta 00:06:16
porque no sabemos la tabla del 2 00:06:18
pues vamos a hacer un programa 00:06:19
que te resuelve un problema 00:06:22
esto ya sí, repito, es un programa 00:06:23
que sirve para resolver un problema 00:06:25
que se nos ha presentado 00:06:27
porque no sabemos la tabla del 2 00:06:28
vale, pues venga 00:06:30
entonces, ahora ya 00:06:33
vamos a empezar a 00:06:35
hacer el proceso 00:06:37
de principio a fin 00:06:39
de hacer un código 00:06:40
pero concretado a un caso muy sencillo 00:06:42
Bueno, pues paso uno 00:06:46
¿Qué es lo que uno hace? 00:06:48
Se lee el enunciado 00:06:51
Y se asegura de que entiende 00:06:52
Exactamente lo que hay que hacer 00:06:54
Esa parte 00:06:57
Parece obvia 00:06:59
Pero es 00:07:00
La parte en la cual 00:07:02
Se cometen la mayor parte de los errores 00:07:04
Yo no he entendido exactamente lo que tengo que hacer 00:07:06
No lo he entendido, he entendido otra cosa 00:07:08
Y dedico un montón de tiempo 00:07:10
A hacer un programa que no hace lo que 00:07:12
tiene que hacer, funciona estupendamente 00:07:14
uy si, funciona muy bien, pero es que no hace 00:07:16
lo que te he pedido, conclusión 00:07:18
pues te han echado del trabajo, vale 00:07:20
entonces 00:07:22
porque esa parte la hacen los que más 00:07:23
cobran de la empresa, quienes son los que más 00:07:26
ganan en la empresa, en el equipo de 00:07:28
desarrollo de un proyecto 00:07:30
los que no 00:07:31
programan 00:07:34
los que, los analistas 00:07:35
y esos 00:07:39
que hacen, esos son 00:07:41
los que tienen que, primero 00:07:42
juntarse con el cliente 00:07:44
y entender 00:07:46
qué necesita el cliente 00:07:47
parece tontería, pero no es fácil 00:07:50
porque aquí entender 00:07:52
que el cliente necesita 00:07:53
que cuando meta un número 00:07:55
le aparezca multiplicado por dos 00:07:57
eso es fácil de entender que necesita eso 00:07:59
pero una aplicación grande 00:08:02
no está entendiendo lo que necesita 00:08:03
y normalmente se le explicará mal 00:08:05
entonces, entender lo que me están pidiendo hacer 00:08:06
no es fácil 00:08:10
en nuestro caso, ¿a qué se traduce? 00:08:11
que cuando yo os planteo un ejercicio 00:08:13
o cuando os planteo un examen, tenéis que leer 00:08:15
bien enunciado y entender lo que tenéis 00:08:17
que hacer. ¿Vale? No es evidente. 00:08:19
Entonces, saber leer es 00:08:24
fundamental y es por lo que más se cobra en la 00:08:25
empresa. Entender qué tengo que 00:08:27
hacer. Vale, en este caso 00:08:29
esa parte ya la hemos hecho. Ya hemos entendido 00:08:31
que yo voy a recibir un número 00:08:33
y lo que quiere el usuario 00:08:35
es que se le devuelva 00:08:37
multiplicado por dos. Vale. 00:08:39
después de mil reuniones con el cliente 00:08:41
hemos entendido que eso es lo que quiere 00:08:43
siguiente parte 00:08:45
ahora ya empezamos a diseñar 00:08:47
el código 00:08:50
todavía no estamos programando 00:08:50
ni necesitamos 00:08:53
saber programar 00:08:56
y quien hace eso pues también es el que más 00:08:57
va a ganar el que diseña el código 00:09:01
y vale 00:09:03
diseñar el código que implica a nosotros 00:09:04
ahora mismo que estamos en un caso sencillo 00:09:07
pues decidir que elementos vamos a necesitar 00:09:08
con que lenguaje lo vamos a hacer 00:09:11
tener una especie de primer mapa 00:09:13
de cómo va a ser nuestro código en general 00:09:16
y luego ya llega la parte sencilla 00:09:18
que es la que hace el programador 00:09:20
que ya programa que es el que menos cobra 00:09:21
ahora ya empezamos a diseñar 00:09:23
el programa 00:09:27
va a pedir un número 00:09:28
por teclado 00:09:30
pues va a necesitar una variable 00:09:32
primera parte 00:09:34
va a necesitar una variable para guardar el número 00:09:36
muy bien, ya he hecho un paso importante 00:09:37
identificar que hay una variable 00:09:40
vale, y en este caso es que 00:09:41
el diseño poco más tiene 00:09:45
¿qué tengo que hacer con esa variable? 00:09:47
multiplicarla por 2 00:09:50
multiplicar por 2 sé hacerlo 00:09:51
sé que hay un operador multiplicar 00:09:53
lo tengo ya bastante acotado el programa 00:09:54
ahora 00:09:57
eso va a ser una expresión, ¿qué hago con esa expresión? 00:09:58
tendremos que guardarla en otra variable 00:10:02
vale, entonces ya empiezo a pensar 00:10:03
vale, pues necesito dos variables 00:10:05
una 00:10:07
la cajita en la que llega el valor de entrada 00:10:08
y otra cajita 00:10:12
en la que se guarda 00:10:14
el resultado de la expresión que yo voy a necesitar 00:10:15
hacer. Todo esto, 00:10:18
como veis, es un diseño que tiene que ver con el lenguaje 00:10:20
de programación. Vale, voy a tener una cajita 00:10:21
con el valor. ¿Qué tendría que hacer después? 00:10:23
Mostrarla por consola. Ah, vale, pues muy bien. 00:10:25
Sabré hacerlo. Vale. 00:10:28
Pues en este caso, el diseño 00:10:30
se traduce en eso. Pero ya hemos 00:10:31
llegado a dos conclusiones muy 00:10:33
importantes. La primera, 00:10:35
que necesitaría una variable 00:10:37
para guardar el dato de entrada 00:10:39
entonces esa parte 00:10:40
es lo que se llama el diseño de los datos 00:10:43
porque más importante 00:10:46
que lo que hace un programa 00:10:48
es con qué lo hace 00:10:50
con qué trabaja 00:10:51
los programas con qué trabajan, con datos 00:10:53
en nuestro caso este programa 00:10:55
trabaja con un número 00:10:57
pero una aplicación real trabaja con miles 00:10:58
de datos de diferentes tipos 00:11:01
entonces como yo esos miles de datos 00:11:03
de diferentes tipos no haga un buen diseño 00:11:05
de dónde se van a guardar, en qué tipos de cajitas, 00:11:07
como no haga un buen diseño, 00:11:11
el programa luego se va a volver loco 00:11:12
para actuar con ellos 00:11:15
y cogerlos y llevarlos y moverlos. 00:11:17
Se va a volver loco. 00:11:18
Entonces, la parte del diseño de los datos 00:11:20
es más importante en realidad 00:11:22
que la del diseño del algoritmo, 00:11:24
de qué va a hacer. 00:11:26
Es casi más importante. 00:11:27
Entonces, en nuestro caso, 00:11:30
el diseño de los datos ha traducido a decir 00:11:31
una variable entera para guardar el número. 00:11:33
bueno, y otra 00:11:36
como voy a hacer una expresión 00:11:37
y esa expresión hay por algún lado 00:11:40
venga, pues otra, se ha traducido en eso porque es muy sencillo 00:11:41
pues venga, como parece que ya lo tenemos 00:11:44
bastante diseñado y en la cabeza 00:11:46
tenemos un primer prototipo 00:11:48
y normalmente nos habremos puesto 00:11:50
con un papel y un lápiz 00:11:52
porque siempre se programa 00:11:54
con un papel y un lápiz 00:11:56
para hacerte tus esquemitas y tus cosas 00:11:58
ya tenemos el esquemita, hemos puesto la cajita 00:12:00
con la NA, vale, una expresión, esto va aquí 00:12:02
Y como ya eso lo tenemos más o menos ya en la cabeza, ya empezamos a programar. 00:12:04
¿Qué es lo primero a lo que yo había llegado? 00:12:09
A que necesito una cajita para el dato de entrada. 00:12:11
Una cajita es una variable. 00:12:15
¿De qué tipo? 00:12:16
Me han dicho un número entero. 00:12:17
Bueno, por defecto normalmente uno para los enteros siempre pone int. 00:12:19
¿Por qué hombre? 00:12:22
A menos que el usuario le diga, cuidado que es una aplicación para números enormísimos. 00:12:24
Pero en general siempre ponemos int. 00:12:29
Venga, pues ya está. 00:12:32
Y, ¿cómo le llamamos? Un nombre, lo más explicativo del, pues venga, yo que en este caso, pues número entrada o dato entrada o yo que sé, como os dé la gana llamarlo. En este caso es que tampoco tiene, cuando uno trabaja con clientes, pues lo llamará clientes, cuando trabaja con hombres lo llamará nombre, cuando trabaja con ellas lo llamará edad, en este caso, venga, dato entrada, vale. 00:12:33
Vale, pues ahora cuál es el problema 00:12:57
Que antes de empezar a hacer esta operación 00:13:00
Que tenemos que hacer 00:13:03
Dato entrada por 2 00:13:04
Porque hasta aquí hemos llegado 00:13:07
Esta operación habrá que hacerla 00:13:09
Pero claro, esta expresión me dará un resultado 00:13:10
Que lo tengo que asignar a algún sitio 00:13:13
¿Vale? 00:13:15
Entonces a algún lado tendré que llevar eso 00:13:18
Entonces uno puede decir 00:13:20
Venga, pues venga 00:13:22
Lo voy a llevar a otra variable entera 00:13:23
hala, ya está 00:13:25
vale 00:13:28
lo llevo a otra variable entera 00:13:30
entonces esta expresión, dato entrada por 2 00:13:32
la llevo a otra variable entera 00:13:35
que declaro 00:13:37
ya a la vez que le doy un valor 00:13:38
así me ahorro líneas 00:13:40
podríamos declarar arriba, claro, el resultado 00:13:41
y abajo darle el valor, resultado igual a dato por 2 00:13:44
aprovecharía en la misma, nos da 00:13:48
lo mismo, vale 00:13:50
vale, pero efectivamente 00:13:51
que nos falta aquí entre medias 00:13:54
nos falta aquí entre medias 00:13:56
a dato 00:13:59
entrada 00:14:01
darle el valor 00:14:03
esto es lo que nos falta 00:14:05
darle el valor 00:14:07
a dato entrada, esto nos falta 00:14:08
mientras dato entrada no tenga el valor 00:14:10
yo no puedo hacer esta expresión 00:14:12
y no puedo utilizar esta expresión 00:14:15
para dársela a mi variable 00:14:17
donde va el numerito resultado 00:14:19
y no puedo mostrarla 00:14:21
por pantalla 00:14:23
vale 00:14:24
resultado 00:14:39
vale, entonces tengo ya 00:14:41
hecho gran parte del programa 00:14:44
vale, que me falta 00:14:46
este huequito de en medio 00:14:48
este huequito es el que tengo sin resolver 00:14:49
pero tengo hecho 00:14:51
que necesito una variable entera 00:14:53
tengo hecha la expresión 00:14:55
que va a obtener 00:14:59
mi resultado final 00:15:00
y el valor de esa expresión 00:15:01
tengo decidido que va a ir a otra variable 00:15:04
obviamente, pues yo no lo pierdo 00:15:05
tendré que asignar a algún lado 00:15:07
pues tengo decidido que le voy a dar a esta variable 00:15:08
que también tengo que declarar, claro 00:15:11
pues venga, la declaro 00:15:13
y tengo decidido que ahora voy a mostrar un mensajito 00:15:14
el resultado es 00:15:17
y luego voy a mostrar el resultado 00:15:18
porque ya sabemos que con el System.out podemos mostrar 00:15:20
tanto cadenas como contenidos de variables 00:15:23
vale, pero esto lo tengo vacío 00:15:25
ahora tengo que completar eso 00:15:27
pero ya he hecho un esqueleto 00:15:29
entonces de nuevo 00:15:32
otra idea 00:15:33
con la que 00:15:34
si os tiene que quedar dentro 00:15:36
uno no programa así 00:15:38
tirando líneas una tras otra 00:15:41
no se programa así 00:15:42
uno va programando 00:15:44
como en 00:15:46
como si dijéramos 00:15:48
en refinamientos sucesivos 00:15:54
a ver 00:15:57
uno hace un primer 00:15:58
una primera estructura 00:16:00
una primera plantilla de la aplicación 00:16:03
donde algunas cosas ya las tiene resueltas como nosotros aquí tenemos resuelto mostrar el mensaje 00:16:05
tenemos resuelto esto pero eso sí sin resolver entonces tenemos un primer prototipo una primera 00:16:11
plantilla con cosas resueltas pero claro aquí tenemos un todavía un agujero negro que tenemos 00:16:17
que rellenar aquí otro agujero negro que tenemos que rellenar pero ya tengo una primera versión 00:16:25
versión completa 00:16:30
como aquí, tengo una primera versión completa 00:16:31
pero tiene este agujero negro 00:16:34
¿vale? tiene este agujero negro 00:16:36
o puede tener dos 00:16:38
a lo mejor aquí me falta otra cosa que no sé 00:16:40
y tiene otro agujero negro, entonces 00:16:42
vamos programando así, como si dijéramos 00:16:43
de fuera hacia adentro 00:16:46
no en secuencia una línea tras otra 00:16:47
si no se puede programar 00:16:50
yo primero 00:16:52
tengo la visión global de lo que tiene que hacer 00:16:53
y algunas cosas 00:16:56
ya tendré resueltas y ahora me voy metiendo 00:16:58
en cajitas más pequeñas, vale 00:17:00
yo sé que aquí tendré que leer del teclado 00:17:01
no sé hacerlo todavía 00:17:04
no pasa nada, ahí está mi agujerito negro 00:17:05
ahí tendré que leer del teclado, vale 00:17:08
cuando ya tenga leído, seguiré por aquí 00:17:09
esto ya si lo tengo, pues esto lo pongo 00:17:11
y así voy rellenando las cajas 00:17:13
que se queden vacías 00:17:15
los agujeros negros que se queden vacíos 00:17:17
vale, porque es que 00:17:19
lo que hacéis 00:17:22
muchas veces, y otra vez realizo 00:17:24
por enésima vez 00:17:25
un enunciado 00:17:26
bueno, con suerte lo leéis y lo entendéis 00:17:28
vale, asumimos que la parte de leerla y entenderla 00:17:31
con suerte la habéis hecho 00:17:33
y ahora, abrís el Eclipse y os ponéis 00:17:34
a teclear código 00:17:37
¿eso dónde se ha visto? 00:17:38
no se trabaja así, a ver, en un programa 00:17:41
muy sencillo, sí, porque uno 00:17:43
ya lo lee y ya sabe que tiene que programar 00:17:45
pero no se trabaja así 00:17:47
uno, lo ha entendido 00:17:49
ahora, se hace su esquema 00:17:51
de, ah, este programa tiene que hacer esto 00:17:53
esto, esto, esto 00:17:55
Pues venga, hago una primera composición, una primera composición de mi programa, donde algunas cosas, esta todavía no la sé, la pongo en comentarios, es aquí tendré que hacer esto, pero cuando ya lo tenga hecho, ya tendré que hacer esto de aquí, una primera composición del lugar, y luego ya se van resolviendo partes, ¿vale? 00:17:57
por eso un equipo de desarrolladores 00:18:16
puede trabajar juntos 00:18:19
en paralelo y no en secuencia 00:18:20
porque 00:18:22
uno está haciendo esta parte 00:18:24
y otro está haciendo esta parte 00:18:26
y son partes separadas 00:18:27
esta es la parte de leer del teclado 00:18:29
yo no sé hacerla en mi programa general 00:18:31
no sé hacerla, se la encargo a otro 00:18:34
ese la hace y cuando la haga yo la meto aquí 00:18:36
y mientras en paralelo 00:18:38
otro está haciendo la parte 00:18:40
de lo que sea, de mostrar por teclado 00:18:42
que no sé hacerla 00:18:44
por pantalla, que no sé hacerla 00:18:46
pero no pasa nada, se la encargo a alguien 00:18:48
cuando ese alguien la tenga, la meto aquí 00:18:50
y eso no me para 00:18:52
mi programa, yo puedo seguir escribiendo cosas 00:18:54
asumiendo que esta ya está hecha 00:18:56
y que esta ya está hecha, ahora mismo están en vacío 00:18:58
cuando ya las sepa resolver 00:19:00
las voy componiendo 00:19:03
y voy haciendo mi puzzle 00:19:04
pues es como tienes que programar 00:19:05
y eso implica que antes de hacer uno un código 00:19:08
pues se hace su esquemita en papel 00:19:10
su no sé qué, tengo que apoyarme 00:19:12
sobre esto y sobre esto y va haciendo su puzzle. 00:19:14
Este puzzle de aquí es fácil 00:19:17
porque este puzzle de aquí 00:19:19
la única pieza que se ha quedado 00:19:20
por resolver es esta. 00:19:23
¿Y cómo leo por teclado? 00:19:25
Bueno, pues es lo que vamos a incorporar 00:19:27
ahora. Dime. 00:19:29
Tengo una pregunta, pero no tenía. 00:19:30
¿Podría hacer que 00:19:33
pruebe contraseñas por ti? 00:19:36
¿Que pruebe qué? ¿Contraseñas por? 00:19:38
¿Que pruebe 00:19:41
contraseñas por? 00:19:42
Por ti. 00:19:44
Hombre, claro 00:19:45
Tú puedes hacer todo lo que quieras 00:19:48
Hombre, tú puedes programar cualquier cosa 00:19:50
Esa en concreto 00:19:58
Pero claro, tendrás que tener 00:19:59
Pero bueno, esa aplicación 00:20:01
Lo que necesita es 00:20:06
Una especificación mejor hecha 00:20:07
Comprobar cotizas, ¿qué significa? 00:20:10
Si son iguales que alguna 00:20:12
De un listado que tengo de mil 00:20:14
o si cumplen un patrón 00:20:15
tendrás que especificar exactamente 00:20:17
qué significa comprobar contraseña 00:20:19
lo has dejado abierto 00:20:21
comprobar contraseña puede ser 00:20:22
ver si es una de las 15.000 que tengo en un fichero 00:20:24
o ver si cumple un patrón 00:20:27
comprobar significa muchas cosas 00:20:29
entonces si uno sabe 00:20:32
para él qué significa comprobar contraseña 00:20:33
te haces ya el programa que lo hace 00:20:36
pero tienes que saber primero qué quieres resolver 00:20:37
vale, liga exactamente con lo que os decía 00:20:39
que cuando uno le pone un enunciado 00:20:42
tiene que entender qué quieres hacer. 00:20:44
Tú me dices, ¿se puede hacer un programa de comprueba 00:20:45
y contraseñas? No me has dicho nada 00:20:48
porque comprobar contraseñas, ¿qué significa? 00:20:50
Significa mil cosas. 00:20:52
Entonces, siguiente nivel de 00:20:54
especificación. 00:20:56
¿Se puede hacer un programa que dada 00:20:57
una cadena de texto verifique 00:20:59
si es igual a alguna 00:21:01
de un conjunto de mil millones de cadenas 00:21:03
que tengo en un fichero? 00:21:06
Eso ya si está bien especificado. 00:21:07
Pues sí, se puede. ¿Se puede hacer un programa 00:21:09
que dada una cadena de texto compruebe 00:21:12
si tiene al menos un carácter 00:21:14
alfabético, otro numérico y mayúscula? 00:21:16
Sí, se puede, pero son problemas distintos. 00:21:18
¿Entiendes? Vale, bueno, pues en este 00:21:20
caso 00:21:23
nuestra composición 00:21:24
del puzzle le ha faltado solo una pieza 00:21:27
y es cómo asigno yo 00:21:29
a mi variable dato entrada 00:21:31
cómo le asigno un valor que 00:21:33
no es directamente una 00:21:35
expresión que yo pongo a 00:21:37
capón, sino algo leído por teclado. 00:21:39
Bueno, pues, aunque es un rollete de poner, 00:21:41
como tenemos que leer por teclado desde ya, 00:21:44
porque si no esto es un rollo, vamos a ver cómo hacer eso. 00:21:46
Bueno, pues, para hacer eso hay varias maneras. 00:21:50
Vamos ahora mismo a hacerla más sencilla. 00:21:53
Para hacer eso tenemos que crear una variable nueva y esa 00:21:56
variable va a ser la variable capaz de hacer la lectura. 00:22:04
Vale, pues, entonces, vamos a tener que declarar otra 00:22:09
variable nueva que sea capaz de hacer la lectura. 00:22:10
Esa variable le damos el nombre que nos dé la gana, 00:22:13
por ejemplo, lector, yo qué sé. 00:22:16
Le creamos una variable nueva que sea capaz de leer. 00:22:19
Esa variable, todas las variables que se declaran en Java, 00:22:22
ya sabéis que tienen que tener un tipo concreto. 00:22:25
Pues esa variable lector, que es capaz de leer del teclado, 00:22:28
¿de qué tipo tiene que ser? 00:22:32
Tiene que ser de un tipo que os digo yo, que es este tipo. 00:22:33
Tiene que ser de ese tipo. 00:22:37
Y me diréis, este tipo, así, tal cual, tiene que ser ese. 00:22:39
Y me diréis, este tipo no es ninguno de los tipos que me has dicho que hay en Java y que solo hay esos, claro, pero como os habéis estudiado al dedillo y lo tenéis en la memoria, todo lo que vimos el otro día, los tipos que yo di el otro día eran tipos como, ¿alguien me sabe la palabra? 00:22:43
Eso, primitivos 00:22:59
Muy bien, los tipos que yo di 00:23:07
Dije, ojo, estos son 00:23:09
Tipos primitivos 00:23:11
Hay datos 00:23:13
Que no se adaptan a un tipo primitivo 00:23:15
Pusimos el ejemplo de 00:23:17
Un cliente que tiene dentro su nombre, su edad 00:23:19
Un cliente de qué tipo es 00:23:22
Tiene muchas cosas dentro 00:23:23
Entonces, los tipos primitivos 00:23:25
Se extienden 00:23:27
a tipos que dijimos 00:23:29
tipos objeto 00:23:31
que es como un tipo 00:23:32
un dato que tiene dentro 00:23:35
muchos de los primitivos 00:23:37
dos enteros, un char, lo que sea 00:23:39
muchos de los primitivos, vale, dijimos eso 00:23:41
solo para que nos fuera sonando simplemente 00:23:43
que no solo hay tipos primitivos 00:23:45
sino que hay tipos objeto que ya veremos 00:23:47
más adelante, que son tipos 00:23:49
complejos que tienen 00:23:51
varias partes dentro 00:23:53
vale, pues escáner 00:23:54
es un tipo objeto 00:23:56
claro, entonces, ahora mismo 00:23:58
lo único que tenéis que hacer ahora mismo 00:24:00
es creeros que Scanner es un tipo 00:24:02
de los objetos, porque es complejo 00:24:05
no es primitivo 00:24:06
que se llama así, ahora vemos lo de la importación 00:24:07
y yo tengo que declararlo 00:24:11
para poder usarlo 00:24:13
aquí 00:24:15
vale, ahora completamos esta línea que se queda mal 00:24:15
entonces una vez que yo tengo declarado esto 00:24:18
que ya lo tengo declarado 00:24:20
ya eso, es una especie 00:24:22
los objetos son como señores o señoras 00:24:24
que han cobrado vida en mi programa 00:24:27
y que son capaces de hacer cosas. 00:24:28
Las variables primitivas, 00:24:32
como mi numerito int n, int long, 00:24:34
no son señoras y señores 00:24:36
que son capaces de hacer cosas, no. 00:24:38
Son cajas con cosas dentro. 00:24:40
Serían como fotos, ¿vale? 00:24:42
La foto de un señor 00:24:44
solamente tiene el aspecto del señor. 00:24:45
Una variable entera 00:24:48
tiene el numerito 5, no tiene más. 00:24:49
Pues la foto del señor 00:24:52
tiene el aspecto del señor. 00:24:54
pero un señor real 00:24:54
no solo tiene su aspecto 00:24:56
sino que además puede caminar, correr 00:24:58
moverse, hacer muchas cosas 00:25:00
pues esa es la diferencia 00:25:02
entre una variable primitiva y un objeto 00:25:04
las variables primitivas que son todas esas que estamos viendo 00:25:06
las enteras 00:25:08
las decimales, las char y boolean 00:25:10
que todavía no hemos visto 00:25:13
pero las que hemos mencionado 00:25:14
son valores, es un valor 00:25:15
eso lo valen para eso, para tener un valor 00:25:18
valor que yo luego uso en expresiones 00:25:20
pero las variables objeto 00:25:22
tienen valor, valor complejo 00:25:24
pero lo tienen 00:25:26
y además pueden hacer cosas 00:25:27
pueden hacer cosas 00:25:30
bueno, pues la variable 00:25:32
lector está de aquí 00:25:34
como es una variable objeto 00:25:35
aparte de tener un valor dentro 00:25:38
puede hacer 00:25:39
¿y qué puede hacer? 00:25:42
puede 00:25:44
quedarse a la espera del teclado 00:25:45
cuando tú te crees una cosa, cogerla 00:25:47
y devolvértela para la asignación 00:25:49
todo eso puede hacer 00:25:52
esa variable por ser escáner 00:25:53
luego las variables objeto pueden hacer 00:25:55
vale, pues mi variable lector entonces es estupenda 00:25:57
porque puede hacer 00:26:00
hacer, empezar a hacer 00:26:03
como se hace 00:26:06
poniendo un punto, vale 00:26:06
estoy explicando un poco lo que significa 00:26:12
para que no os parezca que os digo las cosas 00:26:14
y tú las tenéis que creer, para que le veáis un sentido 00:26:16
pero ahora mismo 00:26:18
si estoy contando esto solamente 00:26:20
es para que usemos esta sentencia sin más 00:26:22
para leer del teclado 00:26:24
pero hombre, quiero que entendáis un poquito 00:26:25
por dónde van los tiros, aunque todavía 00:26:27
no estemos viendo esto, ni orientación a objetos 00:26:29
ni nada, pero más o menos 00:26:31
podéis entender por encima de qué va el rollo 00:26:33
lector es una variable más 00:26:36
es una variable más 00:26:38
lo que pasa es que es una variable de tipo objeto 00:26:38
en concreto, de tipo 00:26:41
escáner, entonces es una variable de tipo 00:26:43
objeto, tiene la suerte 00:26:45
de que puede hacer cosas 00:26:47
¿y cómo hacemos que una variable 00:26:49
de tipo objeto lance 00:26:51
se lance a hacer algo? 00:26:53
¿Cómo se lanza una variable de tipo objeto a hacer algo? 00:26:55
Poniéndole un punto detrás. 00:26:58
Yo una variable entera n, 00:27:00
a una variable entera n, 00:27:02
a ver qué, 00:27:04
ah, bueno, que esté sobrada. 00:27:06
Imaginaos que yo tengo aquí una variable entera n. 00:27:08
Esta variable solo me vale 00:27:12
o bien para recibir valor en una, 00:27:14
uy, 00:27:17
o bien para recibir valor en una asignación, 00:27:18
como ya sabemos, 00:27:21
o bien para ser usada 00:27:23
para que otra variable reciba 00:27:24
su valor. 00:27:27
Es para lo único que para lo que nos vale. 00:27:28
Solo nos vale para eso una variable 00:27:33
primitiva. Me da igual que sea int, que sea 00:27:34
eso, solo nos vale para eso. O para darle 00:27:36
valores, o para ser usada 00:27:38
en una expresión, para 00:27:40
dar valor a otra. Por eso 00:27:42
es estática, es una imagen, no es una foto. 00:27:44
Solo me vale para que yo la vea 00:27:47
o para que yo la use 00:27:49
para hacer una fotocopia para otra, para lo que sea. 00:27:50
Pero nunca jamás 00:27:53
Una variable primitiva puede lanzarse a hacer algo 00:27:54
Nunca podríamos hacer 00:27:57
N, punto 00:27:59
Y haz algo 00:28:00
Tú N, haz algo 00:28:02
Porque punto significa haz algo 00:28:04
No puede, porque es una variable primitiva 00:28:05
Pero 00:28:08
Lector sí que puede 00:28:09
Hacer cosas, porque es variable objeto 00:28:12
Bueno, pues en particular, ¿qué puede hacer? 00:28:14
Las cosas que puede hacer reciben un nombre 00:28:16
Entonces lector puede hacer muchas 00:28:18
Pero en concreto puede hacer una 00:28:20
Que significa 00:28:22
vete al teclado, coge lo que alguien haya metido 00:28:23
y dámelo 00:28:27
y ya cuando ya la máquina virtual lo ha recibido 00:28:29
lo asignará aquí, es una asignación más 00:28:33
lo que pasa es que lo que asigna 00:28:36
es de lo que ha recogido el teclado 00:28:38
bueno, pues esa acción se llama next in 00:28:40
ya está, se llama así, se llama next in 00:28:43
entonces, el punto next in implica 00:28:46
oye objeto lector, desencadena la acción 00:28:49
de irte al teclado, coger lo que alguien haya metido 00:28:53
y dármelo, y entregármelo. 00:28:55
Significa eso, ¿vale? 00:28:58
Bueno, pues así leeremos del teclado números enteros. 00:29:01
Que sepáis que significa que la idea de fondo es esa. 00:29:04
Pero todo esto es, porque el texto es un objeto, 00:29:08
es un método para ti y para la TAM, 00:29:10
que todo eso todavía no lo veremos en programación 00:29:12
de entrada de objetos. 00:29:14
Ahora mismo, con saber leer del teclado 00:29:16
y que entendáis un poquito lo que hay de fondo, 00:29:18
es suficiente. 00:29:20
vale, aún así 00:29:21
este 00:29:24
el compilador me está diciendo 00:29:25
error rojo patatín 00:29:28
¿por qué? porque yo aquí he declarado la variable 00:29:30
sin más para que se vea claro 00:29:32
que es una variable más del tipo 00:29:34
lector, pero hay que asignarle 00:29:36
un valor, porque yo ahí la he declarado 00:29:38
pero cuando uno declara una variable 00:29:40
no tiene nada dentro todavía 00:29:42
está indefinido 00:29:44
entonces es como cuando hago int n 00:29:45
la cajita está 00:29:48
pero lo que tiene n dentro está indefinido 00:29:49
hasta que yo no hago n igual a algo 00:29:52
no recibe algo 00:29:54
pues con el lector está igual 00:29:55
yo he dicho, he creado un lector 00:29:57
pero no tiene a la persona dentro 00:29:59
no tiene nada dentro creado 00:30:04
he creado como 00:30:06
la casa 00:30:07
para meter al tío, al lector dentro 00:30:09
la casa, la cajita, en el caso 00:30:11
una variable, pero el tío no lo he creado 00:30:13
como en la cajita n 00:30:16
el 7 no lo he metido todavía 00:30:18
pues aquí el tío no lo he creado 00:30:19
vale, pues venga, vamos a crearlo 00:30:21
vamos a crearlo 00:30:23
para su espacio lector 00:30:25
para su variable, bueno pues se crea 00:30:27
sí o sí de esta manera 00:30:29
que también os lo tenéis que creer 00:30:30
sin entender porque no conocemos 00:30:33
ni constructores ni nada 00:30:35
así se crea 00:30:36
así se crea 00:30:39
vale, pues ya tengo 00:30:44
una variable de tipo objeto 00:30:53
declarada, que al ser objeto es capaz de hacer 00:30:55
muchas cosas, además le he dado 00:30:57
un valor, porque hombre 00:30:59
he creado una casa para un tío 00:31:01
pero el tío no está adentro, pues poco va a poder 00:31:03
leer, vale 00:31:05
y ahora ya este tío que he creado 00:31:07
lector, es capaz 00:31:09
de hacer cosas, entre ellas 00:31:11
esta, que es 00:31:13
leer del teclado, venga 00:31:15
pues a ver 00:31:17
el entorno de desarrollo os habrá puesto 00:31:18
el solito, porque es muy 00:31:21
listo y muy tonto, os habrá puesto 00:31:23
esta línea 00:31:25
vale, si no os la pone 00:31:26
solo, es que 00:31:31
el tema es que cuando usamos 00:31:33
tipos de datos, objeto 00:31:35
la gran mayoría de ellos 00:31:37
están en otro paquete y hay que decirle 00:31:40
en qué paquete está 00:31:41
de nuevo, ahora mismo 00:31:42
siempre tiene que ser 00:31:44
después del package 00:31:54
El package, la primera línea siempre obligatorio 00:31:54
Luego los import y luego ya el public class 00:31:58
El orden hay que respetarlo 00:32:00
Vale, entonces 00:32:02
Esta línea ahora mismo tampoco entendemos lo que significa 00:32:03
Que se quede, que hay que ponerla 00:32:06
Es como una especie de aviso, oye que voy a usar scanner 00:32:09
Ya está, es una especie de aviso 00:32:12
De que vamos a usarlo 00:32:13
No entendemos lo que significa pero no pasa nada 00:32:14
La aclaramos tal cual 00:32:17
Bueno, pues ya sabemos leer del teclado 00:32:18
Vale, entonces ahora 00:32:21
Vamos a ejecutar este programa 00:32:22
Vamos a ejecutarlo 00:32:26
Este, vale, pues lo ejecutamos 00:32:30
¿Veis? Aquí es un ejemplo en el que 00:32:33
Si yo ejecuto este programa dándole al botón verde 00:32:37
Así sin más, ¿cuál me va a ejecutar? 00:32:39
Ejemplo variables enteras 00:32:41
Y no es ese el que yo quiero ejecutar 00:32:42
Quiero ejecutar este otro 00:32:45
Entonces aquí darle al botón verde sin más, pues no 00:32:46
Entonces le voy aquí, botón derecho 00:32:48
Runas 00:32:50
Java 00:32:53
vale 00:32:53
vale, entonces ¿qué ha pasado? 00:32:55
está el programa parado 00:33:04
¿veis? hay un cursor que pita 00:33:06
claro, con razón está parado 00:33:08
¿el programa qué ha hecho? 00:33:09
ha hecho su primera línea 00:33:11
que es declarar la cajita 00:33:13
esa parte ya la ha hecho, ha declarado la cajita 00:33:15
y ahora le hemos dicho 00:33:17
tú, lector 00:33:20
vete y coge del teclado lo que te meta 00:33:20
pues él es 00:33:24
muy obediente 00:33:25
y se ha ido a coger del teclado 00:33:27
lo que le metan, pero no le están metiendo nada 00:33:29
pues se está esperando 00:33:31
y se va a quedar esperando hasta el infinito 00:33:32
es decir, este programa está en la mitad 00:33:35
no ha terminado 00:33:37
si hubiera terminado, pondría aquí terminate 00:33:38
que es lo que pone cuando hemos ejecutado otros 00:33:41
¿verdad? pero no ha terminado 00:33:43
está parado a la mitad 00:33:45
cruzado de brazos 00:33:46
de hecho este botón 00:33:48
que me permite a mí parar a lo bestia el proceso 00:33:50
del sistema operativo, pararlo 00:33:53
está en rojo, significa si yo quiero parar el proceso 00:33:54
pues lo podría parar 00:33:57
¿vale? pero lo que 00:33:59
está ahora es esperando, ¿se ha quedado clavado 00:34:01
dónde? en esta línea 00:34:03
se ha quedado clavado, y ahí se va a quedar 00:34:05
clavado hasta el infinito, ¿hasta cuándo? 00:34:07
hasta que yo no meta un número 00:34:10
y cuando yo lo meta 00:34:11
el lector que está ahí esperando 00:34:13
cogerá el número y lo entregará 00:34:15
en la sentencia 00:34:18
de asignación en la que está colocado 00:34:19
pues venga, vamos a 00:34:22
meterle el numerito 00:34:23
enter, hasta que no damos el enter 00:34:27
no se entera 00:34:29
enter, y ahora ya me dice 00:34:29
el resultado, esto es muy interesante 00:34:32
una vez que yo le he dado al enter, él ya 00:34:34
ha cogido 00:34:36
el numerito, lo ha entregado 00:34:38
y ya ha continuado operando 00:34:41
ha continuado operando, que ha hecho esto 00:34:42
o sea, esto 00:34:44
sobra, vale 00:34:45
y ya está 00:34:50
¿qué pasa? que este programa 00:34:51
nos ha quedado 00:34:54
muy poco amigable, que se llama, ¿por qué? 00:34:55
Porque tú lanzas un programa y se queda esperando y no te dice nada y el usuario dice que tengo que meter aquí. Hombre, lo normal es que hagamos programas que sean un poquito más amables con el que los va a usar. ¿Qué sería lo ideal? Haber puesto antes del next in un mensajito introduzca por favor número entero. Eso habría sido lo ideal porque si no nos hemos quedado ahí con cara de tontos. 00:34:58
ahora ya este programa 00:35:22
está un poco mejor 00:35:29
declara la variable 00:35:32
muestra un mensaje 00:35:33
y ahora se queda esperando 00:35:35
pero ahora ya nos ha hecho un mensaje antes 00:35:37
entonces ahora ya 00:35:40
ahora ya 00:35:42
jolín, tiene otra pinta 00:35:44
está esperando 00:35:46
porque está en next in 00:35:48
está esperando porque está en next in 00:35:49
pero como antes me ha mostrado un mensaje 00:35:51
como antes me lo ha mostrado 00:35:53
que es una sentencia que no tiene nada que ver con la otra, son independientes 00:35:54
como antes me lo ha mostrado, al menos el usuario 00:35:56
sabe lo que tiene que hacer 00:35:58
pues ya está, ¿vale? 00:35:59
¿cómo? 00:36:07
vale, a ver 00:36:10
lo he puesto 00:36:12
a ver, lo he puesto separado 00:36:13
porque como yo hasta ahora lo que había dicho es 00:36:16
que el system out le das 00:36:18
o comillas dobles o una variable y te lo muestra 00:36:19
¿vale? pero 00:36:22
podemos en un mismo system out 00:36:23
mostrar varias cosas a la vez 00:36:26
si queremos. Si queremos varias 00:36:28
cosas, las vamos 00:36:29
concatenando con el operador más. 00:36:31
Por ejemplo, yo podría poner 00:36:34
quiero las comillas dobles 00:36:36
y el contenido de la variable. 00:36:38
Pues entonces pongo esto 00:36:40
y ahora pongo 00:36:41
más y la variable 00:36:43
y me va a concatenar, concatenación 00:36:46
en el sentido de cadenas, me va a 00:36:49
concatenar esto 00:36:51
con esto, ¿vale? 00:36:53
Entonces, ahora yo hago esto y, ¿vale? Pero ojo, porque no quería decir esto ahora, porque ya no tenemos tiempo, ojo, porque si yo pongo aquí, por ejemplo, imaginaos un system out que ponga variable n1 más variable n2, sin más. 00:36:57
Imaginaos, si ya me voy con esto, imaginaos que tenemos esto de aquí, n1 igual a 8 y n2 igual a 12, y yo pongo ahora n1 más n2, porque quiero mostrar las dos, según lo que yo he dicho hasta ahora, vosotros esperaríais que pusiera 8 y 12, ¿sí o no? 00:37:17
y no lo pone, ¿por qué? 00:37:49
porque este operador 00:37:52
cuando tiene variable entera a un lado 00:37:53
y variable entera al otro 00:37:55
ya no interpreta que esté concatenando 00:37:57
él dice, ah, yo soy la suma 00:38:00
ahora, entonces ¿qué hace? 00:38:02
te suma y te muestra la suma 00:38:03
para que este operador, la máquina 00:38:06
virtual, interprete que está 00:38:07
concatenando cadenas 00:38:09
uno de los dos al menos 00:38:11
tiene que ser una cadena 00:38:14
con que uno de los dos sea una cadena 00:38:15
ya interpreta, ojo, no soy el operador 00:38:18
suma aritmética, soy el operador 00:38:20
concatenar, con lo cual 00:38:22
yo podría arreglar esto, por ejemplo 00:38:24
haciendo esto de aquí 00:38:26
poniendo un espacio, ¿verdad? 00:38:27
porque ahora ya 00:38:31
este tiene un lado cadena 00:38:32
luego dice, ojo, no soy operador suma 00:38:34
soy operador concatenar, pues concateno 00:38:36
8 con espacio 00:38:38
y me queda una cadena, y ahora 00:38:40
este más, aquí tiene un número 00:38:42
pero aquí tiene una cadena, entonces dice 00:38:45
Ojo, no soy operador suma, soy operador concatenar, 00:38:46
porque a un lado tengo una cadena, pues funciono como cadena. 00:38:49
Entonces ahora, como concatenación, perdón. 00:38:53
Entonces ahora este bicho, pues, ahora ya sí que sí, bueno, lo que fuera. 00:38:56
Ah, bueno, es que no le he metido un numerito entero. 00:39:02
Vale, ahora ya, este ya sí, ya no te hace la suma de 8 más 12, sino, ¿vale? 00:39:06
Bueno, paramos. 00:39:13
Un segundito que paro 00:39:15
Dime 00:39:17
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
10
Fecha:
19 de septiembre de 2024 - 17:03
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
39′ 20″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
148.16 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid