Saltar navegación

20240924 ProgrEstruct-Variables-ejercicios_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 24 de septiembre de 2024 por Raquel G.

7 visualizaciones

Más información Transcripción

Descargar la transcripción

Venga, hacedme caso todos, aunque vayamos a hacer esto mismo, ¿vale? 00:00:00
Entonces, ¿qué es lo que vosotros habréis hecho? 00:00:05
Sí, ahora mismo había esos dos para sincronizarnos todos en ese punto. 00:00:10
Vale, pues ¿qué es lo que habréis hecho vosotros? 00:00:15
Venga, pues vamos a hacer... 00:00:17
Entonces, todo esto que voy a hacer es todo lo que ahora mismo tendríais que llegar vosotros por vosotros mismos, ¿vale? 00:00:18
Porque si no, pues tenéis que seguir machacando en eso. 00:00:26
Vale, pues entonces, ejercicio 1. 00:00:31
Vamos a hacer una clase. 00:00:34
Andoni, que te voy a sacar el otro hombro. 00:00:36
Silencio. 00:00:40
Silencio. 00:00:42
Vale. 00:00:43
Vamos a hacer un ejercicio, pues una clase para ese ejercicio. 00:00:46
O sea, todo lo que yo estoy diciendo ahora, 00:00:49
todo frase por frase, es lo que autoevaluaros. 00:00:51
A ver si todos lo tenéis en la cabeza ahí claro y memorizado, porque si no deberíais tenerlo, porque si no estamos ya empezando a empezar a sentar las bases de que en noviembre os vayáis. 00:00:54
Bueno, pues entonces, vamos a hacer un ejercicio, un ejercicio, pues ahora mismo un programa para ese ejercicio. 00:01:07
en Java 00:01:14
nosotros a cada programa 00:01:16
por ahora lo estamos llamando clase 00:01:18
porque es un término 00:01:20
de programación de entrada de objetos, ahora mismo no 00:01:22
entendemos muy bien quizá por qué le llamamos clase 00:01:24
pero nos vamos a quedar con que 00:01:26
ahora mismo para nosotros cada programa 00:01:28
que hace algo es una clase 00:01:30
vale, nos quedamos con eso 00:01:32
vale, ¿cómo hacemos una clase? 00:01:34
pues sabemos que hay que poner obligatoriamente 00:01:37
class 00:01:38
nombre de la clase y luego public 00:01:39
static void name, o lo escribo 00:01:42
a mano, que debería poder escribirlo a mano 00:01:44
o si tengo 00:01:46
el eclipse, pues le ahorro la tarea 00:01:48
me ahorro la tarea, entonces si tengo 00:01:50
el eclipse, me puedo ahorrar la tarea 00:01:52
de escribir a mano el class 00:01:54
nombre que me dé la gana 00:01:56
public static void main, bla bla bla 00:01:57
me lo puedo ahorrar de esta manera 00:01:59
pues new class 00:02:02
le digo aquí el nombrecito 00:02:03
pues venga, ejercicio 00:02:06
uno 00:02:08
y él ya me ha 00:02:09
escrito esto solito 00:02:12
Como no le he marcado el tick 00:02:14
En la ventana desplegable 00:02:16
Lo he hecho muy rápido, no le he marcado el check 00:02:17
De que me escriba también el public static void main 00:02:20
Pues no me lo ha escrito 00:02:22
Pero no pasa nada, no se lo escribo 00:02:24
Y se acabó, vale, así 00:02:26
Bueno, pues entonces 00:02:32
Esta estructura con o sin el public 00:02:34
Nos da igual 00:02:36
Esta estructura 00:02:37
Es ahora mismo la estructura 00:02:41
Que obligatoriamente tenemos que calzar 00:02:43
ahí cada vez que queramos hacer un programa 00:02:46
y ahora el programa va ahí dentro, ¿verdad? 00:02:48
¿Vale? Repito que todo esto 00:02:51
que os estoy diciendo es lo que a día de hoy 00:02:52
tiene que estar ahí, os tiene que sonar, si ya me lo sé 00:02:54
ya me lo sé, pues os tiene que sonar a ya me lo sé 00:02:56
ya me lo sé, ¿vale? 00:02:58
Recordad que si estamos 00:03:01
en el eclipse y hemos hecho de las 00:03:02
subcarpetas o los paquetes para que nos 00:03:04
quede más organizadito, aquí además 00:03:06
nos habrá puesto package, no pasa nada 00:03:08
le dejamos el package 00:03:10
¿No entendemos todavía muy bien por qué lo pone? 00:03:11
Ya sé que no lo entendemos 00:03:14
Pero se lo dejamos 00:03:15
Bueno, yo como no he puesto aquí una subcarpeta 00:03:17
Package, ni nada 00:03:20
Pues por eso no me ha puesto ahí nada 00:03:21
Venga, pues hala, ahora ya empezamos 00:03:23
Con el ejercicio 00:03:26
Pues qué es lo que uno habrá hecho 00:03:26
Pues uno primero de todo 00:03:28
Lo ha tenido que leer 00:03:31
Esto de aquí no se lo puedo quitar 00:03:34
Tendría que descargarlo y abrirlo 00:03:38
Vale, pues a ver 00:03:41
Lo primero que habréis hecho será imprescindible leerlo y entender exactamente qué se pide. En este caso es una frase. Programa que solicita por teclado dos numeritos distintos, primero uno y luego otro, dos números. 00:03:54
Entonces, uno, para entender bien un enunciado, tiene que ponerse en la situación real de que ese programa ya se está ejecutando. En este caso es sencillo. Hay ejemplos en los cuales no es tan sencillo. Pero para entender bien lo que pide un enunciado, tenéis que psicológicamente poneros en la situación de, vamos a suponer que ese programa arranca. ¿Qué tiene que pasar? 00:04:11
Vale, pues en este caso, primero te dirá solicita un número, tú le metes ese número, vale, luego te dirá introduce otro número, tú le metes otro número y cuando ya haya pasado eso que yo le he metido un número y luego después otro número, me tiene que mostrar la suma de ambos. 00:04:30
bueno, entonces ya hemos entendido 00:04:50
que se nos pide 00:04:52
¿vale? y repito, para entender bien 00:04:53
que se nos pide, tenemos 00:04:56
aparte de leer bien el enunciado y analizarlo 00:04:58
ponernos en la situación de que 00:05:00
el código se está ejecutando y ver 00:05:02
que debería pasar, pues aquí 00:05:04
debería pasar que me pida un número 00:05:06
y yo lo meta, que luego después 00:05:08
me pida otro y yo lo vuelvo a meter 00:05:10
y luego después que me muestre un resultado 00:05:11
vale, pues ya hemos hecho 00:05:14
todo eso y ya entendemos que nos pide 00:05:16
como ya entendemos bien que nos pide 00:05:18
ahora ya nos podemos venir aquí 00:05:20
y empezar a pensar ya en términos de Java 00:05:22
no significa que tengamos que ponerse a escribir líneas de código 00:05:25
una tras otra, no 00:05:28
ya podemos empezar a pensar 00:05:29
primera cosa que habremos pensado 00:05:31
¿con qué datos trabaja mi programa? 00:05:33
pues por lo menos con dos números enteros 00:05:37
que yo los voy a pedir por teclado, claro 00:05:40
pero con dos números enteros 00:05:43
entonces, de nuevo, todos tenemos clarísimo grabado 00:05:44
que todos los datos con los que 00:05:47
un programa va a operar 00:05:49
tienen que estar en variables, no hay 00:05:50
alternativa, tienen que estar en variables 00:05:53
entonces 00:05:55
si mi programa trabaja con un 00:05:57
número entero y con otro 00:05:59
número entero, con dos 00:06:01
porque me va a pedir dos, lo primero que 00:06:02
ya tengo que hacer es, pues voy a declarar 00:06:05
dos variables, una para cada 00:06:07
dato, y eso es siempre 00:06:09
lo primero que pensamos 00:06:11
en nuestro código 00:06:13
¿qué variables necesito? 00:06:15
Y voy a necesitar variables correspondientes a los datos con los que trabaja. Entonces, tenemos siempre que en este primer análisis de mi aplicación ver con qué datos trabaja, con dos números, trabaja con dos números, ah, vale, trabaja con dos números, pues tengo que declarar dos variables, ¿vale? 00:06:17
Entonces, es fundamental cuando uno piensa en cómo hacer un programa 00:06:34
que no se centre tanto en lo que tiene que hacer, 00:06:38
sino en con qué datos trabaja. 00:06:43
Eso es mucho más importante incluso. 00:06:45
Porque lo que tiene que hacer muchas veces es nada. 00:06:48
Leer del teclado y mostrar y hacer una suma y resta. 00:06:50
Chorradas. 00:06:53
Ahora mismo, al menos. 00:06:54
Es más importante pensar con qué datos trabaja. 00:06:55
Esa es la pregunta que siempre se nos olvida. 00:06:58
Nos creemos que programar es hacer cosas. 00:07:00
Sí, programar es hacer cosas. 00:07:02
pero esas cosas se hacen con datos 00:07:04
entonces 00:07:06
en el diseño de un programa 00:07:07
la parte más crítica 00:07:10
suele ser 00:07:12
¿qué datos trabaja mi programa? 00:07:13
¿con qué datos trabaja? 00:07:16
¿y dónde los guardo? 00:07:18
esa es la parte crítica 00:07:19
¿y ahora qué hace? 00:07:20
lo que hace serán cuatro chorradas que escribo con tres líneas 00:07:22
bueno, pues en este caso 00:07:25
¿con qué datos trabaja mi programa? 00:07:26
es fácil de responder, dos números 00:07:28
¿dónde los guardo? 00:07:30
fácil de responder, dos variables 00:07:32
¿vale? habrá situaciones 00:07:35
en las que no es tan fácil, ¿con qué datos 00:07:37
trabaja mi programa? con 27.000 00:07:39
nombres y 40.000 00:07:41
números decimales 00:07:42
entonces ahí, decidir 00:07:44
dónde los guardo, ya no va a ser 00:07:46
trivial, porque no voy a declararme con 10.000 00:07:49
variables, tendré que pensar en hacer 00:07:50
una lista, hacer una array, hacer no sé qué 00:07:53
pero eso ya será más adelante 00:07:54
ahora mismo, ha sido fácil de resolver 00:07:56
mi aplicación trabaja con dos 00:07:59
números, pues dos variables 00:08:01
luego, quedaos grabados 00:08:02
en la cabeza, antes de empezar a hacer 00:08:05
ninguna cosa, uno tiene que tener muy claro 00:08:07
cuáles son los datos con los que trabaja 00:08:08
su programa, y diseñar 00:08:10
el conjunto de variables 00:08:12
que necesita para 00:08:15
guardar esos datos, porque si no, ¿dónde van a ir esos datos? 00:08:16
pues venga, dos números 00:08:20
pues dos variables 00:08:21
enteras, ¿sabemos declarar dos variables enteras? 00:08:23
claro que sabemos, lo sabemos, lo hemos aprendido 00:08:25
y sabemos declararla, pues ya está 00:08:27
como no lo hemos estudiado, sabemos declararla 00:08:28
esto no nos para, aquí es donde 00:08:30
podríamos pararnos y quedarnos 00:08:33
atascados, ¿por qué? porque no hemos 00:08:34
estudiado y no nos hemos aprendido de memoria 00:08:37
cómo se declara una variable 00:08:39
y cuál es el nombre del tipo de dato entero 00:08:40
ahí nos quedaríamos atascados 00:08:43
nos quedaríamos atascados porque no lo hemos estudiado 00:08:44
no lo hemos memorizado 00:08:46
¿vale? bueno, como ese no es nuestro 00:08:47
caso, no nos quedamos atascados 00:08:51
porque sabemos cómo se declaran dos variables enteras 00:08:52
poniendo el tipo de dato primero 00:08:55
luego el nombre que a mí me dé la gana 00:08:57
número uno, ahora 00:08:59
Que quiero otra variable 00:09:00
Pues venga 00:09:03
Me pongo yo mi otra variable 00:09:04
Hombre, ya que empezamos 00:09:06
A ser ya profesionales 00:09:09
Esto está bien, con esto he declarado 00:09:10
Dos variables, pero ya que somos profesionales 00:09:12
Pues bueno, las declaro en la misma línea 00:09:15
Que sabemos que lo puedo hacer, ¿no? 00:09:16
Sabemos que esta misma línea 00:09:19
La puedo hacer así 00:09:20
¿Vale? Y estoy haciendo lo mismo 00:09:21
Estoy haciendo lo mismo, ¿vale? 00:09:25
Eso ya lo sabemos 00:09:27
Todo esto ya lo tenemos memorizado y lo sabemos 00:09:28
Vale, ahora ya que tenemos las variables que va a usar mi programa para guardar los datos, ahora ya la siguiente pregunta que nos hacemos de forma natural es, Valera, para que mi programa trabaje haciendo cosas con esos datos, que ya veremos qué tiene que hacer, pero para que trabaje haciendo cosas con esos datos, tengo que asignarles valor. 00:09:30
Luego, el siguiente problema que viene después de declarar es asignar. 00:09:54
Pues ahora la pregunta es, vale, ¿y de dónde asigno? 00:09:58
¿Me ha dicho el programa que le asigne 7 a la primera variable y 4 a la segunda? 00:10:00
No, no me ha dicho que le asigne 7 y 4. 00:10:05
Porque si me hubiera dicho eso, yo haría número 1 igual a 7 y número 2 igual a 4. 00:10:08
Pero es que no me ha dicho eso el programa. 00:10:18
El programa me ha dicho, lo que tienes que asignarle a la variable es algo que leas del teclado. 00:10:19
Vale, pues ahí tampoco nos paramos, porque como no lo hemos estudiado, sabemos perfectamente 00:10:29
qué hay que poner aquí para asignar a esta variable lo que leemos del teclado. 00:10:34
Entonces, ¿qué es lo que leo del teclado? Pues no me paro, lo hago seguido porque me lo he estudiado 00:10:39
y lo tengo en la memoria. 00:10:44
Vale, fundamental que todo esté estudiado y en la memoria. 00:10:45
Si no, uno está parado en cada línea 00:10:48
Vale, pues 00:10:50
¿Qué teníamos que hacer? 00:10:52
Declarar el famoso objeto scanner 00:10:53
Con el nombre que a uno le dé la gana 00:10:56
Y ponerle 00:10:58
Esto de aquí para que se inicialice 00:11:00
Vale, para que 00:11:02
El compilador se lo trague 00:11:09
Teníamos que poner aquí 00:11:11
Que de nuevo esto es porque 00:11:13
Lo sabemos de memoria 00:11:15
No hay otra 00:11:17
Java útil 00:11:18
Punto scanner 00:11:20
vale, y ahora ya 00:11:23
que teníamos ese objeto 00:11:31
lector hecho, ya sabíamos que en lugar 00:11:33
de 7, no le asignamos 7 00:11:35
le asignamos esto 00:11:37
y a este en lugar de 4 00:11:39
no le asignamos 4, sino que 00:11:44
le asignamos esto 00:11:46
vale, ya hemos hecho gran parte 00:11:47
del programa, que es 00:11:53
ya he decidido que son dos variables 00:11:54
y ya es lo que necesito, las he declarado 00:11:57
y ya he visto 00:11:59
ya he decidido que lo que tengo que asignarles 00:12:01
Asignarles ahora que asignarles es leído del teclado, leído del teclado. 00:12:03
Ya podemos avanzar antes de hacer la primera ejecución que va en este programa, pues sí, hasta ahora está bien y va a funcionar, pero va a ser un poco feo porque aquí se va a quedar esperando sin decirnos lo que espera y luego después va a seguir esperando al siguiente sin decirnos lo que espera. 00:12:08
Entonces, para hacer el programa un poquito más amigable 00:12:25
Aunque no sea obligatorio, un poquito más amigable 00:12:29
Vamos a poner que muestra aquí un mensajito 00:12:31
Para que al menos nos esté informando de qué va a esperar después 00:12:33
Que menos, ¿no? 00:12:38
Que menos que sea un poquito amigable y nos diga lo que espera 00:12:41
Introduzca número entero 00:12:47
Y aquí otro 00:12:56
Y aquí otro 00:13:00
vale 00:13:05
entonces ahora ya este programa cuando lo ejecutemos 00:13:06
mostrará este mensaje 00:13:10
y se quedará esperando, pero al menos yo ya sé 00:13:11
que espera, le meto un entero 00:13:13
volverá a mostrar el mensaje y se quedará esperando 00:13:15
pero ya sé lo que espera, le meto otro entero 00:13:17
y ahora 00:13:19
escribimos el resultado final 00:13:20
y luego ya paramos y comentamos 00:13:23
los posibles errores que nos podrían haber salido 00:13:25
vale, pues ya tenemos gran parte hecha 00:13:27
que es, tengo los dos números 00:13:29
guardados en las variables 00:13:32
que tiene que estar 00:13:33
porque el programa solo puede trabajar 00:13:34
con lo que hay en variables, 00:13:38
solo con lo que hay en variables, 00:13:39
no puede trabajar con nada más, 00:13:40
solo con lo que hay en variables. 00:13:42
Vale, ¿qué nos falta? 00:13:43
Que nos muestre por pantalla 00:13:45
la suma del contenido de las dos variables. 00:13:47
Bueno, pues ya sabemos cómo hacer 00:13:52
la suma del contenido de dos variables. 00:13:53
Número 1 más número 2 00:13:56
Es la suma del contenido de esas dos variables 00:14:00
Pero esto suelto no pinta nada 00:14:04
¿Qué hago yo con esto suelto? 00:14:06
Pues puedo asignárselo a otra variable 00:14:08
Y luego mostrar esa variable 00:14:11
O mostrarlo directamente en un System.out.println 00:14:12
Lo que vive de la gana 00:14:15
Por ejemplo, vamos a mostrarlo directamente 00:14:17
Bueno, a ver, voy a hacerlo en plan largo 00:14:20
Voy a declararme otra variable más 00:14:23
Para guardar el resultado 00:14:25
Porque soy así de chula 00:14:27
y quiero otra variable más solo para el resultado. 00:14:28
Pues venga, me declaro otra variable entera más. 00:14:32
Y a esa variable entera, 00:14:36
a esa variable entera que me he declarado, 00:14:38
le asigno la suma de las dos anteriores. 00:14:42
Vale, pues ya tengo el resultado ahí guardadito. 00:14:46
Tengo el resultado ahí guardado. 00:14:49
Vale, es otra variable más. 00:14:51
Con lo cual he utilizado tres variables. 00:14:52
Las dos primeras para los datos de entrada 00:14:55
y otra más para guardar la suma de las dos primeras, ¿vale? 00:14:57
Pero, claro, si dejo el programa así, el programa termina 00:15:03
y el que está ahí sentado no ve el contenido de la variable. 00:15:05
Hombre, pues mostrémoslo, mostrémoslo. 00:15:09
¡Hala! Pues ya sabemos que el System.out muestra, 00:15:18
como esto no está entrecomillado, 00:15:22
como eso no está entrecomillado, 00:15:24
muestra el contenido de esa variable. 00:15:26
Si estuviera entrecomillado, 00:15:29
comillado, sabemos que mostraría 00:15:30
resultado literal, porque está entre comillas 00:15:32
dobles, pero no, queremos el contenido 00:15:34
de la variable. 00:15:36
Pues el system.out cuando encuentre esto 00:15:38
será el contenido, ¿vale? 00:15:40
Y ya tenemos 00:15:45
nuestra primera versión del programa, si es 00:15:46
que, y uno 00:15:49
ya la, como no tiene errores de compilación 00:15:51
la puede ejecutar. Nunca 00:15:53
ejecutéis algo que tiene errores de compilación 00:15:55
porque no tiene sentido. 00:15:57
Este no lo tiene, no tiene nada 00:16:00
rojo, no tiene ningún error de compilación. 00:16:01
pues lo puedo compilar, perdón, ejecutar, me pongo a hacer mis pruebas, introduzco número entero, 5, introduzco número entero, 6, 11, vale, pues ya está, vale, vamos a parar aquí y luego vemos posibles errores que os puedo hacer, 00:16:03
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
7
Fecha:
24 de septiembre de 2024 - 18:28
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
16′ 22″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
64.78 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid