Saltar navegación

20241107 ProgrEstruct-Funciones_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 11 de noviembre de 2024 por Raquel G.

19 visualizaciones

Más información Transcripción

Descargar la transcripción

Venga, chicos y chicas y todo, y chiques y todo lo que sea que haya por aquí. 00:00:00
Vale, bueno, pues entonces, ¿qué hemos visto? 00:00:09
Hemos visto la programación estructurada, ¿vale? 00:00:14
Y la programación estructurada es lo que hemos visto y no hay más, 00:00:18
salvo detalles particulares de cada lenguaje, no hay más. 00:00:22
que es variables que rellenamos con datos, expresiones que podemos construir involucrando variables y los operadores del lenguaje, tanto lógicos como aritméticos, expresiones, expresiones que a su vez nos dan valores para variables y luego decisiones que nos permiten que el programa haga diferentes evaluaciones de esas expresiones, diferentes cosas en función de una condición 00:00:24
y bucles que nos permiten que un programa 00:00:49
se repita, perdón, que un trozo 00:00:52
de código se repita varias veces 00:00:54
entonces componiendo todo eso podemos hacer 00:00:55
cualquier cosa, ¿vale? cualquier cosa 00:00:58
que, cualquier cosa que le podamos 00:01:00
encargar a una CPU 00:01:02
cualquier cosa de la que una 00:01:04
CPU puede hacer 00:01:06
¿vale? una CPU convencional 00:01:08
vamos, no una arquitectura de otro tipo 00:01:10
otro tipo de arquitectura 00:01:12
vale, pues entonces cualquier cosa 00:01:16
que una CPU puede hacer 00:01:18
con su unidad aritmético-lógica, 00:01:20
unidad de control y todo eso, 00:01:21
se lo podemos indicar mediante 00:01:23
programación estructurada, como he dicho hasta ahora. 00:01:25
Y no necesitamos nada más, porque no entiende 00:01:27
nada más que eso. 00:01:29
Claro, pero ya un poquito hemos empezado 00:01:31
a ver en la aplicación esa de alumnos 00:01:33
del otro día, 00:01:35
que ya empiezan a quedar los programas un poco largos 00:01:37
y empieza a ser un poco pesado. 00:01:39
¿Empieza a ser un poco largo? 00:01:41
Sí, vale. 00:01:42
Abel, déjame, no me estropees la introducción. 00:01:44
No me tan miedo. 00:01:46
No, no es largo, pero bueno, para nosotros ahora mismo sí, porque de manejar un programa de 6 o 7 líneas a manejar ya algo que tiene 100 es largo y es un rollo. 00:01:48
Entonces, de hecho, como pauta de estilo, si a ti te queda un método, si a ti te queda un trozo de código de más de 10, 15 líneas, ya es un consejo que lo refactorices. Es decir, mira, reestructura esto de otra manera para que no te quede aquí en el mismo fichero, que queda muy largo. Si luego hay que buscar errores, es muy complicado. 00:02:01
entonces ya la aplicación 00:02:18
esta de alumnos del otro día ya hubiera 00:02:21
sido pesada de depurar 00:02:23
si hubiéramos tenido que encontrar errores lo que fuera 00:02:25
ya hubiera sido pesada 00:02:27
entonces muchísimo más bonito 00:02:28
organizar 00:02:31
el código de otra manera 00:02:33
y sobre todo 00:02:34
muchísimo más práctico 00:02:37
a la hora de encontrar errores 00:02:39
por un lado y de introducir 00:02:41
modificaciones, si yo mi aplicación 00:02:43
enorme con un montón 00:02:45
de líneas, así 00:02:47
pues digo, oye mira 00:02:49
como esto hace una cosa 00:02:51
y esto hace otra 00:02:53
y esto hace otra 00:02:55
que ya hemos dicho varias veces 00:02:57
que cuando nosotros programamos, programamos 00:02:58
por partes independientes en realidad 00:03:01
¿no? yo hago esta parte 00:03:03
esta parte ya está resuelta, ahora esta 00:03:05
parte se puede insertar aquí 00:03:07
vale, ya tengo esta parte resuelta y esta parte 00:03:08
se podría insertar aquí, pero de alguna manera 00:03:11
son como partes aisladas 00:03:13
entonces, si yo tengo aquí mi programa 00:03:15
con las partes que voy resolviendo 00:03:18
en lugar de irlas 00:03:20
engrasando, insertando 00:03:22
una con otra en el mismo código 00:03:24
pues si en lugar de eso pudiera 00:03:25
oye, a esta 00:03:27
vamos a darle un nombrecito 00:03:29
y la meto aquí 00:03:31
en un sitio distinto 00:03:33
a esta vamos a darle otro nombrecito 00:03:35
y esta parte la meto aquí 00:03:38
y a esta vamos a darle otro nombrecito 00:03:41
y la meto aquí 00:03:44
entonces primero 00:03:47
¿qué he conseguido? 00:03:49
que el trabajo de varios desarrolladores es más fácil 00:03:51
porque uno dice, oye tú ocúpate de esto 00:03:53
y este se ocupa de esto 00:03:55
en paralelo el desarrollador 2 00:03:56
se ocupa de esta parte 00:03:59
en paralelo el desarrollador 3 00:04:00
se ocupa de esta parte 00:04:03
cada uno tendrá sus requisitos 00:04:04
oye, tu trozo de código tiene que hacer esto 00:04:06
ah vale, pues yo hago esto por mi lado 00:04:09
por libre 00:04:11
oye, tu trozo de código tiene que hacer esto 00:04:11
Ah, pues yo hago esto por mi lado, por libre. 00:04:14
Cada uno trabaja en paralelo de forma independiente. 00:04:16
Cuando ya están estas partes hechas, 00:04:19
pues este programa tan feo 00:04:21
se convertiría en las llamadas y más en tres líneas. 00:04:24
Nombre 1, nombre 2 y nombre 3. 00:04:29
Se convertiría en eso. 00:04:32
Entonces queda más claro, 00:04:34
porque además si esos nombres están bien elegidos, 00:04:35
luego el que quiere ver lo que hace esta aplicación 00:04:37
dice, ah, sacar cifras. 00:04:39
Ah, vale, esto es un código que saca cifras. 00:04:42
¿Me interesa cómo está hecho? 00:04:45
Pues me voy aquí a mirarlo. 00:04:47
¿Que no me interesa? 00:04:48
Ya sé que esta parte hace sacar cifras. 00:04:49
Muy bien. 00:04:51
¿Mostrarlas por pantalla? 00:04:52
Ah, vale, este código lo que va a hacer es mostrarlas por pantalla. 00:04:53
¿Me interesa ver cómo lo hace? 00:04:57
Bueno, pues me voy a meter aquí a mirarlo. 00:04:58
¿Que no me interesa ver cómo lo hace? 00:05:00
Me da igual, no lo miro. 00:05:02
Entonces, uno ya en la aplicación tiene un primer vistazo de lo que hace, 00:05:03
muy bien organizadito, si los nombres se han elegido bien. 00:05:08
que quiere ver los detalles de alguna 00:05:11
de las partes, pues se va a esa 00:05:13
parte de ahí y ya está 00:05:15
luego, otra 00:05:17
ventaja, la aplicación la ejecutamos 00:05:19
pues la aplicación falla 00:05:21
entonces 00:05:22
porque no ha mostrado bien 00:05:24
las cifras, bueno pues entonces 00:05:27
el único fichero que tenemos que abrir 00:05:29
y que luego compilar otra vez 00:05:31
es este 00:05:33
los demás ni se 00:05:34
enteran, los demás ni se enteran 00:05:37
entonces es mucho más fácil depurar 00:05:39
si está separado por partes y cada parte tiene un nombre 00:05:41
luego 00:05:44
tres ventajas por lo menos 00:05:45
entender el código, mucho más claro 00:05:47
que varios desarrolladores 00:05:49
trabajen en paralelo, cada uno por su lado 00:05:52
y luego 00:05:54
depurar errores 00:05:55
mucho más sencillo 00:05:57
imagino que es una duda de mierda 00:05:59
pero 00:06:02
si todos los programas 00:06:02
por separado funcionan bien 00:06:06
pero luego a la hora de ponerlo en conjunto 00:06:07
no te saca los números bien 00:06:09
de la parte 1 00:06:11
Sí, a ver, lo que pasa es que esta es una forma 00:06:13
de ver la idea 00:06:15
Esto no es que sean programas 00:06:18
Esto sería como una función 00:06:21
que tú pones aparte 00:06:22
y luego esa función la llamas aquí 00:06:23
Entonces esta función te funcionará o no 00:06:25
dependiendo de si los datos que han venido de aquí 00:06:27
están bien o no están bien 00:06:30
Pero si esta función te funciona 00:06:32
tú esta no tienes que volver a tocarla, ni a mirarla, ni nada 00:06:33
porque esta ya está probada, ya se ha visto que si le das bien los datos funciona 00:06:36
esta ya está probada, esta depurada, esta te olvidas 00:06:40
entonces, el programa no te funciona pero no te funciona 00:06:42
porque es esto entonces, pues nada, tú simplemente te vas aquí 00:06:47
te vas ahí y ya está 00:06:51
pues la idea es que tú puedes probar y verificar de forma separada 00:06:53
esto, tú lo pruebas y lo verificas, luego claro el conjunto 00:07:00
ya forma una aplicación distinta 00:07:04
esa aplicación te funcionará 00:07:06
no te funcionará, habrá que hacerle sus propias pruebas 00:07:08
y bueno, habrá que ver 00:07:10
pero en cualquier caso, si esa aplicación no te funciona 00:07:11
siempre va a ser más sencillo 00:07:14
encontrar los errores 00:07:16
si está separado por partes 00:07:18
que si tienes ahí 00:07:20
las 10.000 líneas seguidas 00:07:21
siempre va a ser más manejable 00:07:24
si está más organizadito 00:07:25
esa es más o menos la idea 00:07:27
¿vale? 00:07:29
entonces, esto ya 00:07:31
antes de la programación orientada a objetos 00:07:33
ya recibió un nombre 00:07:36
que es el nombre de funciones 00:07:38
pues esto que yo he puesto aquí serían las funciones 00:07:39
¿vale? 00:07:42
esto serían funciones 00:07:43
cuando ya llegó la programación orientada a objetos 00:07:44
este concepto de función ya se diluyó 00:07:50
porque se incluyó 00:07:52
en el concepto de clase 00:07:54
¿vale? entonces una clase 00:07:56
en realidad, como ya veremos 00:07:58
en breve, es un montón 00:08:00
de funciones dentro, con más cositas 00:08:02
o más cosas, pero un montón de funciones dentro 00:08:04
¿vale? 00:08:06
entonces, aún así, antes ya 00:08:08
de empezar la programación anotada de objetos, las clases 00:08:10
y todo eso, vamos a ver 00:08:12
cómo en Java podemos 00:08:14
clarificar un poquito nuestros 00:08:16
códigos, separando 00:08:18
partes, a lo mejor 00:08:20
separando partes en funciones aparte 00:08:22
y así entendemos este concepto 00:08:24
porque si entendemos este 00:08:27
concepto, de llamar a función 00:08:28
cómo tengo que llamarla 00:08:30
si le puedo pasar parámetros a la función 00:08:32
o no, como recojo los resultados 00:08:34
si entendemos bien 00:08:37
este concepto y lo sabemos aplicar 00:08:38
pues luego ya el salto 00:08:41
a la programación de entrada de objetos 00:08:43
ya es más sencillo 00:08:44
¿vale? 00:08:46
pues vamos a 00:08:47
¿qué has dicho? ¿no has entendido nada? 00:08:49
¿alguien se lo 00:08:57
puede explicar? 00:08:58
no, no, maestro 00:09:00
Bueno, pues lo acabarás entendiendo 00:09:01
Pero... 00:09:19
¿Qué quieres que haga? 00:09:21
¿Que te vuelva a contar lo mismo otra vez? 00:09:23
Es que no sé, no entiendo 00:09:24
¿Por qué todo eso ahora? 00:09:26
Que no has entendido por qué todo eso ahora 00:09:27
Venga 00:09:31
Pues a ver 00:09:58
Vamos a ver 00:10:00
Dicho esto 00:10:01
Venga, vamos a empezar 00:10:07
Vamos a empezar con un ejemplo 00:10:10
Vamos a empezar con un ejemplo muy sencillo 00:10:14
Para ver la estructura 00:10:21
Como lo vamos a aplicar ahora mismo 00:10:23
Silencio, ajaba con lo que sabemos 00:10:24
Y luego ya 00:10:27
Pues podemos en alguno de los ejercicios 00:10:28
que hemos hecho antes que ocupaban más 00:10:30
vamos a decir, vale, ahora vamos a este ejercicio 00:10:32
modificarlo para sacarlo a funciones 00:10:34
y a ver si así efectivamente 00:10:36
lo vemos mejor, nos queda más claro 00:10:38
y de alguna manera entendemos 00:10:40
la ventaja 00:10:42
de programar de esta manera 00:10:44
Venga, pues vamos a hacer 00:10:46
No, ahora mismo 00:10:52
vamos a hacer un ejercicio, un ejemplo 00:11:00
para ver 00:11:02
la sintaxis de esto 00:11:03
Sí, sí, sí 00:11:05
Ah, acabáramos 00:11:09
O sea, que lo que vamos a hacer son funciones 00:11:11
Separadas o algo así 00:11:13
Sí, vamos a 00:11:14
Hacer funciones 00:11:16
Que son trozos de código 00:11:18
Bajo un nombre 00:11:19
Que pueden ser llamadas desde otro código 00:11:21
Y es como si tú 00:11:24
Todo ese código lo insertaras 00:11:26
Es como si hicieras un copia y pega 00:11:27
¿Vale? 00:11:29
Pero claro, esto tiene sus matices 00:11:31
Que es lo que tenemos que ver 00:11:33
Venga 00:11:35
Venga 00:11:37
Ay, sí 00:11:58
Me ha dado pereza 00:12:02
Bueno, se me ha puesto el por defecto 00:12:04
Pero por defecto es ninguno 00:12:10
Porque lo pone en el raíz directamente 00:12:11
Ya veréis con los paquetes 00:12:13
Cuando estudiemos los paquetes 00:12:16
Lo que significan 00:12:18
Entonces sí que os vais a quedar 00:12:20
Venga, pues yo que sé, funciona el mismo, da igual 00:12:21
Pues bien, entonces te cagarás un poco menos 00:12:24
Que los otros 00:12:33
Vale, venga 00:12:36
Nosotros hasta ahora 00:12:38
Todo nuestro código estaba metido ahí 00:12:41
y había muchas cosas que no entendíamos 00:12:44
y que vamos a seguir sin entender un rato más 00:12:48
¿Cómo protestáis tanto? 00:12:50
No me interrumpáis 00:12:57
A ver, hay cosas que vamos a seguir sin entender 00:12:58
obviamente, porque no sabemos 00:13:03
este public que pinta aquí 00:13:05
no sabemos este static que pinta aquí 00:13:07
el void ya sí vamos a entender 00:13:10
lo que significa 00:13:12
Pero este public no sabemos lo que significa 00:13:12
Lo entenderemos cuando 00:13:15
Estudiemos exactamente que son los paquetes 00:13:17
Y como funcionan 00:13:19
El static tampoco sabemos todavía lo que significa 00:13:20
Lo entenderemos cuando ya veamos clases 00:13:23
Ahora ya 00:13:25
En un ratinín este void 00:13:27
Y esto que está aquí si lo entenderemos 00:13:29
Pero lo demás no 00:13:31
En cualquier caso es que nos da igual 00:13:33
Nos da igual 00:13:35
A nosotros hasta ahora lo único que nos importa 00:13:37
Es que nuestros programas 00:13:38
Eran sentencias aquí dentro 00:13:41
Y ya está 00:13:43
Es lo único que nos importa 00:13:44
Y todo lo demás ya irá llegando 00:13:45
Paciencia 00:13:47
Vale, pues entonces que nosotros queríamos hacer un programa 00:13:48
Que 00:13:51
Pidiera 00:13:53
Te pidiera el nombre y luego te saludara 00:13:55
Por ejemplo 00:13:57
Pues hacíamos esto 00:13:58
¿Verdad? 00:14:00
Ese si lo pongo en el examen 00:14:04
Sabéis hacerlo, ¿no? 00:14:05
Dime que lo vas a poner 00:14:06
Ponlo, aunque sea 00:14:08
Dime 00:14:10
Esas preguntas se hacen 00:14:11
Dime sin mentir que lo vas a poner 00:14:13
Porque cualquiera te puede decir cualquier cosa 00:14:15
Dime sin mentir 00:14:18
Eso es posible 00:14:28
Eso, justo, estaba pensando 00:14:30
Vale, vale 00:14:37
Sí, la pregunta sería 00:14:42
¿Me vas a decir sin mentir si lo vas a poner? 00:14:50
No, no, no 00:14:52
La pregunta sería 00:14:53
¿Cuál sería la apuesta que elegiría el otro? 00:14:54
Y siempre va a ser la contraria 00:14:56
Porque el que te va a mentir, te va a mentir 00:14:58
Y el que te va a decir la verdad, te va a decir la verdad 00:15:00
Claro, pero traducido a la pregunta 00:15:01
¿Vas a poner esto en el examen? 00:15:03
¿Cómo se cambia eso? 00:15:04
A mí si una mujer me dice buenos días 00:15:06
Yo miro por la ventana porque esto va a ser 00:15:07
Bueno, ya empezamos generalizando 00:15:09
Bueno, no ha dicho que 00:15:12
Que todos los hombres 00:15:20
No mienten 00:15:22
Mienten todos los humanos 00:15:22
Un poco iguales son 00:15:25
Porque estamos en clase de programación 00:15:31
Y os voy a explicar lo que es una función 00:15:40
y tienes que confiar y hacerme caso 00:15:42
venga 00:15:45
vale 00:15:47
es que claro, me distraigo 00:15:48
con tonterías, vale, a ver 00:15:51
pues entonces, imaginaos si yo os he pedido 00:15:52
un código que te pida el nombre 00:15:55
y te salude, pues haríais esto 00:15:57
y lo haríais todo muy bien y tú has dicho 00:15:58
vas a poner esto 00:16:00
claro, y 00:16:02
podríamos iniciar una conversación infinita 00:16:06
pero no hace falta porque ya está, hemos hecho 00:16:08
el código y se acabó 00:16:10
Vale, pues ahora vamos a suponer que queremos sacar este código a una función 00:16:11
¿Vale? Vamos a suponer que queremos sacarlo 00:16:16
Vamos a ver cómo se hace 00:16:19
¿Vale? Que tenga interés o no 00:16:21
Pues bueno, sacar tres líneas 00:16:23
Lo digo porque me adelanto 00:16:25
¿Y por qué lo hacemos? 00:16:27
Pues lo hacemos para explicarte cómo es la sintaxis 00:16:28
¿Vale? No porque sea imprescindible en tu vida 00:16:31
Venga, pues entonces 00:16:34
Vamos a sacarlo a una función 00:16:37
Vale 00:16:39
Venga, pues 00:16:40
La función 00:16:42
La ponemos fuera de estas llaves 00:16:45
¿Veis? 00:16:48
El main se abre aquí 00:16:49
Y se cierra aquí 00:16:51
El propio main ya es una función 00:16:52
Como ahora vamos a ir entendiendo 00:16:55
Que se abre aquí y se cierra aquí 00:16:57
Pues ahora vamos a empezar a utilizar más 00:16:59
No solo esta, no solo el main 00:17:01
Más funciones 00:17:03
Venga, pues entonces va fuera de las llaves 00:17:03
Primero 00:17:06
no, no, no, de la primera 00:17:08
de la de esta no, esta las encierra 00:17:11
todas 00:17:13
vale, aquí en medio de las dos 00:17:13
vale, entonces 00:17:17
vale, entonces vamos a hacer una función que pide el nombre 00:17:19
y saludar, es decir, justo esto 00:17:31
con lo cual si tenemos esa función 00:17:33
pues en nuestro main la llamaremos 00:17:35
y listo, vale 00:17:37
pues, ¿qué tenemos que hacer 00:17:39
para hacer una función? 00:17:41
una vez que hemos identificado lo que queremos 00:17:42
que tenga dentro, eso siempre 00:17:45
es la parte fundamental 00:17:47
la que llamamos análisis, que es 00:17:48
oye, primero entiende lo que quieres hacer 00:17:50
y luego ya te pones a hacerlo, vale 00:17:53
pues hemos entendido que lo que queremos es una función 00:17:54
que te pide el nombre y saluda 00:17:57
vale, pues entonces 00:17:59
vamos a pensar un nombre 00:18:01
lo más explicativo posible para ella 00:18:02
a ver, que yo le puedo llamar así 00:18:05
Java no me va a decir nada, pero no es la idea 00:18:06
la idea es darle un 00:18:09
nombre explicativo relacionado 00:18:11
con lo que va a hacer 00:18:12
vale, pues vamos a llamarle 00:18:13
venga 00:18:16
vamos a llamarle saludar 00:18:18
y ya está, vale 00:18:20
el nombre es saludar 00:18:21
la función 00:18:23
tiene aparte del nombre otras dos 00:18:25
cosas más que hay que completar 00:18:28
una va aquí 00:18:30
entre unos paréntesis que son obligatorios 00:18:32
estos paréntesis 00:18:35
son obligatorios 00:18:36
hay que ponerlos sí o sí 00:18:38
Dentro de estos paréntesis puede ir algo o puede no ir 00:18:40
Ahora mismo no vamos a poner nada 00:18:44
Pero como son obligatorios hay que ponerlos 00:18:47
Vacíos, obligatorios 00:18:49
Y antes de la función tiene que ir algo 00:18:51
También obligatorio 00:18:54
¿Qué tiene que ir antes de la función? 00:18:56
Tiene que ir algo relacionado con el hecho de si esta función 00:19:00
Me va a devolver un valor o no me lo va a devolver 00:19:05
Hacia el programa que lo llama 00:19:07
Ahora, luego lo entenderemos mejor 00:19:10
Pero ahora avanzamos 00:19:14
Una función, aparte de hacer el código que tiene dentro 00:19:15
Aparte de hacer el código que tiene dentro 00:19:18
Puede construir un valor 00:19:20
Uno solo 00:19:22
Un valor solo 00:19:24
Y entregarlo al programa que lo llama 00:19:25
Puede o no 00:19:28
En este caso, nuestra función 00:19:31
No va a construir ningún valor 00:19:33
Ni entregarlo al programa que lo llama 00:19:35
Lo que va a hacer va a ser mostrar por consola 00:19:37
Un mensajito y ya está 00:19:39
no va a hacer nada más. Entonces, cuando una función no hace eso de construir dentro un valor 00:19:40
y entregarlo al programa que lo llama, sí, se le pone el void, ¿vale? Pero algo hay que ponerle 00:19:46
obligatorio. Bueno, aprovechamos y paramos, ¿vale? Justo, efectivamente. 00:19:56
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
19
Fecha:
11 de noviembre de 2024 - 12:14
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
20′ 03″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
546.05 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid