Saltar navegación

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

Clase 8-01-24 - 3 - 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 8 de enero de 2024 por Raquel G.

5 visualizaciones

Más información Transcripción

Descargar la transcripción

Venga, pues ala, ejercicio 3, vale, en el proyecto que estoy subiendo la ola virtual, 00:00:00
lo estoy metiendo cada ejercicio ahí en paquetes distintos, 00:00:20
pero insisto, nosotros todavía no sabemos lo que son paquetes, 00:00:24
aunque creáis que lo sabéis, no lo sabéis, lo sabréis en unos días. 00:00:27
Bueno, pues venga, el ejercicio 3, vamos a calentar con él. 00:00:33
En este caso, la aplicación ya me da el análisis hecho, 00:00:38
que va a ser la mayoría de nuestros casos en los exámenes o vídeos que planteemos. 00:00:47
Nosotros en los ejercicios que planteemos y en los exámenes, 00:00:54
ya diremos qué clases hay que programar, pero en una situación real, 00:00:57
en una aplicación real, a uno lo que se le dice es, 00:01:02
tienes que solucionarme el problema de matricular a los alumnos de mi instituto, 00:01:05
y uno ahí tendrá que hacer su análisis y decir, vamos a ver, 00:01:09
qué entidades voy a necesitar, esta, esta, esta, 00:01:14
y empezar a trabajar desde ahí, desde ese punto, 00:01:17
¿vale? Pero toda esa parte de análisis previo, insisto, 00:01:20
nosotros ahora no la estamos haciendo porque nuestros enunciados 00:01:23
ya directamente dicen qué clases tienes que programar, 00:01:26
y luego el programa principal, qué tiene que hacer. 00:01:29
Bueno, pues este es el caso, nos están diciendo, venga, 00:01:32
esta aplicación es el software que va dentro de una cafetera, ¿vale? 00:01:36
Cuando una cafetera, tú le das al botón de llenar agua, 00:01:42
echar café, pues das a botones, esos botones ejecutarán un pequeño programa, 00:01:46
un programa que activará los sensores de abrir la compuerta del agua, 00:01:52
lo que sea, pues lo que te están diciendo es, 00:01:56
haz esa aplicación, esa aplicación. 00:01:59
Bueno, pues esa aplicación, ¿con qué va a trabajar? 00:02:03
Con una cafetera, ¿no? La aplicación del software interno de una cafetera, 00:02:06
la entidad con la que trabajas, la cafetera, pues ya está, 00:02:11
ya te lo dicen aquí. 00:02:14
Bueno, pues entonces vamos a necesitar una clase cafetera, ¿vale? 00:02:16
Pues venga, lo primero entonces es declarar esa clase, 00:02:20
lo primero es declarar esa clase, que es la única entidad 00:02:27
con la que va a trabajar el software, la cafetera, la única, 00:02:32
pues hala, venga, ya está la clase, ¿vale? 00:02:38
El public, yo lo quito porque como no sabemos lo que es, 00:02:43
pues tener algo ahí que no sabemos lo que es, pues no me gusta. 00:02:47
Bueno, ahora la siguiente pregunta que uno se haría en un caso real es, 00:02:51
vale, este software que gestiona el funcionamiento de la cafetera, 00:02:55
este software, ¿qué datos de la cafetera necesita para funcionar? 00:03:00
Pues la capacidad, lo que tiene en ese momento, la marca, 00:03:06
el volumen, el color, ¿qué datos necesita de la cafetera 00:03:10
para gestionar ese software? 00:03:13
Bueno, pues después de haber hecho el análisis de los requisitos 00:03:15
de la aplicación, uno llegaría a la conclusión, 00:03:19
que ya te dan aquí en el enunciado, que te dicen, a ver, 00:03:22
las acciones que hace ese software, que son llenar la cafetera, 00:03:26
servir café, etcétera, los únicos datos que necesitan son 00:03:30
la cantidad máxima de café que cabe y la cantidad actual que tiene. 00:03:35
Solo necesitas esos dos datos, la que tiene y la que cabría como máximo. 00:03:43
Con esas dos informaciones, el software de la cafetera 00:03:49
ya puede hacer todo lo que necesite. 00:03:52
Vale, aquí ya he enunciado, te dice que son esas dos las propiedades 00:03:55
que necesitamos, pero en un caso real, pues uno tendría que haber analizado 00:03:58
en función de los requisitos que tiene que satisfacer, 00:04:02
cuáles son las características que necesita. 00:04:05
¿Vale? 00:04:11
Y Andon y Diego Jiménez no creo que vuelvan a aprobar en su vida. 00:04:13
Porque lo veo venido. 00:04:20
Pues venga, entonces, capacidad máxima y cantidad actual. 00:04:26
Bueno, habría que decidir de esos dos datos qué son los que necesitamos. 00:04:32
Bueno, entero, double, pues bueno, el que más nos guste. 00:04:36
Vamos a suponer que son centímetros cúbicos, porque es un tema de volumen. 00:04:39
Pues venga, entero. 00:04:45
Vale, pues esa es una de las propiedades de cada cafetera, la capacidad máxima. 00:04:52
Vale, y la otra, la cantidad que tiene en ese momento. 00:04:58
Como las dos son enteras, pues nosotros ya sabemos declarar las variables, 00:05:05
si son del mismo tipo, las declaramos ya en la misma línea, 00:05:10
todo esto ya lo sabemos. 00:05:13
Ahora, ya tenemos las propiedades. 00:05:14
Por defecto, uno suele hacer un constructor siempre. 00:05:18
Ya lo dijimos antes de irnos de vacaciones cuando miramos los constructores. 00:05:22
Que por defecto, uno suele hacer un constructor siempre cafetera, 00:05:27
que es el que llamamos, el que se llama constructor con parámetros, ¿verdad? 00:05:35
Es al que se le pasan dos valores y el constructor los usa 00:05:41
para inicializar con ellos esas propiedades. 00:05:47
Ese es el famoso constructor con parámetros. 00:05:51
Entonces uno lo puede escribir a mano o como se suele hacer siempre por defecto, 00:05:53
ya dijimos que el Eclipse y otros entornos de desarrollo 00:05:57
te permiten generarlo automáticamente con el source, 00:06:00
generar constructor usando campos, bla, bla, bla. 00:06:04
Le quito el super porque en este caso no está haciendo nada, 00:06:09
estar y no estar es lo mismo. 00:06:13
Y le quito el public por lo mismo, 00:06:15
porque no sé ninguna de las dos cosas qué significa 00:06:17
y que estén o que no estén da exactamente igual, 00:06:20
porque no la estamos usando. 00:06:23
Este es el constructor con parámetros que se llama, 00:06:25
que es el constructor que suelen incluir todas las clases porque es muy útil. 00:06:29
Si tú tienes este constructor, cuando instancias el objeto, 00:06:34
en el momento de instanciarlo ya aprovechas y le das un primer valor. 00:06:37
Ya aprovechas y le das un primer valor a través de estos parámetros. 00:06:43
¿Recordáis aquí el primero de los 2315 matices distintos 00:06:50
que vais a tener que ir incorporando todos de memoria, no en los papeles? 00:06:56
En esos son los que espero que estéis tomando apuntes. 00:07:01
Bueno, pues aparte de los papeles de los que toméis apuntes, 00:07:04
habrá las 2315 cosas que tendréis que ir incorporando en la cabeza de memoria. 00:07:07
Bueno, pues una de ellas, recordad que era esta. 00:07:13
Cuando yo doy aquí un parámetro y resulta que este parámetro 00:07:16
se llama igual que una propiedad, se llama igual que una propiedad, 00:07:22
de repente aparece una ambigüedad, ¿verdad? 00:07:26
Aparece una ambigüedad. ¿Qué es? 00:07:29
Oye tú, ¿y aquí dentro qué pasa? 00:07:32
Cuando yo ponga capacidad máxima, 00:07:35
¿a quién le estoy haciendo referencia? 00:07:44
¿Al parámetro que le he pasado desde fuera? 00:07:47
¿O a la propiedad interna de la cafetera? 00:07:50
Se acaba de crear una ambigüedad, ¿no? 00:07:53
¿Por qué se llama igual? 00:07:56
Pues esa ambigüedad se resuelve, dijimos, con esto. 00:07:59
Porque si nosotros no ponemos esto, esto se refiere al parámetro que está aquí. 00:08:04
Y si ponemos this significa no, es propiedad del objeto al que estoy, 00:08:11
de este, this, de este. 00:08:15
Entonces el this es opcional cuando no hay ambigüedad. 00:08:18
Cuando no hay ambigüedad es opcional, 00:08:22
porque no hay ningún parámetro que se llame así. 00:08:24
Si a este le hubieran cambiado de nombre, 00:08:26
el Eclipse hubiera decidido dar otro nombre, 00:08:28
no lo ha decidido porque es muy listo, 00:08:30
y lo hubiera decidido llamar así, 00:08:32
entonces no habría ambigüedad 00:08:34
y este constructor podría haberse hecho así. 00:08:36
Ahora no habría ambigüedad, el this sobra. 00:08:47
Sería opcional, porque con capacidad máxima 00:08:50
no hay duda de a qué nos referimos. 00:08:53
Nos referimos a la propiedad porque no hay nadie más 00:08:55
que se llame capacidad máxima, no hay nadie más, no hay duda. 00:08:57
Con lo cual el this es opcional, sobra. 00:09:00
Que lo pongo por claridad, que suele ser habitual ponerlo, 00:09:03
porque queda más bonito, no pasa nada, no sobra. 00:09:07
Ahí está estupendo el this puesto. 00:09:10
Que no me da la gana ponerlo, 00:09:13
porque no me gusta poner cosas opcionales, lo quito. 00:09:15
Da igual, no hay ambigüedad en cualquier caso, 00:09:20
porque solo hay una cosa que se llame capacidad máxima, 00:09:22
que es esto. 00:09:24
Pero si se nos ha ocurrido, como se le ocurre al Eclipse 00:09:27
y a todo el mundo, llamarlo igual, 00:09:30
pues la ambigüedad aparece. 00:09:35
Si la ambigüedad aparece, ahora ya hay que resolverla. 00:09:38
Capacidad máxima, si yo no pongo this, es este. 00:09:46
Con lo cual esto sería absurdo. 00:09:50
Sería, al parámetro capacidad máxima, asígnale el valor del parámetro. 00:09:52
¿Qué tontería es esa? Esto no tendría sentido. 00:09:56
Entonces aquí sí que tenemos que poner el this, 00:09:59
porque yo me quiero referir a la propiedad. 00:10:04
Esto está claro, ¿no? 00:10:11
Este this sirve para eso, para decir, 00:10:13
el objeto en el que estoy, punto la propiedad que yo quiera. 00:10:15
Y es imprescindible cuando hay dos variables que se llaman igual. 00:10:19
Tengo que distinguir si estoy en la propiedad del objeto 00:10:23
o estoy en otra variable. 00:10:26
Este parámetro, lo que sea. 00:10:28
Esa ambigüedad también podría haber aparecido. 00:10:31
Imagínate que yo estos parámetros los quito de ahí 00:10:33
y me he creado aquí una variable, 00:10:37
o sea que los leo por teclado, por ejemplo, 00:10:43
y me creo yo aquí un capacidad máxima, 00:10:46
una variable local que me creo ahí, capacidad máxima, 00:10:54
que la leemos por teclado. 00:10:59
Hacemos el import. 00:11:17
Y ahora yo pongo aquí, 00:11:22
introduzca capacidad máxima. 00:11:27
Y la leo aquí, scan.next int era. 00:11:35
Vale, hago lo mismo con la cantidad actual. 00:11:41
Vale, pues este es otro constructor que me podría a mí 00:12:10
haber dado la gana hacer. 00:12:12
¿Por qué no? 00:12:13
Me da a mí la gana hacer este constructor. 00:12:14
Vale, un constructor al que no le paso parámetros. 00:12:16
¿Y qué es lo que hace cuando se le llama? 00:12:19
Pide él por teclado los valores, 00:12:21
los pide, los guarda en dos variables locales, 00:12:24
y ahora asigna esos valores a las propiedades de la cafetera. 00:12:27
Podría haberme dado a mí la gana hacer ese constructor, ¿no? 00:12:33
Vale, pues de nuevo aquí hay ambigüedad, 00:12:38
porque ahora tengo aquí dos cosas que se llaman capacidad máxima. 00:12:41
Esta variable que acabo de declarar, 00:12:45
esta variable que está dentro de este método, 00:12:48
y la propiedad. 00:12:51
De nuevo he creado una ambigüedad. 00:12:52
Pues ahora de nuevo le doy el dis, 00:12:54
porque si yo quito el dis, 00:12:56
pues estoy haciendo una tontería. 00:12:59
Si yo quito el dis el compilador ha encantado, 00:13:01
dice a mí que más me da, quítalo si quieres. 00:13:03
Pero entonces ¿qué estaríamos haciendo? 00:13:05
Asignar a esta misma variable su propio valor, 00:13:07
o sea, sentencia estúpida. 00:13:10
A la variable n le asigno n, 00:13:12
estaríamos haciendo un n igual a n. 00:13:14
Y a esta variable le estaríamos asignando su propio valor. 00:13:16
¿Para qué voy a hacer yo esa tontería, n igual a n? 00:13:19
Es que no quiero hacer esa tontería. 00:13:22
Lo que quiero es a la propiedad de la cafetera de arriba 00:13:24
asignarle el contenido de esta variable que lo acabo de leer. 00:13:27
Son dos cosas distintas. 00:13:31
Entonces tengo que distinguirlo. 00:13:33
Así que tendría que poner el dis para que esto tenga sentido. 00:13:35
Este es otro constructor que yo puedo hacer si quiero. 00:13:44
De hecho vamos a ir haciendo el main en paralelo. 00:13:47
Vamos a hacer un main en paralelo para irlo viendo. 00:13:49
Pues nos hacemos una clase aquí con método main. 00:13:56
Y ahora vamos a crear aquí un objeto cafetera con ese constructor. 00:14:00
Lo estoy haciendo para ejemplificar lo otro. 00:14:11
Todavía no estoy haciendo exactamente lo que pide el ejercicio. 00:14:13
Por ejemplo, llamo así. 00:14:21
Vale, pues con esto he distanciado el objeto. 00:14:29
Ahora voy a hacer que se muestren los valores que tienen. 00:14:33
Pues cft punto su capacidad actual. 00:14:41
Vamos a ver, vamos a poner la capacidad máxima es. 00:14:45
Y pongo aquí cft punto capacidad máxima. 00:14:53
Y ahora voy a poner aquí. 00:15:00
La cantidad actual es cf punto cantidad actual. 00:15:09
Este trozo de main tiene sentido. 00:15:30
Es un trozo de main que estoy poniendo para ejemplo solo. 00:15:32
Crea un objeto cafetera, lo creas. 00:15:36
Y ahora me muestra la capacidad máxima de esa cafetera que acabas de crear. 00:15:39
Accediendo a su propiedad capacidad máxima como sabemos acceder. 00:15:44
Y luego muestra la cantidad actual que tiene. 00:15:48
Accediendo a su propiedad cantidad actual. 00:15:50
¿Vale? 00:15:54
Entonces este trozo de main. 00:15:56
Bueno, pues vale, ese trozo de main tiene sentido. 00:16:00
Entonces, ¿qué va a pasar cuando lo ejecutemos? 00:16:03
Se va a crear el objeto en memoria. 00:16:06
Y se va a llamar al constructor. 00:16:09
Bueno, pero ¿el constructor qué hace? 00:16:11
Pues el constructor nos va a pedir esto. 00:16:14
Nos va a pedir los valores. 00:16:19
Y se los va a dar a las propiedades de la cafetera. 00:16:21
Todo eso se va a hacer. 00:16:25
Como consecuencia de la instanciación. 00:16:27
Todo eso. 00:16:29
¿Vale? 00:16:33
Está claro lo que va a pasar, ¿no? 00:16:34
Si hacemos esta ejecución de este main. 00:16:35
Lo ejecutamos. 00:16:40
Y aquí efectivamente está dentro del constructor. 00:16:44
Acaba de llamarlo. 00:16:47
Está dentro de él. 00:16:48
Lo acaba de llamar. 00:16:49
Estamos todavía en esta línea. 00:16:50
Estamos aquí todavía. 00:16:52
Acaba de llamar al constructor y está ahí parado. 00:16:54
Está ahí en el next scene. 00:16:57
Está ahí parado. 00:16:58
¿Vale? 00:16:59
Capacidad actual de esta cafetera. 00:17:00
Venga, esta cafetera tiene 100. 00:17:01
Sigue en el constructor. 00:17:03
Sigue ahí dentro parado. 00:17:04
Sigue ahí. 00:17:06
Ahora está aquí en el next scene. 00:17:07
Sigue ahí. 00:17:08
¿Vale? 00:17:11
La cantidad actual que tiene. 00:17:12
50. 00:17:14
Y ahora efectivamente la cafetera ya se crea. 00:17:15
Con estos valores de las propiedades. 00:17:18
100 y 50. 00:17:20
Y ahora ya me dice la capacidad máxima es 100, 00:17:22
porque 100 es lo que tiene esta propiedad. 00:17:25
Y la cantidad actual es 50. 00:17:28
Bueno, está claro, ¿no? 00:17:32
Pero claro, esto mismo uno le quita el dis 00:17:35
y compila estupendamente, pero deja de tener todo el sentido. 00:17:39
Le quitamos el dis. 00:17:43
¿Vale? 00:17:49
Le quito el dis. 00:17:50
Y ahora hago la pregunta. 00:17:51
¿Vale? 00:17:53
A mi aplicación le he quitado el dis. 00:17:54
Y lo dejo así. 00:17:56
Y ahora hago la pregunta. 00:17:58
Yo voy a volver a ejecutar esto. 00:18:00
Voy a volver a ejecutar este main. 00:18:02
Voy a volver a ejecutarlo. 00:18:04
Va a llamar al constructor. 00:18:07
Entonces, 00:18:10
¿qué me va a salir? 00:18:13
O sea, esto me va a salir, lógicamente, 00:18:14
vea el constructor. 00:18:16
Y aquí, ¿qué me va a salir? 00:18:17
La capacidad máxima es ¿cuánto? 00:18:18
Y la cantidad actual es ¿cuánto? 00:18:20
¿Qué me va a salir? 00:18:22
Cuando yo ejecute el programa ahora con este cambio que he hecho. 00:18:23
Quitando el dis porque me he equivocado y he quitado el dis. 00:18:26
Y he dejado así la sentencia. 00:18:30
¿Qué me va a salir ahí? 00:18:34
Cuando yo lo ejecute. 00:18:37
Venga, que alguien me diga algo. 00:18:42
Cuando yo haga la ejecución, 00:18:46
¿qué número me va a salir aquí y qué número me va a salir ahí? 00:18:50
Con este cambio que he hecho. 00:18:53
¿Qué es este? 00:18:57
He hecho este cambio. 00:18:58
He quitado el dis. 00:18:59
Es el único cambio que he hecho. 00:19:00
Venga, con lo que acabo de explicar me lo tendríais que decir. 00:19:07
¿Qué numeritos me van a salir ahí? 00:19:13
¿Qué numeritos me van a salir ahí? 00:19:16
Efectivamente. 00:19:21
El constructor será invocado. 00:19:23
Estupendo. 00:19:25
Cogerá dos valores y guardará estas variables internas. 00:19:26
Y con estas asignaciones será a esta misma variable a la que asigne su valor. 00:19:30
Es una tontería porque ya lo tenía, pero bueno, se lo vuelve a asignar. 00:19:35
Conclusión, las propiedades de arriba no se han enterado de nada. 00:19:38
Las propiedades de arriba, lo que ha hecho el constructor les ha dado exactamente igual. 00:19:41
Luego, a la hora de mostrarlas, aquí el main cuando las muestra, 00:19:46
va a mostrar los valores que tengan por defecto porque nadie les ha asignado nada. 00:19:51
Y ya hemos dicho varias veces que una variable numérica por defecto, 00:19:57
si no se le asigna nada, Java le asigna al cero. 00:20:01
Y efectivamente, pues es lo que me está diciendo. 00:20:15
Cero, cero. 00:20:18
Luego, obviamente, yo no me equivoco y pongo las cosas como las tengo que poner. 00:20:26
Y esto ya sí. 00:20:34
Entonces diríais, jolín, pues qué ganas de complicar las cosas 00:20:38
llamando a variables internas exactamente igual que a las propiedades. 00:20:42
No las llames igual y así si te olvidas del dis no pasa nada. 00:20:47
Bueno, pero es que hay que hacer las cosas bien. 00:20:51
Es que si esa variable lo que significa es la capacidad máxima de la cafetera 00:20:53
que se llame así, las variables tienen que llamarse con un nombre que signifique lo que son. 00:20:58
Porque eso va a hacer que los demás entiendan el programa. 00:21:05
Entonces si esa variable es la capacidad máxima que yo la quiero meter, 00:21:08
que se llame capacidad máxima. 00:21:11
Coño, qué mala suerte, también se llama capacidad máxima la de arriba. 00:21:13
De mala suerte nada, para eso tienes un dis. 00:21:16
Pero a las variables hay que llamarles con un nombre que explique lo que son. 00:21:19
Que coincide con el de otro, con el de la propiedad. 00:21:23
Bueno, por eso está el dis y por eso el Eclipse te genera los parámetros con el mismo nombre. 00:21:26
Lo genera con el mismo nombre a propósito. 00:21:31
Porque así queda más claro el código. 00:21:33
Vale. 00:21:36
Bueno. 00:21:38
Voy a dejar este constructor, como ya lo tengo aquí hecho, voy a dejarlo porque no molesta. 00:21:40
Pero también dijimos antes de vacaciones que uno puede poner todos los constructores que quiera. 00:21:44
Pero tiene que distinguirlos, ya que no se puede distinguir por el nombre. 00:21:50
Porque el nombre tiene que ser todos el mismo. 00:21:56
El de la clase distingámoslo por los parámetros que recibe. 00:21:58
Bueno, este no recibe ninguno. 00:22:01
Pero puede hacer yo el constructor con parámetros. 00:22:03
Por ejemplo este. 00:22:06
Ah, la tengo. 00:22:10
Le quito el public, que no sé lo que es y lo quito. 00:22:12
Vale, ahora tengo dos constructores. 00:22:15
Bueno, no pasa nada, puedo tener todos los que quiera. 00:22:17
Porque son distinguibles por la lista de parámetros. 00:22:19
Vale, tengo mis dos constructores en esta clase cafetera. 00:22:24
Ya tengo las propiedades. 00:22:27
Los constructores. 00:22:29
Y me falta el resto de métodos. 00:22:32
¿Vale? 00:22:34
Para seguir probando. 00:22:36
Por ejemplo, yo aquí he instanciado una cafetera, la cafetera1, con el primer constructor. 00:22:38
¿Qué quiero hacer otra cafetera? 00:22:43
Pues por ejemplo. 00:22:45
¿Qué quiero hacer otra? 00:22:52
Otro objeto cualquiera. 00:22:54
Pues como ejemplo, vamos a hacerlo usando el otro constructor. 00:22:56
Hay otro constructor que tiene que recibir dos parámetros, ¿no? 00:23:02
Vale, cft1,1. 00:23:07
Bueno, pues voy a pedirlos yo aquí en el programa principal. 00:23:11
Voy a pedir en el programa principal y se los paso. 00:23:14
Sería otra forma de hacerlo, otra forma. 00:23:16
Entonces voy a copiar y pegar esto. 00:23:18
Pongo ahí. 00:23:32
Voy a poner aquí para distinguirlo. 00:23:48
Para la segunda cafetera. 00:23:50
Y ahora voy a mostrar aquí lo que tiene la otra también. 00:24:01
Vale, pues por ejemplo, en este main que estoy haciendo para probar simplemente. 00:24:14
He creado dos objetos cafetera. 00:24:18
La primera y este lo he creado con la primera versión del constructor. 00:24:20
La que dentro de ella pide los valores y se los da las propiedades. 00:24:24
Vale, pues ya está. 00:24:29
Y aquí estoy creando otra cafetera. 00:24:32
Pero con la otra versión del constructor. 00:24:38
Con la versión del constructor que necesita dos valores. 00:24:41
¿Qué es esta versión? 00:24:45
Esta. 00:24:47
Necesita dos valores y coge esos valores para dárselos a las propiedades. 00:24:48
Bueno, puede usar el constructor que quiera. 00:24:53
Aquí estoy usando el otro. 00:24:55
Entonces, esos dos valores los tengo que pedir previamente. 00:24:57
Claro, los pido previamente. 00:25:01
Bueno, pues los he pedido aquí previamente y ahora se los paso. 00:25:03
Bueno, es otra forma, otra forma de hacerlo. 00:25:07
Me da igual. 00:25:09
Voy a ejecutar aquí para crear las dos. 00:25:13
Esta es la primera. 00:25:17
Estamos dentro del constructor. 00:25:18
Pues venga, 120 y tiene 20. 00:25:20
Y ahora, para la segunda. 00:25:24
Esto me lo está pidiendo ahora ya desde el programa principal. 00:25:26
Desde el main. 00:25:28
Esto me lo está pidiendo desde el main. 00:25:29
Pues la segunda creo que tenga 100 y 50. 00:25:31
Ahora ya es cuando llama al constructor. 00:25:34
Y lo único que hace el constructor es coger este 100 y 50 y pasárselo. 00:25:36
Bueno, son diferentes formas de hacerlo. 00:25:40
Lo que importa es que lo entendamos. 00:25:45
Esto de los constructores. 00:25:47
Pero repito. 00:25:49
Este constructor es el constructor habitual que aparece en todas las clases. 00:25:51
Porque es muy útil. 00:25:57
Tú le pasas los valores y los usa para asignárselos a las propiedades. 00:25:59
Y luego los valores, la aplicación ya los recoge como le dé la gana. 00:26:08
Porque este constructor es muy poco útil en realidad. 00:26:13
Este constructor te está obligando a que tengas una consola. 00:26:16
Ahí activa para meterlo por teclado. 00:26:20
Y si la aplicación cambia y tú ya no quieres meter los valores por teclado. 00:26:23
Si no los quieres meter a una interfaz gráfica. 00:26:27
Este constructor no vale para nada. 00:26:29
Tendrías que cambiarlo todo otra vez. 00:26:31
Por eso no se hace así. 00:26:34
Por eso se trabaja con este. 00:26:36
Y que sea el programa principal el que tenga la responsabilidad de recoger esto. 00:26:39
Por interfaz gráfica, por consola, como le dé la gana. 00:26:44
El programa principal que decida como lo recoge. 00:26:48
Se lo pasamos al constructor y el constructor ya lo utiliza. 00:26:51
Porque iros quedando con el concepto de desacoplamiento. 00:27:00
Que es una de las cosas que perseguimos en programación. 00:27:05
Que es que las modificaciones de una clase me afecten lo menos posible a otra. 00:27:08
Hay que hacer aplicaciones lo más desacopladas posibles. 00:27:15
Hay que hacer clases lo más desacopladas posibles. 00:27:19
Entonces, este constructor no sigue el principio de desacoplamiento. 00:27:23
¿Por qué? 00:27:29
Porque si de repente el resto de mis clases cambian y empiezan a utilizar interfaces gráficas. 00:27:30
Me tengo que venir yo a esta clase también y tocarle y decirle consola afuera. 00:27:35
Tengo que meter aquí, coger por interfaz gráfica, ya veremos cómo. 00:27:42
Está muy poco desacoplada. 00:27:45
Si cambio a interfaz gráfica tengo que meterme en esta también. 00:27:48
Este constructor muy mal pensado. 00:27:52
Este muy bien pensado. 00:27:57
Porque que las clases de mi aplicación, las otras cambian y empiezan a trabajar por interfaz gráfica. 00:27:59
A este se le apela. 00:28:04
Dice, me da igual, tú pásame los valores. 00:28:05
Me da igual cómo los hayas recogido. 00:28:07
Yo los voy a coger y se los voy a dar a las propiedades. 00:28:09
Con lo cual, esa clase no hay que tocarla. 00:28:11
Esa clase está desacoplada de las demás. 00:28:13
Entonces, las aplicaciones, una misma aplicación se puede hacer de muchas maneras. 00:28:17
Se puede hacer, admite muchos diseños. 00:28:22
Algunos serán buenos, otros malos y otros peores. 00:28:25
Y solo si hace uno los buenos, pues conserva el trabajo. 00:28:28
No se trata de hacer los que funcionen, sino los que están bien diseñados. 00:28:33
Pues la idea es que las clases estén lo más desacopladas posibles. 00:28:37
Si yo tengo que tocar algo, por favor, eso no implique tener que tocar las demás. 00:28:43
Pues ese es el principio de este constructor. 00:28:49
Bueno, pues importante que os vayáis quedando con todo esto que os digo. 00:28:53
Bueno, pues estamos solo con los constructores por ahora. 00:28:58
Vale, ya está. 00:29:02
¿Alguna duda, pregunta? 00:29:03
Venga, pues seguimos con la clase cafetera. 00:29:07
¿Qué más hay que hacer? 00:29:09
Hemos hecho propiedades. 00:29:10
Hemos hecho constructores. 00:29:11
Estos dos, un poquito pues para explicar todo este rollo. 00:29:13
Hemos hecho estos dos. 00:29:16
Y ahora habrá que hacer métodos. 00:29:19
De nuevo, en un caso real, uno estaría analizando la aplicación y diría, 00:29:23
a ver, el software de mi cafetera necesita llenar, vaciar, 00:29:28
pues yo voy a hacer métodos para todo esto. 00:29:32
Esa parte de análisis ya me la tienen hecha y ya me dicen directamente 00:29:34
los métodos que tengo que programar. 00:29:38
Como ya me los dicen, pues ya nos metemos directamente a programar esos métodos. 00:29:40
Y me dicen que son, este método, este método llenar cafetera, 00:29:45
es el método que se va a invocar cuando le demos al botoncito 00:29:51
de llenar de esa cafetera que tiene ese software dentro. 00:29:54
¿Y este método qué hace? 00:29:57
Pues hace que la cantidad actual de la cafetera se ponga igual 00:30:00
que la capacidad máxima. 00:30:04
Eso es lo que hace llenar, hacer que la cantidad actual 00:30:06
se ponga igual que la capacidad. 00:30:09
Entonces ese método será el que se incorpora cuando le demos al botoncito 00:30:11
y claro, ese software estará conectado a unos sensores, 00:30:15
pues para abrir el compartimiento del café o lo que sea, 00:30:19
pero esa parte ya mecánica de los sensores o electrónica no es nada más igual. 00:30:21
Venga, vamos a hacer ese método, el método llenar cafetera. 00:30:25
Lo primero el nombre, en este caso no hay que elegirlo 00:30:28
porque ya nos lo han elegido el nombre, pues no hay nada que elegir. 00:30:33
Pero lo demás ya sí que hay que programarlo, ¿qué es? 00:30:39
Primero, para hacer lo que ese método tiene que hacer, 00:30:42
necesito pasarle alguna información desde fuera, 00:30:47
es decir, aquí en las interrogaciones tengo que poner algo, 00:30:51
pues vamos a ver, ¿qué tiene que hacer ese método? 00:30:56
Ese método tiene que hacer que la propiedad cantidad actual 00:31:00
se ponga con el valor que tiene la propiedad capacidad máxima, 00:31:06
es lo que tiene que hacer, poner la cantidad actual 00:31:10
al valor que tenga la capacidad máxima, eso es llenar. 00:31:12
Si la capacidad es 100 y la cantidad es 50, 00:31:16
llenar es poner ese 50 a 100, eso es llenar. 00:31:19
Bueno, ¡silencio! 00:31:23
María, vale, pues entonces, ahora ya repito la pregunta, 00:31:26
entendiendo lo que significa ese método, lo que tiene que hacer, 00:31:30
¿necesitamos pasar alguna información desde fuera 00:31:34
para que el método pueda hacer eso? 00:31:38
¿Sí o no? 00:31:45
No, porque el método solo trabaja con las propiedades, 00:31:46
pone ésta con el valor que tenga ésta 00:31:49
y las propiedades ya tiene acceso directo a ellas, 00:31:52
no hay que pasarle ninguna información. 00:31:55
Bueno, pues entonces solo trabaja con las propiedades del objeto, 00:31:58
no trabaja con nada externo, solo con las propiedades, 00:32:02
luego esto vacío porque solo trabaja con las propiedades. 00:32:05
Vale, ¿y qué es lo que tiene que hacer? 00:32:08
Hemos dicho que lo que tiene que hacer es poner la capacidad actual 00:32:11
con el mismo valor que tenga, no, cantidad actual, 00:32:18
cantidad actual con el mismo valor que tenga la capacidad máxima, 00:32:24
eso es lo que tiene que hacer el método, 00:32:29
poner esta propiedad con el mismo valor que tenga ésta, 00:32:32
para que se llene, si tenía 50 se llena a 100, 00:32:36
que es la capacidad máxima o lo que sea. 00:32:40
Ahora la siguiente pregunta para completar la declaración del método es, 00:32:42
¿necesita el método devolver algo al exterior? 00:32:47
¿Sí o no? 00:32:53
No, porque el efecto del método queda reflejado ya en las propiedades, 00:32:57
entonces cuando el método lo único que hace es tocar las propiedades, 00:33:01
ya las propiedades ya se quedan tocadas o modificadas, 00:33:05
ya se quedan tocadas, no hay que sacar nada hacia afuera, 00:33:08
porque ya el método ha tocado las propiedades 00:33:11
y ya se quedan ahí esas propiedades modificadas, 00:33:14
no devuelve ningún valor hacia afuera, 00:33:17
luego ponemos aquí void, 00:33:20
vale y este método está, 00:33:25
¿es necesario poner ahí el dis? 00:33:28
Pues no es necesario porque no hay más variables que se llamen así 00:33:30
aparte de las propiedades, no es necesario, 00:33:34
que lo quiero poner porque queda mucho más bonito 00:33:37
y me gusta más, pues lo pongo porque no molesta, 00:33:42
pero en este caso es opcional, 00:33:47
¿vale? en este caso es opcional, 00:33:49
porque no hay más variables que se llamen en cantidad actual. 00:33:51
Bueno, pues el método de llenar cafetera ya está, 00:33:55
más métodos que hay que programar 00:33:58
para ese software de esa cafetera, 00:34:03
¿qué más tenemos que hacer a través de los botoncitos de esa cafetera? 00:34:05
Servir una taza, 00:34:10
vale, pues servir una taza es, 00:34:12
cuando le damos a ese botoncito, 00:34:14
el compartimento del café se vaciará 00:34:17
con la cantidad que tenga, que ocupe la taza, 00:34:23
si yo le paso una taza de 100 mililitros, 00:34:28
pues la cantidad actual de café tendrá que bajar 100 mililitros, 00:34:31
si le paso una taza de 50, 00:34:36
la cantidad de café bajará en 50, 00:34:38
eso es servir taza, ¿no? 00:34:41
Eso es lo que hace el botoncito cuando le damos, 00:34:44
¿vale? 00:34:48
Si la cantidad actual que tiene es más pequeñita 00:34:50
que la cantidad que yo, 00:34:55
si tiene 50 y le paso una taza de 100, 00:34:58
pues dice, vale, pues sirven los 50, 00:35:00
ya está y te quedas a cero, sirven los 50. 00:35:02
Bueno, pues entonces, 00:35:05
he entendido lo que hace el método, ¿no? 00:35:07
Tendrá que disminuir la cantidad actual, 00:35:09
la tendrá que disminuir en un volumen igual al de la taza que yo le paso, 00:35:11
tendrá que disminuir un volumen igual al de la taza que yo le paso, 00:35:17
porque estoy sirviendo esa taza, 00:35:19
que se queda cero, 00:35:21
antes de completar la taza, pues se queda cero, 00:35:23
no puede servir más, obviamente. 00:35:25
Bueno, pues entonces, programando ese método, 00:35:27
de nuevo el nombre, 00:35:30
no tenemos opción de elegirlo, 00:35:32
porque ya está elegido. 00:35:34
Vale, pues la primera pregunta, 00:35:39
después del nombre, es esta, siempre, es, 00:35:42
a ver, 00:35:46
para poder hacer lo que tiene que hacer el método, 00:35:48
que es disminuir la cantidad actual 00:35:50
de la cafetera en el volumen de la taza, 00:35:54
¿necesito pasarle alguna información a ese método desde fuera? 00:35:59
Sí, ¿qué tenemos que pasarle? 00:36:03
El volumen de la taza, claro, porque servirá más o menos, 00:36:06
bajará más o menos en función del volumen de la taza, 00:36:09
pues aquí hay que pasárselo, 00:36:12
hay que pasárselo sí o sí. 00:36:17
Vale, y ahora ya con eso, ya sabemos lo que hace, 00:36:19
porque lo que hará será, 00:36:22
capacidad actual, 00:36:24
menos igual, 00:36:29
volumen taza, ¿no? 00:36:34
Es decir, restará a la cantidad, no capacidad, 00:36:36
restará a la cantidad actual, 00:36:46
el volumen de la taza que yo le paso, 00:36:49
lo resta, 00:36:50
y la cantidad que se queda, 00:36:52
pues es el resultado de la resta, 00:36:54
esto es lo que hará, ¿no? 00:36:56
Esta es la idea. 00:36:57
Ahora sí, hay un matiz ahí que hay que completar, ¿no? 00:37:01
¿Qué dice el enunciado? 00:37:05
Esto, yo no lo he contemplado, 00:37:12
es decir, si la cantidad actual es 5 00:37:14
y le doy una taza de 100, 00:37:17
el resultado de ese método me dejaría 00:37:18
en cantidad actual, menos 95. 00:37:21
Entonces, esto no es exactamente así, 00:37:27
esto será así, 00:37:30
si esto es mayor o igual que cero, 00:37:32
si es menor que cero, tendría que ser cero, ¿verdad? 00:37:35
Entonces, esto ahora ya uno lo programa como quiera, 00:37:39
con un IF, con una, como quiera, 00:37:41
por ejemplo, 00:37:44
podemos poner cantidad actual, 00:37:46
pues cantidad actual, 00:37:51
depende, 00:37:53
su valor final va a depender 00:37:56
de si cantidad actual es mayor o igual 00:37:58
que volumen taza o no, 00:38:00
depende, 00:38:02
bueno, pues esa es la asignación 00:38:03
condicionada de toda la vida, 00:38:05
cantidad actual es mayor 00:38:07
que volumen taza, 00:38:11
es mayor que volumen taza, 00:38:16
si es mayor, 00:38:18
pues entonces la cantidad actual será, 00:38:20
lo pongo aquí abajo para que se vea, 00:38:22
será cantidad actual, 00:38:24
menos volumen taza, 00:38:27
que no lo es, 00:38:31
pues será cero, 00:38:33
vale, ahora ya sí, 00:38:35
ahora ya sí esto refleja 00:38:37
lo que me dice el enunciado, 00:38:39
que la cantidad es mayor 00:38:42
que el volumen que tengo que llenar, 00:38:43
pues la cantidad se queda 00:38:46
como la que tenía, 00:38:48
menos el volumen que he llenado, 00:38:49
que no es mayor, 00:38:51
porque es más pequeña o igual, 00:38:52
se queda cero, 00:38:53
sirve toda la que hay 00:38:54
y se queda cero, 00:38:55
no se queda en negativo, 00:38:57
porque eso no existe, 00:38:58
se queda cero, 00:38:59
vale, pues esto ya recoge 00:39:01
lo que me dice, 00:39:02
y ahora ya la siguiente pregunta, 00:39:04
de nuevo es lo mismo que antes, 00:39:06
¿tiene que devolver algo 00:39:08
como valor de retorno, 00:39:09
este método? 00:39:10
¿Sí o no? 00:39:12
No, porque el efecto del método 00:39:13
se queda en la propiedad, 00:39:16
el efecto del método 00:39:17
es bajar esa propiedad, 00:39:18
que es una propiedad de la clase, 00:39:20
el efecto del método 00:39:22
ya está ahí en esta propiedad, 00:39:23
no tiene que devolver nada, 00:39:24
pues entonces ahí 00:39:27
pongo otro void, 00:39:29
ala, ya tenemos el otro método, 00:39:33
más métodos, 00:39:41
vaciar, 00:39:42
poner la cantidad de café 00:39:43
a cero, 00:39:44
este es fácil de hacer, 00:39:45
y agregar, 00:39:46
añadir la cantidad de café 00:39:48
pasada como parámetro, 00:39:50
aquí habría que añadir, 00:39:51
si paso más 00:39:53
que la capacidad máxima, 00:39:55
pues la dejo en capacidad máxima, 00:39:57
venga, pues vaciar cafetera 00:40:02
lo podemos hacer rápidamente, 00:40:04
no hay ya ni que pensar, 00:40:08
cafetera, 00:40:11
este, 00:40:14
no necesita ningún parámetro 00:40:16
y lo que hace va 00:40:18
es ponerla a cero, 00:40:20
este no tiene nada, 00:40:23
que perra me ha dado con la 00:40:25
cantidad, 00:40:27
vale, 00:40:28
este tiene poco que pensar, 00:40:30
ponerla a cero, 00:40:31
no necesita ningún parámetro, 00:40:32
y ahora la otra que era 00:40:34
agregar café 00:40:39
a cero, 00:40:42
este si necesita 00:40:47
un parámetro de fuera, 00:40:49
porque este es, 00:40:51
vamos a ver, 00:40:52
¿cuánto café 00:40:54
vas a aumentar la cantidad actual? 00:40:56
¿cuánto lo vas a aumentar? 00:40:58
dime cuánto, 00:40:59
para que yo sepa 00:41:00
cuánto tengo que aumentarla, 00:41:01
dime cuánto, 00:41:02
eso hay que pasárselo desde fuera, 00:41:03
es como servir tazas, 00:41:04
dime cuánto quieres que te dé, 00:41:05
tendrás que decírmelo 00:41:07
para saber yo cuánto te doy, 00:41:08
pues este igual, 00:41:09
dime cuánto quieres meter, 00:41:10
pues habrá que pasarle 00:41:12
ese parámetro, 00:41:14
esa cantidad, 00:41:15
y ahora uno podría hacer así, 00:41:20
cantidad 00:41:22
actual 00:41:25
más igual 00:41:26
cantidad, 00:41:28
vale, 00:41:31
pero pasaría lo de siempre, 00:41:32
que, 00:41:34
cuidado, 00:41:35
si la cantidad resultante 00:41:36
después de hacer la suma 00:41:38
es mayor que capacidad máxima, 00:41:39
es mayor, 00:41:41
entonces 00:41:42
cantidad actual 00:41:43
que sea la capacidad máxima, 00:41:44
el resto ha rebosado, 00:41:45
obviamente, 00:41:46
el resto ha rebosado, 00:41:47
entonces, hombre, 00:41:49
para tener eso en cuenta, 00:41:50
pues cambiémoslo 00:41:51
con una asignación condicionada, 00:41:52
porque lo que asigno 00:41:54
a cantidad actual 00:41:55
va a depender 00:41:56
de si 00:41:57
cantidad 00:41:58
actual 00:42:01
más 00:42:02
la cantidad 00:42:03
es mayor 00:42:04
que la capacidad máxima, 00:42:05
va a depender 00:42:07
de esta condición, 00:42:08
va a depender 00:42:09
de esta condición, 00:42:10
la cantidad actual 00:42:14
más la cantidad 00:42:15
nueva 00:42:16
es mayor 00:42:17
que la capacidad máxima, 00:42:18
entonces, 00:42:20
cuál va a ser 00:42:23
la cantidad actual, 00:42:24
la capacidad máxima, 00:42:25
porque el resto 00:42:27
habrá rebosado, 00:42:28
que no, 00:42:29
pues entonces 00:42:30
ahora ya sí, 00:42:31
que no es mayor, 00:42:32
pues entonces 00:42:33
ahora 00:42:34
será esto, 00:42:35
y ya tenemos 00:42:45
todos los métodos, 00:42:46
cada uno de ellos 00:42:48
es un sensor 00:42:49
que cuando se da, 00:42:51
pues llama 00:42:52
el método 00:42:53
de ese software, 00:42:54
ese software 00:42:55
que cambia las propiedades 00:42:56
y cambiar 00:42:58
las propiedades 00:42:59
ya estará conectado 00:43:00
a unos sensores 00:43:02
electrónicos 00:43:03
para abrir y cerrar 00:43:04
por las puertas 00:43:05
del café, 00:43:06
pero esa parte 00:43:07
ya de los sensores 00:43:08
electrónicos 00:43:09
ya nos da igual, 00:43:10
lo que hacemos 00:43:11
entonces es la parte 00:43:12
del software 00:43:13
de la cafetera, 00:43:14
que lo que hace 00:43:15
es cambiar 00:43:16
las propiedades, 00:43:17
luego ya otra 00:43:18
la parte 00:43:19
electrónica 00:43:20
que es 00:43:21
cuando esas propiedades 00:43:22
cambien 00:43:23
como resultado 00:43:24
de la ejecución 00:43:25
de esos métodos, 00:43:26
cuando cambien 00:43:27
esos sensores 00:43:28
se activarán 00:43:29
para abrir 00:43:30
y cerrar 00:43:31
la entrada 00:43:32
la clase esta 00:43:33
ya está completa, 00:43:34
vale, 00:43:36
tiene este constructor 00:43:37
un poco 00:43:38
bana, 00:43:39
este 00:43:40
más interesante 00:43:41
y los cuatro 00:43:42
métodos 00:43:43
y las propiedades, 00:43:44
vale, 00:43:48
alguna duda 00:43:49
sobre esta clase, 00:43:50
entonces como este software 00:43:51
solo trabaja 00:43:52
con la entidad cafetera 00:43:53
ya no le hace falta 00:43:54
más clases, 00:43:55
ahora ya la principal, 00:43:56
la principal 00:43:57
que es la que 00:43:58
se ejecuta 00:43:59
y la que instancia 00:44:00
la cafetera, 00:44:01
vale, 00:44:02
vamos a parar aquí 00:44:03
un momentín. 00:44:04
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
5
Fecha:
8 de enero de 2024 - 12:43
Visibilidad:
Público
Centro:
IES ROSA CHACEL
Relación de aspecto:
1.78:1
Resolución:
1280x720 píxeles
Tamaño:
840.09 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid