Saltar navegación

2024-12-16-Programacion - 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 16 de diciembre de 2024 por Jose Manuel M.

24 visualizaciones

Tarea tema 4

Más información Transcripción

Descargar la transcripción

comparto pantalla ahí está y bueno si no tenéis ninguna cosa en particular pues para cerrar un 00:00:04
poco el tema el tema 2 pues se me había ocurrido el tema 2 el tema 4 se me había ocurrido que 00:00:22
podíamos hacer la tarea si no tenéis ninguna cosita así en particular que queráis que veamos 00:00:29
aunque tenéis una solución propuesta por lo hacemos poco a poco y así vamos comentando 00:00:36
toda la jugada 00:00:40
bueno, mirad, aquí tenemos el enunciado 00:00:42
hacemos una lectura 00:00:52
rápida de él 00:00:54
nos pone en contexto 00:00:56
que una cadena de restaurante 00:00:58
necesita un programa para registrar 00:01:00
los alimentos domésticos que tienen sus cocinas 00:01:02
dice que 00:01:04
una cocina puede tener un frigorífico 00:01:06
y una placa de inducción 00:01:08
ambas cosas 00:01:09
una de las dos o ninguna de ellas 00:01:12
bueno, pues un poco 00:01:14
para identificar lo que sería un diseño previo a hacer el ejercicio pues bueno pues proponemos 00:01:17
que existan al menos tres clases bueno pues en realidad muchos de vosotros habéis resuelto la 00:01:23
tarea con una cuarta que es perfectamente correcto que sería la que inicia el programa para luego ir 00:01:30
instanciando objetos de cada una de estas tres clases identificados los tres actores digamos 00:01:35
El término actor está un poco relacionado con la programación orientada a objetos en la parte de diseño y probablemente os aparecerá este término si veis la asignatura de entornos de desarrollo. 00:01:43
Para los que participan en un programa se les puede llegar a denominar actores, como si formaran parte de una película que fuese nuestro programa o de una obra de teatro. 00:01:56
entonces lo que correspondería a la hora de hacer el diseño sería para cada una de las clases 00:02:05
identificar qué es aquello significativo para esa clase dentro del programa 00:02:13
entonces el enunciado dice que tendrá las siguientes características que son aquellos parámetros 00:02:17
que más o menos podemos identificar como importantes a la hora de definir la clase cocina 00:02:24
que sería un nombre, pues el nombre lo guardaremos en una variable tipo string 00:02:30
un frigorífico, que lo que haremos será construir un atributo, parámetro de la clase cocina de tipo clase frigorífico, una placa, la misma forma que el frigorífico, pues crearemos un atributo para la placa, luego existirá o no existirá, primero podemos definir como parámetro de clase la referencia y luego hacer, reservar los recursos a través del new y el constructor del frigorífico y la placa, 00:02:34
caso de que se nos pida, ¿no? Y luego, bueno, pues para aquí 00:03:04
os proponía en el enunciado que hubiese un par 00:03:08
de booleans, por ejemplo, aquí no aparece, aquí, sería 00:03:12
lo que sería el indicador, los booleans que nos indiquen si hay o no hay frigorífico. 00:03:18
Y esto sería las referencias a frigorífico y a la placa. Y luego, bueno, para que 00:03:22
os resultase un poco más fácil el ejercicio, como todavía no nos hemos 00:03:28
metido muy, muy de lleno todavía a programar, pues en lo que es 00:03:32
el enunciado pues os proponía aparte de los parámetros pues al menos los métodos que se me 00:03:36
ocurría que pudieran tener no para enfocarlo y que el ejercicio esté de acuerdo a lo que más o menos 00:03:42
hemos visto como contenidos en este tema entonces que tuviese un método aquí que lo que haga es 00:03:48
informar de exactamente qué componentes tiene esa cocina en particular junto con su nombre con este 00:03:55
tipo de mensaje. Y en lugar de hacer aquí 00:04:03
el system.out.println, pues os 00:04:07
pedía que, pues para 00:04:09
gestionar un poco lo que es el return y todo 00:04:10
esto, que no fuese un método 00:04:13
que devolviese un void, sino un string para 00:04:14
construir el string que devuelve y el 00:04:17
mensaje en sí se pusiera en el main, me parece 00:04:19
recordar que decía por aquí. Luego, bueno, 00:04:21
la clase frigorífico es 00:04:25
un getter y un setter, que también 00:04:27
hemos hablado de ellos, 00:04:28
relaciona al único parámetro que 00:04:31
tiene, que es el de marca, que será un string. 00:04:33
Como tenemos los 00:04:36
getter y los setter, lo que vamos a hacer luego va a ser poner este parámetro que sea de acceso 00:04:37
privado para que a la hora de informar a este parámetro de su valor o a la hora de recoger su 00:04:43
información, obligarnos a utilizar los getter y los setter. Y bueno, pues nada, en la placa, pues otro 00:04:50
de los elementos de los que hemos hablado durante el ejercicio, pues el constructor, un método 00:04:57
constructor y un getter y un setter para el color y en este caso el color en lugar de pedirse por 00:05:03
teclado lo que hacíamos era solicitar el color a través de de forma aleatoria entre tres posibles 00:05:08
colores para que fuese azul marrón o verde en un mismo porcentaje de posibilidades y luego aquí 00:05:15
una secuencia de cómo podría el programa pues nada se solicita el nombre de la cocina para informar 00:05:23
a este parámetro de la clase cocina se dice si hay frigorífico en el frigorífico y en caso de 00:05:28
que haya frigorífico pues aplica hacemos unión a la referencia que tenemos como parámetro de clase 00:05:35
del frigorífico si resulta que el frigorífico tenemos que recuperar su marca la cogemos por 00:05:41
teclado y esa marca será la que asignaremos a través del setter aquí en el frigorífico con 00:05:50
el set marca, y luego la placa 00:05:59
un poco la misma idea 00:06:02
lo único que el color en sí no se lo pedimos 00:06:03
por teclado, sino que se carga 00:06:06
de forma aleatoria en el constructor 00:06:08
de la cocina, lo decimos por aquí 00:06:10
fijaros, el constructor 00:06:12
llama setColor 00:06:14
y luego para concluir, pues lo que hacemos es 00:06:15
llamar al método informo para que nos diga 00:06:18
cómo ha ido la cocina 00:06:20
hoy el tiempo es un poco más escaso, como solo 00:06:22
tenemos una hora, pues a ver si nos da tiempo a completar 00:06:26
el ejercicio, y si nos da tiempo 00:06:28
pues jugamos un poco con 00:06:30
la etiqueta static de nuevo 00:06:32
que ya le hemos comentado en varias ocasiones 00:06:35
y bueno, tenemos abierta 00:06:37
alguna pregunta ahí en el foro 00:06:39
en relación a esto, pues si nos da tiempo lo vemos 00:06:41
y si no ya retomaremos 00:06:43
en algún otro momento esta etiqueta 00:06:44
durante el siguiente tema con seguridad 00:06:46
Pues vale, vamos a 00:06:49
ponernos en marcha 00:06:51
con el ejercicio 00:06:55
os voy contando un poquito 00:06:56
rápido, a ver si nos da tiempo a acabar el ejercicio 00:07:04
repasando 00:07:08
parando un poquito en cada en diferentes conceptos de los que hemos ido viendo en el tema pero si 00:07:10
tenéis cualquier duda pues pararme al final estas tutorías más que para ver de mario avanzado es 00:07:15
para resolver posibles tutorías que tengáis unos cortes en avisarme si alguna cosilla no se entiende 00:07:21
bien ahora por aquí del ejercicio con el que estuvimos trabajando el último día creamos un 00:07:31
un proyecto, un proyecto Java, que podemos llamar, vamos a llamarlo restaurante, voy a eliminar el módulo este, 00:07:41
como hago siempre, y vamos a crear, vamos a construir el ejercicio en base a cuatro clases, entonces, 00:08:00
vamos a crear una primera clase restaurante, básicamente para que tenga el main, fijaros, en lugar de andar 00:08:08
escribiéndolo luego, voy a poner aquí que me integre el código main, que me da 00:08:17
la opción Eclipse y aquí tenemos restaurante. Luego tenemos tres clases 00:08:21
más, la clase cocina, la clase frigorífico y la clase placa. En la clase 00:08:30
restaurante podríamos, el ejercicio está planteado para que haya, entendemos 00:09:00
un solo restaurante que tiene una única cocina y la cocina tiene la 00:09:08
posibilidad de tener o no tener placa o no tener frigorífico o en caso de tener alguna de las dos 00:09:13
o ambas solamente una de cada de cada clase no permiten tener varias cocinas o no lo propone 00:09:18
así el ejercicio entonces podríamos decir que bueno pues el restaurante que caracteriza a la 00:09:24
hora de definir los parámetros que tiene una clase pues aquí java nos permite definir cualquier cosa 00:09:31
imaginaros que pusiéramos aquí un int y esto en realidad es una variable que luego utilizamos 00:09:38
aquí para ir trabajando sobre un bucle pues esto lo permitiría como y lo ponemos a esta altura sería 00:09:42
del ámbito de la clase en su conjunto pues y estaría disponible aquí compilaría el programa 00:09:48
si funcionaría así pero sería muy correcto poner una variable y que en realidad podríamos querer 00:09:54
para un bucle dentro del main pues no mucho porque aparte de que de buscar que los programas 00:10:01
nos funcionen en sí, tenemos que, estamos intentando dar respuesta 00:10:07
a una funcionalidad y los parámetros de clase en la programación 00:10:12
orientada a objetos, tenemos que pensarlos como aquellas cosas 00:10:16
que son características del restaurante, no definirlas de forma 00:10:20
que nos permita que el programa nos compile en sí. 00:10:25
Lógicamente el programa finalmente tendrá que compilar, pero esta variable 00:10:28
y desistir, que no va a ser el caso, si fuese una variable para 00:10:31
trabajo intermedio dentro del método main, pues habría que definirla aquí y no aquí como parámetro 00:10:35
de clase, ya que no es algo que caracteriza a los restaurantes. En este ejercicio, ¿podríamos 00:10:39
entender que la cocina podría ser una característica del restaurante? Bueno, pues podríamos 00:10:45
entenderlo. Podría tener el restaurante, si el enunciado lo pidiese, unas dimensiones para 00:10:52
expresar los metros cuadrados, una cocina, una sala donde están las mesas, estas cosas sí pueden 00:10:57
caracterizar al restaurante, una variable por ejemplo de este tipo. La cocina, pues sí podría 00:11:06
ser, ponemos cocina, mi cocina. Aquí tenemos una referencia a una cocina, será una referencia que 00:11:12
todavía no es un objeto activado, a un tipo de datos, que no es un tipo de datos primitivo, es un tipo de datos referenciado 00:11:24
y corresponde a una de las clases que luego vamos a desarrollar aquí nosotros en nuestro programa, que es la clase cocina. 00:11:31
Bueno, pues aquí entonces, en realidad esto todavía es una referencia, podríamos coger y decir aquí, vamos a instanciar la cocina, 00:11:42
con toda seguridad va a haber una cocina en el ejercicio pero aquí igual año cocina y con esta 00:11:51
jugada a ver si claro es cierto al estar fuera del min debería ser estático vale vamos a vamos 00:12:01
a repasar esto mirad imaginaos que tenemos un método public public mostrar nombre de él 00:12:29
por ejemplo el nombre del restaurante si yo cojo y pongo aquí esto fijaros que aquí se me compila 00:12:42
pero aquí no que es justo lo que lo que se refiere es alguien alguien me estaba diciendo para la 00:12:51
grabación que si no debería ser estático a la hora de definirlo aquí qué es lo que sucede main es un 00:12:58
método que es estático entonces cuando se está ejecutando main para cualquier método estático 00:13:06
main es un poco más especial al referirse a al referirse al método que por el que entramos en 00:13:12
el programa pero cuando nosotros cogemos y utilizamos un método como estático bien sea 00:13:22
main o no sea main este método es común a todos los posibles objetos que pertenecen a la clase 00:13:28
restaurante. Como mi cocina es un parámetro que no lo hemos definido estático, cada uno de los 00:13:34
restaurantes que pudiéramos definir en nuestro programa en línea general tendrían un mi cocina 00:13:42
y como este método main sí que es estático, es el mismo método, el mismo código el que se 00:13:47
ejecutará para absolutamente todos los restaurantes. Si tuviéramos en nuestro programa instanciados 00:13:55
cuatro restaurantes en otras clases que sucedería que todos ellos utilizarían el mismo main y 00:14:00
cualquiera de ellos podría ejecutar el método main de los cuatro restaurantes cada uno tendría 00:14:06
su propia cocina entonces si cada uno tiene su propia cocina no sabríamos a qué cocina nos 00:14:13
estamos refiriendo a cuál de las cuatro entonces desde un método que es estático no podemos hacer 00:14:19
referencia a parámetros que no sean estáticos por este motivo porque no está claro a que mi cocina 00:14:25
a cual de todos los posibles restaurantes que utilicen el main estarán refiriéndose a la hora 00:14:36
de utilizar la variable mi cocina entonces se solucionaría poniendo este como static para que 00:14:42
compile, pero ahora habría que ver si en el contexto del ejercicio me interesaría que todo restaurante 00:14:49
tuviese la misma cocina, porque esto tiene sus connotaciones, claro. El hecho de definir mi cocina 00:15:00
como estático implica que si en el ejercicio hubiese cinco restaurantes, los cinco restaurantes 00:15:05
estarían compartiendo la misma cocina porque lo hemos definido como estático. Si así fuese, estaría 00:15:12
correctamente bien definido de esta forma y nos permitiría permitiría utilizarlo aquí nos 00:15:19
compilaría si el enunciado del ejercicio dice que la diferente restaurantes cada uno tiene su cocina 00:15:25
entonces esto no lo podríamos definir ya estático por porque el requisito del ejercicio no nos lo 00:15:33
permite y ya no nos compilaría aquí ya que el main es un método común en este caso si quisiéramos 00:15:39
dentro trabajar con un objeto propio de la cocina tendríamos que definir la variable no como una 00:15:47
variable de clase que fuese que tuviese cada uno de los restaurantes una cocina sino como una 00:15:54
variable local al mail aquí podríamos poner cocina y entonces pues ya si me compilaría aquí ya habría 00:16:00
ambigüedades no sea el restaurante que sea cuando llame al main aunque sea común la cocina a la que 00:16:08
se refiere es esta que está definida aquí como local y no está y no a este parámetro de clase 00:16:14
que sería una diferente para cada uno de los restaurantes vamos a dejarlo así es cierto lo 00:16:21
que comentaba veis para que me compilase en el main tendría que haber sido así cosa diferente 00:16:29
es si tenemos un método que no es estático dentro del restaurante si yo pongo aquí un método que no 00:16:34
es estático, public void, mi nombre vamos a poner, por poner un nombre 00:16:39
el que sea, si yo ahora pongo aquí una cocina que es un parámetro 00:16:45
de clase de cualquiera de los restaurantes, si hay cinco restaurantes 00:16:57
cada restaurante tendrá su parámetro mi cocina, si yo en un método 00:17:00
como mi nombre que no es estático, al contrario de main, ahora yo pongo 00:17:06
aquí mi cocina, punto, lo que sea, mi cocina igual a new cocina. Este sí me compila. ¿Y por qué me compila? 00:17:11
Porque este método, al no ser estático, cada restaurante ejecutará, digamos, una copia de este 00:17:22
método. Y cuando esté un restaurante, el restaurante 1, ejecutando el método mi nombre, método 00:17:28
perteneciente a la clase restaurante para el restaurante 1, ejecutando mi nombre, como es el 00:17:33
restaurante1, el que está ejecutando mi nombre, sin lugar a dudas, mi cocina que utiliza es mi 00:17:39
cocina del restaurante1. Entonces, en este caso, me compila, pero desde un método que es estático, 00:17:45
no puedo utilizar una variable sin identificarla perfectamente, que no sea estática, porque ante 00:17:55
la posibilidad de que existan diferentes restaurantes, no sabría cuál de ellos, que mi 00:18:03
cocina utilizar, la cocina de qué restaurante, si del restaurante 1, del 2, del 3, del 4 00:18:09
o del 5. Dicho esto, cuando 00:18:13
hagamos el programa no hay que poner esto estático para que me compile 00:18:17
si es que lo quiero utilizar aquí en el main o dejarlo sin que sea estático 00:18:21
porque me compila en algún otro sitio. La definición del parámetro tiene que ser 00:18:25
acorde a diferentes restaurantes compartirán la misma 00:18:29
cocina, si es que sí, estático. Diferentes 00:18:33
¿Qué restaurantes compartirán la misma cocina? No, pues entonces no es estática para que cada uno de los restaurantes que instanciemos tenga su propia cocina. 00:18:37
¿No se respondía a tu pregunta? ¿Alguien que preguntaba por ahí que si tenía que ser estático? Sí. Vale. Bueno, pues continuamos entonces. 00:18:50
Entonces, fijaos, instanciamos un objeto de la cocina con un constructor. Vamos un momentito a la cocina, luego vamos retomando el mail. La cocina, ¿qué es lo que tiene que tener? Pues hemos dicho que tiene un nombre, cosas que caracterizan a la cocina, que son variables que de verdad son propias de una cocina en este ejercicio. 00:19:09
Pues tendrá un nombre, tendrá un indicador de si tiene frigorífico o no, un indicador de si tiene placa, tendrá un frigorífico, tendrá una placa. 00:19:28
Todos estos atributos, si los dejamos así, sin ninguna etiqueta extra de public, private y todo esto, tienen alcance de paquete. 00:20:03
lo suyo en verdad es 00:20:11
trabajar con ellos de forma privada 00:20:14
en líneas generales 00:20:17
y que los accesos los hagamos 00:20:22
a través de getters y setters 00:20:26
igual nos puede resultar un poco 00:20:28
incómodo el tener esto privado 00:20:39
luego lo hacemos desde el principio 00:20:41
con privados, ahora podríamos construir los getters 00:20:45
y los setters, vamos a apoyarnos en 00:20:50
en los ides, Eclipse, también NetBeans nos proporciona esa opción, otros ides casi con toda seguridad, de generar getters y setters, que él nos cree en los bloques de código, entonces vamos a decirle que nos cree getters y setters para todos y los mantenemos de forma privada, vemos aquí que los genere y por aquí nos aparecen todos, voy a ponerlos aquí abajo, me gusta más tener los parámetros aquí en esta parte de arriba, vale, pues ya tenemos la cocina, 00:20:52
la cocina además tiene la placa en el frigorífico hemos dicho que tiene la posibilidad de tener una 00:21:28
marca que es un string entonces aquí un string ese color igual que antes tendría alcance de 00:21:37
paquetes si no decimos nada público si ponemos public protect y también son etiquetas que hemos 00:21:48
visto en este tema vamos a ponerlo privado privado recordad que solamente permite el acceso desde la 00:21:56
propia clase a la variable al parámetro el hecho de que sea privado si hacemos un getter y un setter 00:22:03
como está en la misma clase pues tendrán acceso al parámetro vamos a crear también un getter y 00:22:10
un setter por aquí en este caso de la clase el frigorífico no es color el frigorífico es marca 00:22:17
el color creo que es en la placa 00:22:26
todos los efectos da igual pero vamos a ponerlo bien 00:22:31
a ver, no sé que me está pasando aquí 00:22:35
vale, pues ya está, no lo había salvado 00:22:52
yo creo, y bueno 00:23:04
y la placa 00:23:07
pues tiene 00:23:07
el color y vamos a hacer la misma 00:23:10
jugada, lo generamos 00:23:22
y lo vamos a poner privado 00:23:24
la placa también tiene un 00:23:25
constructor, acordaros, los constructores 00:23:35
no devuelven nada 00:23:37
al contrario por ejemplo que 00:23:38
el get, el getter que sí que devuelve un string, los constructores no devuelven nada 00:23:40
pero nos indica convoy. Los métodos por convenio suelen 00:23:45
empezar por letra minúscula si tienen varias palabras 00:23:50
las siguientes palabras, primera de las letras en mayúscula 00:23:54
con excepción de los constructores 00:23:59
que la primera letra directamente es mayúscula porque como 00:24:03
están obligados a llamarse como la clase y el convenio para las clases es que empiecen con mayúscula 00:24:07
pues no nos queda más remedio que bien romper la norma de que las clases 00:24:11
se empiecen por mayúscula o la de que los métodos empiecen por minúscula 00:24:15
al tener que ser iguales, bueno pues aquí tenemos el constructor, ¿por qué nos 00:24:19
interesa tener un constructor? bueno pues porque tenemos que llamar 00:24:26
a setColor para que nos aplique un color que sea aleatorio 00:24:30
a el setColor de la placa, entonces aquí lo que 00:24:34
vamos a hacer va a ser llamar al método setColor 00:24:38
En realidad vamos a hacer una sobrecarga de este método porque justo el setColor tradicional lo que suele hacer es copiar el que recibe como parámetro, se lo copia a la variable de clase, el setColor. 00:24:42
Pero justo este set color no recibe la información desde fuera, sino que la completa a partir de un número aleatorio, porque podrá ser o bien los colores azul, marrón o verde, yo creo que era, azul, marrón o verde en igual proporción. 00:25:00
¿Cómo podemos hacer que sea en igual proporción y que sea aleatorio? Disponemos de dos clases en la librería de Java para calcular números aleatorios. Una que está en la clase math con el método random que devuelve un double entre 0 y 1. 00:25:20
y otro que está en la clase 00:25:42
random, bueno, por ahí tenemos 00:25:46
en java.util.random, habría que integrarlo, es otra de las 00:25:53
opciones y también nos devuelve números aleatorios 00:25:56
la clase random, su propio nombre lo indica 00:25:58
y como método también integrado entre la clase 00:26:02
mat, si esto nos devuelve un valor entre 0 y 1 00:26:05
una posibilidad que tenemos, bueno, pues sería 00:26:08
como nos devuelve un double 00:26:14
mi color, vamos a poner aquí 00:26:16
de color, cogemos 00:26:21
un valor entre 0 y 1 con decimales 00:26:27
y en igual proporción más o menos 00:26:29
seríamos a un 0,3 00:26:33
periodo del 3, ¿verdad? 00:26:35
Para ir entre 0 y 0,3 00:26:37
el 33% de las posibilidades 00:26:39
que nos devolvería el 00:26:42
más random, entre 0,33 00:26:43
y 0,66 con el 6 00:26:45
de nuevo periodo hasta donde 00:26:47
queramos llegar y luego para completar 00:26:49
desde el 0,66 una tercera parte 00:26:51
hasta la unidad, que es lo que nos devuelve random. 00:26:53
Entonces aquí podríamos coger y definir, para ahora hacer las comparaciones aquí, 00:26:57
podríamos definir unas constantes, recordar que se definen parecido a las variables, 00:27:03
en este caso nos interesa, ya que vamos a hacer una comparación con un double 00:27:12
que nos está devolviendo el random, que sean variables de ese tipo, 00:27:17
Vamos a definir la private también aquí. Double. Y vamos a definirla un tercio. Vamos a decir que sea igual a cero. Bueno, aquí podríamos poner tres en los que quisiéramos, ¿verdad? Vamos a poner esos. En realidad es tres periodo. Y luego podríamos decir dos tercios aquí. Dos tercios. 00:27:20
directamente con esta variable ya nos valdría para que nos funcionase pero resulta que esto no son 00:27:45
variables son constantes no vamos a querer que durante el programa esto vaya cambiando entonces 00:27:53
para convertir una variable en una constante que la implicación que tiene es que luego su valor no 00:27:58
pueda cambiarse a lo largo del código podemos poner la etiqueta final y esto convierte ya esta variable 00:28:03
en una constante. 00:28:10
Entonces ponemos final a las dos, 00:28:12
ya tenemos ahí dos constantes, una al valor 00:28:14
fijo de un tercio y otra 00:28:16
al valor fijo de 00:28:18
dos tercios. 00:28:19
Y las constantes 00:28:22
tenemos por convenio, igual que hablábamos 00:28:23
de los métodos y las 00:28:28
clases, que las clases su primera 00:28:29
letra era mayúscula, los métodos empezaban 00:28:32
con una letra minúscula, 00:28:34
para que luego al identificar por ahí 00:28:36
una constante en el código 00:28:37
tengamos directamente la idea 00:28:39
de que efectivamente es una constante las definimos con letras mayúsculas así un tercio 00:28:41
aquí ponemos bien pues nada aquí cada vez que llamemos a set color más rando nos devolverá un 00:28:47
valor entre 0 y 1 principio al ser aleatorio entendemos que la librería estará bien programada 00:29:05
y no lo devolverán en las mismas proporciones no según el número de llamadas con la misma 00:29:10
probabilidad es una posibilidad que tenemos aquí es decir y hay alternativas para gestionar cómo 00:29:15
hacerlo esto si nos da tiempo vemos por ejemplo cómo lo podemos gestionar con un array y decir 00:29:22
si el color es menor el color no el número que nos devuelve el random para determinar el color 00:29:27
es menor a un tercio, entendemos que la diosa fortuna ha querido que el color de esa placa sea azul. 00:29:35
Aquí hicimos el shift, si es menor que dos tercios, recordad que los shifts son autoexcluyentes, 00:29:55
si entra por un tercio, lógicamente también es menor que dos tercios, pero como if el shift es autoexcluyente, 00:30:07
en el momento en que fuese menor de 0,33, este ya no se valoraría. 00:30:13
Con dos tercios podemos hablar de que sea marrón 00:30:21
y en caso de no ser ni uno ni otro, pues decimos que sea verde. 00:30:23
¿En qué caso asignamos un color? Pues vamos a asignar un color en el caso 00:30:39
en el que llamemos que exista una placa. Si existe una placa 00:30:42
como haremos el new y llamaremos al constructor, desde el propio 00:30:48
constructor que se encarga de inicializar los objetos, pues nos 00:30:51
interesa que esa placa tenga un color pues ese color llamamos al método set color y el set color 00:30:56
ya está asignando a la variable de clase el color con el que va a trabajar mientras ese objeto viva 00:31:01
mientras esté activo en el programa el ojo la clase placa prácticamente la tenemos ahí la clase 00:31:06
frigorífico yo creo que prácticamente lo tenemos aquí y ahora pues la clase restaurante bueno pues 00:31:17
Aquí tenemos el inicio y la clase cocina nos queda por implementar el método que informe de sus características. 00:31:26
Después lo hacemos. Vamos a ir avanzando aquí. Cuando lo necesitemos ya lo atacamos. 00:31:41
El ejercicio nos decía que lo primero que hace el programa es solicitar por teclado la cocina. 00:31:48
Ahora, para acceder a información recibida desde el teclado, recordad, tenemos que acceder al flujo de datos SystemIn. El flujo de datos SystemIn tiene la posibilidad de leer desde aquí, fijaros, read, o sea, directamente desde SystemIn seríamos capaces de leer información desde el teclado. 00:31:54
recordad que el teclado está directamente en todo programa asociado al flujo de datos system in pero 00:32:13
bueno la forma de trabajar digamos con desde el código los métodos que tiene system in es un poco 00:32:23
más incómoda que si nos apoyamos en otra librería que tenemos en la en java que ya conocemos que la 00:32:29
clase escáner la clase escáner lo que hace es nos facilita trabajar con flujos de datos con 00:32:36
¿Con qué flujo de datos? Con el que indiquemos aquí. Este flujo de datos podrá ser un fichero, si identificamos aquí un fichero, 00:32:46
podrá ser una conexión con un socket. Un día hablábamos un poquito de los sockets, aunque trabajaréis con ellos más el año que viene 00:32:54
en otra de las asignaturas. Y otro de los flujos de datos, que es el que en el 99% utilizamos para inyectar información en el objeto 00:33:01
de la clase Scanner es precisamente el Sistening, que decimos que está asociado al teclado. 00:33:12
Mi programa permite compilar directamente sin importar nada, sin hacer importaciones de otras clases, 00:33:19
con cosas que están en mi propio paquete, con aquellas clases que tenemos disponibles desde la librería 00:33:29
java lang por ejemplo si éste existe en out verdad si ponemos aquí un sistema out print ln directamente 00:33:39
esto me compila porque esto está en las librerías java lang toda la librería java lang está integrada 00:33:53
directamente en todo programa pero lo que no está en java lang ni pertenezca directamente a mi 00:33:59
estructura de clases en mi paquete pues para que sepa dónde localizarlas tenemos que importar las 00:34:05
dónde está la clase en qué librería está de las dejaba está la clase escáner en la java útil le 00:34:11
decimos aquí metemos el import correspondiente en la cabecera y ya lo tenemos ahí disponible 00:34:18
nuestro programa aquí en el main cuando termine el main se termina nuestro programa y se liberan 00:34:23
los recursos pero podría ser que utilizásemos un escáner en un método que no fuese el main de ese 00:34:32
programa siguiese funcionando entonces para dejar bien cerradito los flujos de datos es conveniente 00:34:38
que todo flujo de datos que abramos aquí estamos abriendo un flujo de datos en system in lo cerremos 00:34:44
una vez terminemos de trabajar con él entonces vamos a poner aquí abajo un close es especialmente 00:34:50
preocupante esto no porque como se acaba el programa al finalizar el main se cerraría en 00:34:57
cualquier caso pero bueno siempre queda mejor ahí no nos pide el nombre en primer lugar toda cocina 00:35:01
va a tener un nombre, no hay lugar a dudas, pues ya 00:35:08
está, aquí vamos a poner un system out 00:35:10
para coger 00:35:12
por teclado el nombre, en primer lugar 00:35:14
nos lo vamos a pedir 00:35:16
por consola, entonces 00:35:17
indica el nombre 00:35:19
de la cocina 00:35:21
y ahora lo que hacemos es 00:35:23
cargar ese nombre, ¿dónde vamos a cargar el nombre? 00:35:27
pues tenemos una variable 00:35:30
para 00:35:31
guardar el nombre de la cocina 00:35:34
aquí en cocina, ese nombre 00:35:35
este atributo recordad que es privado es un string privado en la cocina entonces tenemos aquí una 00:35:37
cocina que hemos instanciado y queremos guardar en esta cocina en su nombre el nombre de la cocina 00:35:46
con la que vamos a trabajar entonces decimos mi cocina lo primero lo primero que nos apetecería 00:35:51
poner es poner aquí después de mi cocina pues el parámetro del nombre ese nombre pero no me 00:36:03
ofrece como parámetro porque no me lo ofrece el ide porque es privado no está al alcance solamente 00:36:13
está al alcance de la propia clase cocina el perdonaje me quedé callado es que están son está 00:36:18
sonando por megafonía y no sé si hay un aviso de desalojo o algo de eso supongo que no bueno 00:36:26
entonces para acceder a la cocina vamos a utilizar el setter de este parámetro se nombre verdad set 00:36:32
nombre y el nombre en sí se lo asignamos como parámetro aquí recordad este parámetro lo que 00:36:42
hace es como variable local al métodos en nombre en este ámbito fijaros como al marcarlos identifican 00:36:50
los dos se ponen los dos en negrita se lo aplica al a la variable que tiene justo el mismo nombre 00:36:56
pero anteponiendo el 10 lo cual quiere decir que se refiere a la variable de clase fijaros 00:37:02
en este otro caso pues ahora vamos a ponerle el nombre que cogemos desde escáner te vamos a poner 00:37:07
aquí vamos a poner que un string ese aus una variable auxiliar string podemos poner aquí esto 00:37:24
que sea igual a mi scan punto netline cogemos el nombre de la cocina se aplica ese aus y ahora ese 00:37:32
aus lo ponemos aquí fijaros estas dos instrucciones bueno pues ahora está bien que las pongáis juntas 00:37:41
luego ya con el tiempo pues intentaréis compactar código porque resultará probablemente más cómodo 00:37:50
más cómodo y que podríamos hacer pues fijaros podríamos hacer sustituir estas dos líneas ahora 00:37:55
el momento que pongáis las dos líneas yo creo que hasta os resulta útil para para que se entienda 00:38:02
mejor aquí lo que hacemos es que lo que cogemos desde tecla desde este teclado lo cargamos en una 00:38:07
variable y luego a esta variable con el setter le aplicamos lo que tiene la variable que anteriormente 00:38:13
hemos cogido por teclado podríamos integrar esas dos líneas y ponerlo así aplicamos al nombre de 00:38:21
la cocina con el setter lo que cogemos por teclado estas dos líneas en dos pasos serían equivalentes 00:38:32
a esta a continuación por aquí nos dice nada nos va a dar tiempo a terminar son las 8 y 10 ya pero 00:38:38
Bueno, solicita por el teclado si hay frigorífico en la cocina. 00:38:49
Y conocido este dato, se hace el new del frigorífico. 00:38:53
Pues nada, vamos a ver si hay frigorífico. 00:38:58
Decimos system out, println, hay frigorífico. 00:39:00
Vamos a decirle que nos diga sí o no. 00:39:16
No recuerdo si exactamente es como lo dice el enunciado. 00:39:18
Pues nada, ante la pregunta de si hay frigorífico, 00:39:21
lo cogemos desde el teclado. 00:39:24
Aquí recuperaremos un sí o un no. 00:39:30
aquí podríamos meter alguno lo habéis hecho ya para proteger que éste sea así o no podríamos 00:39:31
meter un bucle mientras sea diferente así o no sigue pidiendo vamos a entender que el dato se 00:39:37
mete correctamente o si no es sí y metes cualquier otra cosa es no vale sí otro día retomamos el 00:39:43
ejercicio lo afinamos un poquito más entonces qué haríamos comprobaríamos sí lo que acabo de recibir 00:39:50
recordad que ese aus es una variable de tipo string está entre medias de ser un tipo de 00:39:59
referenciado y un tipo primitivo para unas cosas no es necesario hacer el new con lo cual se parece 00:40:07
un poco a los primitivos pero más bien es referenciado y una de las características 00:40:15
que tiene por ser referenciado es que no podemos compararlo con igual igual no nos vale esta 00:40:19
comparación entonces que como lo tenemos que utilizar cómo podemos compararlo con un compare 00:40:24
tú si queremos que nos valga cualquier combinación de sí sin minúsculas y mayúsculas si entre 00:40:30
minúscula y mayúscula como está el caso aquí de esta opción puede hacer un utilizar el compare 00:40:38
tú ignore case este caso le vale mayúsculas minúsculas y de todo tipo y si quiero mantener 00:40:44
esa característica, pero sin utilizar el compare to in every case, puedo utilizar 00:40:51
el compare to que obliga que diferencia entre mayúsculas y minúsculas 00:40:55
pero en ese caso lo que podríamos hacer es utilizar aquí otro 00:40:59
método que es el to, comparar aquí con sí 00:41:03
en mayúsculas y ese aus aquí podría coger y decir 00:41:14
que ese aus se igual a ese aus punto to 00:41:18
uppercase, entonces este como este, ese aus 00:41:22
aquí con mayúsculas minúsculas en este paso lo convierto con toda seguridad a mayúsculas y aquí 00:41:26
puedo comparar con el compare tú directamente poniendo las mayúsculas ya que el aus ese aus 00:41:32
con toda seguridad pondrá sino o lo que sea pero estar en mayúsculas dado que hemos ejecutado aquí 00:41:39
antes el método tu perquis en las estructuras de control necesariamente tenemos que poner aquí 00:41:46
algo que se evalúe como verdadero o falso el compare tú devuelve compare tú en particular 00:41:55
devuelve un valor numérico no es el mejor lo podemos hacer con el compare tú devuelve cero 00:42:02
si es igual un valor menor que cero si es menor una s aus que el sí y un valor mayor que cero si 00:42:08
es mayor esto nos permite al devolvernos mayor menor o igual nos permite ordenar los algoritmos 00:42:18
ordenación utilizar el compare tú entonces esto lo podríamos utilizar con si lo que me devuelve 00:42:27
es un cero quiere decir que ese aus es igual a si te diría cero es igual a cero en caso de ser 00:42:32
iguales me devolvería un truco y luego podemos utilizar el método más directo que en lugar del 00:42:39
compare tú sea el ecuador el cual ya sí que devuelve un booleán diciendo si son iguales 00:42:45
o no lo son mejor es cuál es más directo en este caso que no necesitamos ordenar y sólo queremos 00:42:55
saber si son mayores o no lo son en este caso resulta que tenemos frigorífico entonces pues 00:43:01
nada nos pondríamos a nos pondríamos a trabajar sobre estas dos variables la boolean y él 00:43:08
y sobre el frigorífico para darle alta fijaros el frigorífico el setter del frigorífico recibe 00:43:22
un objeto de la clase frigorífico es decir es un un setter copia lo que hace es asignar la 00:43:29
referencia de un frigorífico que está recibiendo por aquí al frigorífico que tiene la clase y el 00:43:39
setter de si tiene frigorífico el boolean recibe un boolean que será yes en caso de tenerlo y no 00:43:45
en caso de no tenerlo entonces en el caso de tener frigorífico lo que haríamos sería llamar 00:43:51
a mi cocina punto set de frigorífico en este caso diríamos true sí que tiene frigorífico y en el 00:43:58
setter del frigorífico le tenemos que pasar un objeto de la clase frigorífico veis entonces lo 00:44:13
que podríamos hacer aquí es llamar a un frigorífico crear un nuevo frigorífico es decir frigorífico 00:44:21
miFrig 00:44:27
igual a 00:44:29
newFrigorífico 00:44:32
Aquí acabo de construir 00:44:34
un frigorífico 00:44:37
y el setter este 00:44:38
lo que recibe es una referencia a un frigorífico. 00:44:41
Entonces, para llamar a este método 00:44:44
lo tenemos que pasar una referencia a un frigorífico 00:44:45
y esa referencia la tenemos aquí. 00:44:47
Como podéis ver. 00:44:50
El frigorífico que acabo de construir. 00:44:51
Este 00:44:59
y le pasamos la referencia al frigorífico. 00:44:59
Me estoy obligando a hacer esto porque lo he definido aquí como privado. Si el frigorífico aquí no fuese privado, directamente haríamos el new sobre este frigorífico y nos dejaríamos de ese setter. 00:45:03
Bueno, como existe frigorífico, antes de asignarlo, aquí lo que podríamos hacer es pedir la marca del frigorífico, aquí la cargo y esta marca del frigorífico en realidad se la tengo que asignar al frigorífico. 00:45:16
fijaros acordaros que el frigorífico tiene el setter de la marca por el frigorífico 00:45:48
entonces esa marca que la he capturado aquí la tengo en ese aus guardadita en el momento en el 00:45:55
que construye el frigorífico puede decir mi frig punto set marca ese aus es aquí pongo la marca 00:46:00
al frigorífico que acabo de construir le pongo la marca que le había cargado aquí mejor por cercanía 00:46:09
es como más directo aquí separamos así esto construimos el frigorífico asignamos marca 00:46:17
al frigorífico y asociamos al frigorífico con el setter la referencia del frigorífico que he 00:46:30
creado en el mail aquí tendríamos el frigorífico y en caso de que no existe ese frigorífico pues 00:46:37
podríamos que la cocina decir false y ya no existe frigorífico pues no tenemos que hacer 00:46:48
el new del frigorífico ni nada al no existir el frigorífico. Vamos a hacer 00:46:56
copy-paste de esto para la placa y la adaptamos. 00:47:05
Hay placa, si no, si resulta que hay 00:47:12
placa, decimos en lugar del set frigorífico 00:47:18
set placa verdadero y aquí 00:47:22
en este caso diríamos set placa falso. No existe placa. 00:47:26
Si existe placa, pues ¿qué vamos a hacer? Vamos a definir 00:47:31
una placa auxiliar aquí mi placa fijaros en este momento esta placa hace la reserva para una placa 00:47:34
una placa que es una variable local al método main del restaurante pero luego se la vamos a pasar 00:47:47
aquí para cuando completemos y lo pongamos esto bien para que se quede esa referencia esta placa 00:47:55
que estamos construyendo aquí como placa de la cocina en el caso de la placa no hay que pedir 00:48:02
la marca de la placa y en realidad lo que con lo que jugábamos con la placa era con el color y el 00:48:10
color fijaos recordad que se llamaba aquí estamos llamando al constructor de esta placa que estamos 00:48:17
generando y el constructor era el que llamaba set color con lo cual aquí hace ya toda la jugada nos 00:48:22
aplica el color que tenga esa placa venimos aquí el restaurante en caso de existir la placa decimos 00:48:29
mi codicina, punto, set placa y recibe, perdón, no set placa, no, punto, set mi placa, este, que recibe como parámetro una referencia a una placa, mi placa. 00:48:43
Aquí le ponemos el punto y coma y ya nos compila. 00:49:08
¿Y qué nos queda del ejercicio? 00:49:24
Pues nos queda que el método informov. 00:49:26
El método informov muestra por pantalla el resumen del inmobiliario disponible, 00:49:31
pero decimos que devuelva esa información, informov. 00:49:35
Entonces aquí creamos un método que sea public, 00:49:41
devuelve string, se llama informov, 00:49:47
formar el mobiliario 00:49:50
y ahora aquí tiene que construir 00:49:54
en base a toda esta información 00:49:58
si tiene placa, no tiene placa 00:50:00
como es la jugada 00:50:01
como devuelve un string 00:50:03
pues tendría que haber un return 00:50:06
aquí, vamos a poner 00:50:08
ese información 00:50:10
y la variable 00:50:12
esa información la podemos definir aquí como local 00:50:17
y la podemos ir construyendo 00:50:19
poco a poco, es decir 00:50:23
la cocina 00:50:24
una determinada cocina 00:50:26
que tiene un nombre 00:50:30
ese nombre, variable local 00:50:31
aquí no hace falta el getNombre porque es una variable 00:50:33
local, este método 00:50:36
pertenece aquí, por mucho que sea privado 00:50:38
tiene el alcance, le llega 00:50:39
y ahora podemos ir haciendo 00:50:42
a ver, que es lo que me pasa aquí 00:50:50
esto lo defino como string 00:50:52
y ahora puedo ir completando, digo 00:50:54
sí, if 00:50:57
si no tiene 00:50:58
frigorífico 00:51:03
y no tiene placa, ni frigorífico, ni placa, entonces, bueno, pues podría completar ese info, esa información, que es lo que estoy volviendo luego aquí, lo completo con lo que ya tiene hasta ahora, más, no tiene ni frigorífico, ni el shift. 00:51:07
A ver, si no tiene frigorífico y tiene placa, placa y no frigorífico, voy a decir no tiene placa y su frigorífico es de marca y tenemos que la marca la tenemos aquí con el frigorífico, punto frigorífico, get marca. 00:51:46
la hacemos, perdonad si voy un poco rápido 00:52:34
intentando a ver si nos da tiempo 00:52:41
encima no tiene frigorífico 00:52:44
y su placa es de color 00:52:48
dead color 00:52:54
y ya el else es la otra combinación que nos queda 00:53:01
en principio tiene frigorífico y placa 00:53:05
decimos 00:53:10
tiene un frigorífico 00:53:13
frigorífico 00:53:18
de marca 00:53:20
mi frigg.get 00:53:21
marca y su 00:53:28
placa es de color 00:53:31
vamos a hacer una prueba 00:53:32
fijaros, mi import devuelve un string 00:53:34
con lo cual aquí lo que haremos será llamar 00:53:37
mi cocina 00:53:42
punto 00:53:46
mi inform 00:53:49
inform of 00:53:51
y esto lo que queremos es soltarlo 00:53:57
por pantalla 00:54:00
println 00:54:01
mi cocina 00:54:03
.get 00:54:14
.informov 00:54:18
aquí lo tenemos 00:54:21
falta aquí 00:54:23
un paréntesis 00:54:26
y nada, vamos a hacer un par de ejecuciones 00:54:27
y a ver si nos va, si no la terminamos de revisar 00:54:31
el próximo día, lanzamos por aquí 00:54:33
nombre cocina A 00:54:36
¿tiene frigorífico? no 00:54:37
¿tiene placa? no, la cocina A 00:54:39
no tiene ni frigorífico ni placa 00:54:41
Siguiente prueba. 00:54:44
A, vamos a decir que sí tiene frigorífico y que no tiene placa. 00:54:46
A, el nombre frigorífico, Fagor, y no tiene placa. 00:54:50
Uy, él no tiene placa, no le ha gustado por ahí. 00:54:55
Displaca nul, claro. 00:54:59
Aquí, lo que pasa es que aquí, si no tiene placa, se nos va aquí. 00:55:01
Bueno, habría que revisarlo un poco. 00:55:14
Vamos a decir que sí tiene frigorífico, sí tiene placa. 00:55:19
Bueno, dice que tiene... Ah, tiene... Tampoco me dice el nombre del frigorífico. Bueno, queda pendiente darle una vueltecilla. Pero vamos a tener que parar aquí porque están ya preparando para, como os comentaba antes, hacer lo de los proyectos en la aula y están empezando a venir los compañeros para presentar su proyecto. 00:55:23
Si tenéis la solución del ejercicio completa en aula virtual, con las prisas, bueno, no os ha dado tiempo a depurarlo, pero a grandes rasgos, así es como había que montar el ejercicio. 00:55:45
¿Alguna consulta que queréis hacerme antes de cerrar? 00:55:59
Si estáis muy interesados en completar este ejercicio, el próximo día ya después de Navidad lo damos una vueltecilla y lo terminamos de completar en un ratito. 00:56:06
Y si no, pues bueno, pasamos directamente a cosas nuevas. 00:56:15
bueno, sin nada 00:56:17
si no tenéis nada 00:56:22
nos vemos ya justo a la vuelta de navidades 00:56:25
el día 11 me parece que es 00:56:28
la primera semana de 00:56:30
la primera no, la segunda semana de enero 00:56:31
que paséis una buena fiesta 00:56:34
y nada, descansad y comen mucho turrón 00:56:36
venga 00:56:38
pues nada, felices fiestas 00:56:40
hasta luego, aquí corto 00:56:42
hasta luego 00:56:44
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Autor/es:
JM
Subido por:
Jose Manuel M.
Licencia:
Dominio público
Visualizaciones:
24
Fecha:
16 de diciembre de 2024 - 18:31
Visibilidad:
Clave
Centro:
IES ALONSO DE AVELLANEDA
Duración:
56′ 49″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
116.35 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid