2025-02-17-Programacion | Mediateca de EducaMadrid

¿Alguna preguntilla tenéis preparada para hacerme antes de arrancar a contar cosas nuevas? 00:00:02

Si tenéis alguna duda por ahí del tema 7, que es el que tenemos abierto o de alguno anterior, 00:00:10

bueno, si no me decís nada, pues había pensado hoy, como solemos hacer, en resolver, 00:00:22

ya que la semana pasada no pudimos la tarea del tema 6, lo hacemos un poquillo rápido 00:00:29

y luego bueno pues hacemos alguna otra cosita por ahí adicional 00:00:34

tema 7 no tengo ahora mismo no me acuerdo exactamente en qué momento termina 00:00:38

a ver si termina el día 3 todavía nos quedan unas cuantas semanas 00:00:42

para luego hablar de algunas cosas del tema 7 00:00:47

dedicar alguna tutoría entonces hoy trabajamos ya os digo sobre la tarea del tema 6 00:00:52

y alguna otra cosita por ahí que hablemos y la semana que viene 00:00:57

la dedicamos a hacer repaso 00:01:02

de los conceptos que hay en el tema 7 00:01:04

y así con una semanita más 00:01:06

pues tenéis oportunidad de echar un ojo 00:01:08

a los contenidos 00:01:10

me escucháis bien verdad 00:01:11

luego confirmarme por ahí 00:01:13

si vale 00:01:15

perfecto 00:01:17

bueno pues nada la práctica 00:01:19

esta de la tarea de la cocina 00:01:22

tenéis ya como siempre 00:01:24

una solución 00:01:25

puesta en el aula 00:01:28

virtual disponible 00:01:30

y vamos un poco despacito como solemos hacer 00:01:31

repasando los conceptos a hacer el ejercicio. 00:01:35

Básicamente es una segunda versión 00:01:39

de precisamente este ejercicio que hicimos ya en su momento 00:01:43

antes de haber trabajado con Arrays y aquí básicamente lo que aporta 00:01:47

es un poquito el trabajar eso con Arrays porque a la hora de 00:01:51

estamos considerando una única cocina en el ejercicio 00:01:55

pero estamos teniendo en cuenta que esa cocina podría tener 00:01:58

una serie de frigoríficos y una serie de placas 00:02:02

cuando en el ejercicio anterior decíamos que 00:02:06

teníamos la posibilidad de que hubiera un único frigorífico y una única placa 00:02:10

en este caso una cocina podría disponer de cero o varios frigoríficos 00:02:14

y de cero o varias placas, es un poco lo que nos aporta 00:02:19

de nuevo, entonces el método este que proponemos 00:02:22

para la clase cocina, lo que hace es que una vez recogida 00:02:26

la información de nombre de la cocina, los frigoríficos 00:02:30

y placas que puedan existir, pues nos saca 00:02:34

un mensajito informándonos de si hay cocinas 00:02:37

de qué marcas son y si hay placas de qué colores. 00:02:42

Vamos a ponernos manos a la obra. 00:02:47

Entonces vamos a crear un proyecto que podemos llamar 00:02:50

cocina y la clase 00:02:57

y el proyecto este está formado 00:03:08

por tres 00:03:10

clases según propone el 00:03:12

enunciado. Algunos 00:03:14

no es mal criterio cuando 00:03:16

hacéis las prácticas, dedicáis 00:03:18

una clase para el main 00:03:20

y ahí es donde 00:03:22

incorporáis una cuarta clase 00:03:24

una clase que digamos principal 00:03:26

que la consideréis como inicio del programa 00:03:28

y ahí estanciáis la cocina y luego la cocina 00:03:30

empieza a tener información 00:03:32

Bueno, yo según lo proponía en el enunciado, como está en el enunciado así lo desarrollamos, la misma clase cocina es la que tiene el main. Bueno, si suponemos que pudiese haber más de una cocina, pues igual sería buena cosa que el main estuviera en una clase diferente. 00:03:34

por ejemplo podría ser cadena de comercios o lo que sea 00:03:52

o cadena de restaurantes y ahí podríamos a su vez 00:03:57

volver a tener un array por ejemplo de cocinas para que esa 00:04:00

cadena tuviese una o varias cocinas y cada una de esas cocinas 00:04:04

tuviera la oportunidad de tener uno o varios frigoríficos y una o varias placas 00:04:09

Bueno, no hemos sido tan ambiciosos en este ejercicio 00:04:12

entonces vamos a crear las clases, la clase cocina 00:04:16

vamos a crear la clase frigorífico 00:04:20

vamos a crear las tres clases, luego vamos metiendo 00:04:27

código y la clase 00:04:30

placa. La clase frigorífico y la clase placa 00:04:35

no veo que tengamos por aquí justo el ejercicio 00:04:45

hecho anterior, aunque sí que hicimos la práctica 00:04:48

bueno, pues en realidad no han cambiado 00:04:51

mucho del ejercicio anterior 00:04:54

la idea es que la placa pues tenga una marca 00:04:55

como vamos a crear un setter y un 00:04:59

y un getter, pues la podemos definir 00:05:02

esa marca como privada, 00:05:04

private, la marca es 00:05:06

un string, bueno, pues ese marca. 00:05:08

Y luego, 00:05:12

pues tiene su getter y su setter, 00:05:13

que lo podríamos escribir o podemos 00:05:14

intentar aprovechar 00:05:16

el id para que no los genere. 00:05:17

Vamos a buscar por aquí, 00:05:21

generar getters y setters, 00:05:23

nos da aquí el id de la opción, si no lo podríamos 00:05:25

escribir claro a mano, digamos que 00:05:26

para el atributo ese marca, 00:05:28

decimos que los genere, 00:05:30

Y bueno, pues ahí están. La clase frigorífico creo que no tenía mucho más que esto. El acceso a la marca solo se puede hacer desde la propia clase, al haberlo definido como privado, entonces tendremos que acceder a la marca a través de estos dos métodos que en este caso son públicos, con lo cual tendrían visibilidad desde cualquier parte del proyecto, aunque hubiese diferentes paquetes, no sería necesario ni siquiera definirlos como públicos. 00:05:32

si lo definiésemos sin ningún indicador, recordad que esto implica que la visibilidad es visibilidad de paquete 00:06:00

y como todo el código lo tenemos en el mismo paquete, sería igualmente válido. 00:06:07

Vamos a ponerlo público, que es como nos lo ha generado, pero podríamos ser un poquito más restrictivos 00:06:12

si nos seguiría funcionando el programa de igual forma. 00:06:17

Y por otra parte la placa tenía un atributo, vamos a definirlo también private, 00:06:22

para que su acceso sea único y exclusivamente desde esta clase 00:06:29

en el cual identificamos el color. 00:06:33

Vamos a definir un setter y un getter, pero en lugar de 00:06:44

llamar al setter desde por ahí fuera, lo que vamos a hacer va a ser llamarlo 00:06:47

de forma interna también. Entonces vamos a crear los getter y los setter 00:06:51

como antes, vamos a aprovecharnos del IDE, decimos que nos genere el getter 00:06:55

y el setter, y en realidad el color 00:07:01

se lo vamos a asignar en este ejercicio de forma automática 00:07:04

desde el constructor entre tres posibles 00:07:09

que de forma probabilística tenga cualquiera de los tres valores 00:07:11

por igual. Entonces fijaros como este setColor 00:07:17

lo vamos a aprovechar el constructor de la clase placa 00:07:20

para llamarlo y que asigne el color y el constructor está en la propia clase 00:07:24

podríamos incluso este setColor en este ejercicio también ponerlo como private 00:07:28

porque en realidad no vamos a acceder a este método desde fuera de esta clase 00:07:32

podríamos ponerlo, vamos a mantenerlo, aunque en público un getter y un setter 00:07:39

típicamente, pues bueno, que tengan visibilidad pública no es una cosa 00:07:43

para nada descabellada, ¿vale? Entonces ponemos 00:07:47

el constructor para cuando creemos una nueva clase, vamos a definir 00:07:51

el constructor como public, recordad que los constructores no devuelven nada 00:07:55

pero nos indica, al contrario que el resto de los métodos 00:07:59

Los constructores se tienen que llamar de la misma forma que la clase, con lo cual, respecto a esos convenios que tenemos a la hora de nombrar a los constructores, hacemos una pequeña excepción porque típicamente los métodos, tenemos el convenio, el acuerdo de que empiecen con minúsculas, las clases con mayúsculas, el constructor, recordad que no deja de ser un método. 00:08:03

Entonces, para seguir el convenio tendría que ser minúscula, pero como se tiene que llamar como la clase, tenemos que romper una de las dos reglas. 00:08:25

Entonces mantenemos la P mayúscula para el constructor y aquí lo que vamos a hacer va a ser cuando construyamos una nueva placa, 00:08:33

hagamos el new y llamamos al constructor, lo que vamos a hacer va a ser aprovechar este momento para asignar ya un color 00:08:42

y como queremos hacerlo entre tres que tengan un valor aleatorio, hay diferentes formas para hacerlo. 00:08:49

la que yo os proponía en el ejercicio 00:08:57

pues era definir aquí un par de constantes 00:09:01

que fueran a un tercio y a dos tercios 00:09:03

entonces si luego con una función 00:09:06

aleatoria obtenemos un valor 00:09:09

que va entre 0 y 1, pues entre 0,3 00:09:12

periodo, consideraríamos uno de los 00:09:16

tres posibles valores, si esa función random 00:09:19

nos da un valor entre 0 y 0,3 00:09:22

periodo, si va entre 0,3 periodo y 0,6 periodo, pues 00:09:25

consideraríamos el segundo color y entre 0,6 hasta completar 00:09:29

el 1, pues consideraríamos el tercero. De alguna forma ahí conseguimos 00:09:33

que los tres colores tengan los mismos valores. 00:09:37

Entonces, ¿cómo podemos hacer eso? Pues aquí lo que hacemos en el 00:09:41

constructor es llamar al método setColor. En realidad, 00:09:45

no vamos a llamar al método setColor 00:09:54

como clásicamente se hace en los setters 00:09:58

pasándole el valor, sino que lo que vamos a hacer va a ser dentro del setColor 00:10:02

utilizar el método random, con lo cual este setColor, vamos a modificarlo 00:10:05

así un poquito, vamos a decir que no reciba nada 00:10:10

y aquí lo que vamos a hacer va a ser precisamente hacer ese cálculo 00:10:12

entonces, utilizando de la librería 00:10:18

de Java Math, el método 00:10:22

random, este método fijaros que es un método 00:10:25

disponible en la clase mat, no hemos instanciado ningún objeto 00:10:32

de la clase mat, por lo que entendemos que esto se 00:10:36

tratará de un método estático, porque lo podemos llamar con el nombre de la clase 00:10:39

punto nombre del método, en la librería donde esté definido su código 00:10:43

se lo habrán trabajado de forma estática 00:10:48

y este método nos devuelve un valor entre 00:10:51

devuelve un valor entre 0 y 1, en principio pues con el mismo porcentaje de posibilidades 00:10:58

y el valor que devuelve, mirad si ponemos de nuevo aquí math.random, fijaros que lo que 00:11:08

devuelve aquí nos indica el id es un valor de tipo double, entonces definimos aquí un double 00:11:16

de result, pues aquí tendremos un valor 00:11:23

que en unas ejecuciones estará siempre entre 0 y 1 00:11:28

y caerá una vez entre 0 y 0,33, otra vez entre 0,33 00:11:32

y 0,66 y otra entre 0,66 y 0,69 00:11:37

entonces vamos a hacer esa comprobación, decimos if 00:11:41

si de result es menor 00:11:45

que 0,33, pues ahí haremos 00:11:51

algo. El shift podríamos poner de result es menor que 00:11:59

0,66. Fijaros que esto sería periodo, en verdad. Podríamos poner 00:12:10

aquí más 6 y más 3. 00:12:15

Lógicamente no podemos poner infinitos. Tendríamos que considerar 00:12:19

el rango de valores que aceptan los double. Vamos a poner ahí unos cuantos 00:12:22

y ya está. Y si no else, pues resultará que me habrá 00:12:26

dado la tercera de las opciones. Fijaros que si vale 00:12:33

0,1 también es menor de 0,66 pero como el if es excluyente si valiese menor de 0,3 ya habría ejecutado esta parte con lo cual tenemos la garantía de que por aquí pasará solamente dado que aquí lo que hemos comprobado es que sea menor de 0,33 solamente pasará en el caso de que sea de que esté entre 0,33 y 0,66 y ya si no es menor de 0,66 pues estará entre 0,66 y 1 y pasaremos por el último else. 00:12:37

Bueno, pues aquí podemos poner el valor ese color, ponemos el valor que sea, cualquiera de los tres, no me acuerdo, era marrón, verde y azul, creo recordar, o rojo, no me acuerdo, bueno, es igual, marrón, verde y azul. 00:13:07

Bueno, aquí tendríamos el método, el setter, un poquito particular porque no recibimos ningún atributo y además lo hemos definido como private porque su acceso se hace desde la propia clase. 00:13:35

Luego en el ejercicio, por trabajar algunas cosas más de las que estábamos viendo, creo recordar que habíamos definido unas constantes para estos valores, pues bueno, podríamos ponerlo y así lo trabajamos también. 00:13:46

Recordad, fijaros, eso es un valor de tipo double, podríamos poner double, podríamos poner d un tercio y decir que esto sea igual a, perdón, es un número 0.3333. 00:14:00

entonces aquí la comprobación, bueno, pues la podríamos hacer justo con esta variable 00:14:21

¿qué sucede en este caso? que hemos definido la variable 00:14:25

o sea, hemos definido de un tercio como una variable 00:14:28

entonces por aquí podríamos, en cualquier sitio del código 00:14:33

ya que lo hemos definido como parte de un atributo de la clase 00:14:37

podríamos decir que un tercio sea igual a 2, es decir, nos permite modificar 00:14:41

su valor, en el contexto de este ejercicio un tercio nunca debería cambiar 00:14:45

su valor, entonces si lo convertimos en final 00:14:51

lo que es una variable se convierte en una constante y ahora ya 00:14:54

fijaros que ya el propio IDE se da cuenta y no me compila porque dice 00:14:59

oye mira, si has puesto finales porque es una constante no intentes cambiar su valor porque no 00:15:03

ha lugar. Y para completar, fijaros que 00:15:07

no le importa este nombre para una 00:15:15

constante de tipo double, pero sí que habíamos llegado a un convenio también 00:15:19

igual que los métodos empiezan por minúscula y las clases por mayúscula, 00:15:23

de que las constantes aparezcan con todas sus letras en mayúscula. 00:15:27

Entonces, bueno, pues lo correcto, según lo que tenemos acordado, sería algo así. 00:15:33

Y luego, pues podríamos crear una constante para dos tercios, 00:15:39

igual que hemos hecho para uno, dos tercios. 00:15:43

Y aquí hacemos esta comprobación. 00:15:57

fijaros, si queremos ser puristas incluso 00:15:59

para seguir un poco lo que venimos hablando a veces 00:16:03

una placa está caracterizada como atributo 00:16:06

por su color, bueno pues 00:16:10

si fuera la clase más extensa tendría su marca, su peso 00:16:12

sus dimensiones, lo que fuese, eso caracterizaría a una placa 00:16:16

pero bueno, no tiene mucho sentido quizás 00:16:19

que utilicemos un tercio y dos tercios 00:16:22

como atributos 00:16:25

Entonces, quizás ya que son dos variables locales, no son algo que caracterizan en sí a la placa y son dos constantes que vamos a utilizar en el contexto de este método, quizás vendría mejor definirlas aquí. 00:16:26

No recuerdo ahora mismo dónde están definidas en el ejemplo que os he pasado, pero quizás dentro de SetColor, siendo puristas en lo que es el diseño de la placa, ya que un tercio y dos tercios no son características propias de una placa, y si información necesaria para aplicar el color, igual podría venir mejor definirlo aquí que allí arriba. 00:16:43

Y con esto, bueno, pues yo creo que ya tendríamos acabado lo que es. Bueno, esto ya sobra, claro. Esto en realidad no está haciendo nada porque ese color venía del setter de cuando teníamos aquí el parámetro del método setColor y se lo aplicaba al de clase. 00:17:02

entonces esto lo quitamos y aquí lo tendríamos 00:17:26

la placa y el frigorífico. Vámonos a la cocina 00:17:31

según el ejercicio que estamos desarrollando ahora aquí 00:17:35

nos hemos propuesto hacer que la cocina sea el punto de arranque 00:17:39

del programa, con lo cual será la que tenga el método main 00:17:44

entonces ponemos aquí public 00:17:48

static void main, como siempre 00:17:52

todas estas sintaxis que utilizamos para el main string recibe puede recibir como atributos el 00:17:57

método main como métodos el método main una raíz de strings en algún momento hemos hablado de 00:18:04

de cómo de cómo se mete esta información al main y aquí lo tenemos el punto de arranque 00:18:11

os ha denunciado un momento dice la cocina inicia el programa y tendrá las siguientes 00:18:18

características, nombre de la cocina, si tiene o no tiene frigorífico, si tiene o no tiene placa, el 00:18:26

número de frigoríficos, el número de placas y el array de frigoríficos y de placas que donde vamos 00:18:34

a ir guardando esa información. Pues ahora vamos a ello. Nos dice que tiene un string, ese nombre de 00:18:42

la cocina un boolean ve frigorífico tiene frigorífico o no tiene un boolean que nos indique 00:18:50

si tiene placa o no tiene placa esto podríamos si queréis inicializar la falsa los boolean en 00:19:07

verdad si no decimos nada si está están inicializados por defecto a falsa luego hablaba 00:19:13

del número de frigoríficos y numfrig número de frigoríficos lo podemos inicializar a cero aunque 00:19:20

de igual forma que esto se inicializa a false, un número se inicializa 00:19:28

por defecto a cero, placas, 00:19:32

frigoríficos, número de frigoríficos, número de placas 00:19:38

y luego los arrays. En los arrays 00:19:40

tenemos un array de frigoríficos y un array de placas. 00:19:45

Fijaros que no estamos dimensionando aquí todavía con 00:20:09

un new, como típicamente haríamos. No estamos 00:20:12

haciendo esto todavía poniendo aquí un determinado valor porque no sabemos si en esta ejecución la 00:20:19

cocina va a tener frigoríficos o no. Habrá un momento en el que lo pediremos por teclado y 00:20:24

tendremos que hacer esta acción y de la misma forma sucede con las placas. Luego cuando lleguemos a 00:20:29

ello lo repasamos. Bueno, todos en principio todas estas variables vamos a trabajar sobre ellas 00:20:35

principalmente desde el método main. 00:20:46

Recordad, el método main es static, es decir, es único. 00:20:48

Entonces, o bien, tendríamos que trabajar instanciando una cocina 00:20:52

para que desde un sitio static podamos hacer referencia 00:20:57

a la cocina con la que queremos trabajar. 00:21:02

Fijaros, si ponemos aquí ese nombre directamente al valor que sea, 00:21:05

luego lo trabajamos según el ejercicio, se me queja. 00:21:11

¿Por qué se queja? 00:21:14

porque dice, este método que sería común 00:21:15

es el main, pero podría ser cualquier otro, por ser static 00:21:19

a la clase cocina, se puede estar ejecutando 00:21:23

para cualquier cocina el mismo código, entonces se está ejecutando para cualquier 00:21:27

cocina el mismo código, y me pones aquí ese nombre, resulta que tú en el 00:21:31

programa podrías tener 5, 6, 7, 8 cocinas, el enunciado dice que trabajemos 00:21:35

con una solo, entonces para todas esas cocinas 00:21:39

de todas esas cocinas, ¿a qué nombre quieres que le dé el A? 00:21:42

El A del nombre de cuál de todas esas cocinas. 00:21:47

En este ejercicio, la verdad es que, según está definido, 00:21:52

no tenemos más de una cocina, con lo cual, 00:21:55

la única cocina que hay tendrá un nombre y no habrá más. 00:21:58

El único frigorífico que hay tendrá este boolean 00:22:02

y así para todas las variables. 00:22:05

Como no hay más de una cocina y no hay lugar a discrepancias 00:22:07

sobre qué cocina queremos trabajar, podríamos ponerlo como static. 00:22:10

Si lo ponemos static, aunque hubiese 00:22:13

más de una cocina, todas tendrían el mismo nombre, pero 00:22:16

justo en este contexto hay una sola cocina, con lo cual el nombre 00:22:18

que se aplicaría a todas las cocinas es el nombre que se aplica 00:22:22

a la única cocina con la que queremos trabajar. 00:22:25

Por eso nos vale poner aquí static y no tenemos que instanciar 00:22:28

ninguna cocina en particular. 00:22:31

Si no trabajásemos con static, ¿qué sucedería? 00:22:34

Pues entonces, para poder hacer esto, 00:22:37

Al no ser el nombre estático, podría pertenecer a muchas cocinas. 00:22:40

Entonces, tendríamos que identificar el nombre de qué cocina sería. 00:22:44

Entonces, diríamos cocina, micod, 1, igual, año, cocina. 00:22:48

Y ahora, sí que entre todas las posibles cocinas tenemos identificada una 00:23:00

y vamos a asignar a A justo a una determinada cocina. 00:23:04

y aquí ya me compilaría. Aquí no habría discrepancias, no pone ese nombre, un ese nombre genérico 00:23:09

que puede ser para muchas cocinas, ya que cada cocina tiene un nombre distinto al no ser estático. 00:23:17

Ahora ya quedaría claro que estamos asignando a A al nombre de una cocina en particular, que es miCoz1. 00:23:23

Otra cocina, que instanciásemos otro objeto, pues tendría un nombre diferente probablemente. 00:23:29

Como en este ejercicio trabajamos con una sola cocina, vamos a hacer que todos estos atributos 00:23:37

estén compartidas, compartidos por todas las cocinas, que al final, como es 00:23:42

única, pues van a ser los atributos de esa única cocina. 00:23:46

Si lo ponemos static todos, serían atributos 00:23:51

compartidos con todas las posibles cocinas que diéramos de alta en el programa, 00:23:58

como solo hay una, pues para esa cocina en particular 00:24:02

todos los atributos. Entonces aquí ya podríamos 00:24:05

poner un ese nombre igual a lo que sea. Por cerrar esto 00:24:10

que os cuento, esto del static, dependiendo del contexto del enunciado 00:24:18

y cómo vayamos a hacer el programa, es posible o no es posible. Si hubiera más de una cocina 00:24:22

no podríamos decir, bueno, para que me compile sin instanciar un objeto lo pongo static 00:24:26

porque cada cocina tendría su nombre. Hay que tener en cuenta un poco las circunstancias 00:24:30

de lo que nos pide el ejercicio y lo que nos demanda. 00:24:34

Pues ya tenemos ahí definidos todos estos e incluso 00:24:40

fijaros, vamos a darle carácter de privados a todos 00:24:43

si luego alguno necesitamos acceder a él desde algún otro sitio, diferente de que desde la clase, pues le cambiamos la visibilidad. 00:24:47

Pero en principio yo creo que todos los accesos lo vamos a hacer desde la clase cocina a estos elementos, con lo cual podrían ser incluso private 00:24:58

para dar seguridad a nuestra clase y que no pueda ser accedida desde otras futuras clases que quizás quisieran modificar estos datos 00:25:05

y a lo mejor podría no interesarnos vale pues nada la información se va recogiendo para ir 00:25:15

trabajando con el programa desde teclado entonces si se va recogiendo el de teclado vamos a definir 00:25:24

un objeto de la clase escáner es la clase escáner que está definida en la librería mira que no lo 00:25:29

lleve por aquí en la java útil las cosas que están definidas en las librerías java lang no 00:25:45

es necesario importarlas porque las consideran todos los proyectos 00:25:50

dado que se entiende que son funciones de uso tan común 00:25:54

que dicen, pues mira, directamente las integramos en cualquier proyecto con el que 00:25:58

se trabaje. El resto de librerías que tenemos disponibles 00:26:02

de Java, pues cada una la tenemos que importar en caso de necesitarlas. 00:26:06

Lógicamente no sería razonable integrar todas las librerías 00:26:10

porque sería mucho código que probablemente nuestros programas no iríamos 00:26:14

utilizando. En este caso, como vamos a usar Scanner y está en Java útil, que no está en 00:26:18

Java lang, tenemos que importarlo. Pues nada, ya nos va compilando. 00:26:22

Todavía por aquí no, pero ya por aquí sí. 00:26:27

Con Scanner tenemos la posibilidad de leer flujos 00:26:30

de datos. Los flujos de datos, luego cuando hablemos de los 00:26:34

ficheros, trataremos los flujos de datos y en una asignatura 00:26:38

que tendréis, probablemente si os matriculáis el año que viene, que es 00:26:42

programación de servicios y procesos, hablaremos de más flujos de datos 00:26:46

de otros tipos. Lo que nos permite es comunicar nuestro programa 00:26:50

con el exterior. Y esta comunicación, pues fijaros, puede ser 00:26:54

bien desde teclado, cosa que vamos a hacer ahora, el flujo de datos desde el teclado 00:26:57

hasta nuestro programa, o los de salidas cuando hacemos un system of println 00:27:02

y sacamos por pantalla, pues es un flujo de datos de salida desde el programa 00:27:05

a la pantalla. También tenemos la posibilidad de tener flujos de datos 00:27:09

a ficheros, para leer o guardar ficheros, o flujo de datos 00:27:14

también a sockets, que es esto que os digo que veréis el año que viene 00:27:18

en la asignatura de PSP. Scanner nos permite manejar 00:27:21

información recibida en el programa a través de un determinado 00:27:25

flujo de datos, que este curso lo estamos utilizando desde teclado 00:27:30

siempre, pero podría ser información que estamos leyendo, por ejemplo, 00:27:33

desde un fichero. Para identificar el flujo, 00:27:37

o desde dónde nos van a llegar los datos al programa a través de este flujo, se lo decimos en el constructor de escáner. 00:27:41

Entonces, en este caso decimos que en particular queremos gestionar con el objeto MyScan de la clase escáner 00:27:48

información que nos va a ir llegando desde el flujo de datos SystemIn. 00:27:54

Y una buena costumbre es que los flujos de datos que abramos terminemos cerrándolos 00:28:01

para que no se queden ahí abiertos y consumiendo recursos 00:28:07

cuando dejemos de trabajar con ese flujo de datos. 00:28:11

Si estamos leyendo un fichero, cuando terminemos de leerlo, 00:28:14

en lugar de dejarlo ahí al aire y consumiendo recursos, 00:28:17

pues vamos a cerrarlo. 00:28:20

Si estamos leyendo el teclado, pues cuando terminemos vamos a cerrarlo. 00:28:22

Entonces ponemos aquí, ponemos la opción Close y aquí me lo cierra. 00:28:26

Daros cuenta que aquí estoy poniendo el Close al final del Main, 00:28:32

que ya estamos terminando el programa, 00:28:35

Si no lo pusiéramos, es verdad que me da un warning aquí, creo, mirad, me da un aviso aquí diciendo, oye, no me gusta mucho que no lo hayas cerrado, fijaros, dice mi scan is never closed, pero como ya se acaba el programa, al finalizar el programa se cerraría en cualquier caso. 00:28:37

pero podría darse la situación de que terminásemos de utilizar mi scan 00:28:52

y por aquí todavía siguiésemos con código de Java haciendo cosas 00:28:57

a lo mejor es un programa 24-7 que no cierra nunca 00:29:01

y si no lo cerramos, pues aquí dejaríamos un recurso consumiéndose de forma innecesaria 00:29:04

entonces, bueno, pues buena costumbre cerrar los flujos de datos 00:29:10

ahí lo tenemos 00:29:14

y ahora bueno, pues vamos a empezar a trabajar con ello 00:29:18

lo primero que nos pide es el nombre de la cocina 00:29:22

Entonces, nos mandamos un mensaje por aquí, println, y solicitamos el nombre de la cocina. 00:29:25

Dime cómo se llama tu cocina. 00:29:35

Si ponemos un system.out.println y utilizamos este método de la clase out que está colgando de system, 00:29:40

resulta que nos pondría este texto por consola y nos saltaría una línea. 00:29:49

Pues en este caso vamos a utilizar el System of Print que nos saca por consola esto y se queda en la misma línea porque no mete el LN. Me parece más cómodo, más razonable el que te aparezca el texto y el cursor se quede aquí para que pongas el nombre. 00:29:52

bueno pues el nombre en principio va a ser un stream pues que vamos a querer cargar en el 00:30:09

nombre que lo tenemos aquí definido como un atributo de la cocina entonces podemos utilizarlo 00:30:18

directamente en este caso ponemos mi scan punto next line ahora ya tenemos aquí el nombre lo 00:30:23

siguiente que hacemos es por recuperar los frigoríficos las placas entonces 00:30:35

por aquí nos dice el número de frigoríficos, nos indica si hay frigoríficos 00:30:41

por aquí, pues vamos a cargar estos datos y lo vamos a instanciar 00:30:48

tanto frigoríficos como vayamos recibiendo por teclado 00:30:52

entonces podemos poner aquí un system.out.println 00:30:56

dime o indica o como queráis el número 00:31:02

de frigoríficos 00:31:08

de la cocina 00:31:12

y si queréis que os quede un poquito más chulito ya que tenemos aquí el nombre 00:31:14

pues podemos decirle, indicarle pues que nos diga 00:31:20

de la cocina esta y le ponemos así, dime el nombre 00:31:23

el número de frigoríficos de la cocina y así nos sale el nombre 00:31:30

que tiene la cocina en la pregunta que lo acabamos de cargar aquí 00:31:35

a través del escáner 00:31:38

aquí es previsible que recibamos un número 00:31:41

y bueno, en un programa que hiciésemos 00:31:45

en los próximos temas, pues a lo mejor correspondería 00:31:49

validar este número, bien por código o bien a través de excepciones 00:31:52

hay un tema de excepciones que viene a suponer 00:31:56

cuando las excepciones son estos mensajes que a veces nos dan aquí de error 00:32:01

cuando una de ellas muy típica es cuando intentamos acceder a 00:32:05

un elemento de un objeto que no hemos instanciado mirad por ejemplo aquí si cogemos y decimos 00:32:08

frigorífico a y nos lo hacemos un new y ahora ponemos aquí a punto ese nombre frigorífico 00:32:14

no tiene nombre es a punto ese marca bueno ese marca es privado pues vamos a utilizar vaya setter 00:32:28

es setter pues venga set marca que sucede que al frigorífico vamos a poner así null incluso como 00:32:36

no lo hemos hecho un new, tiene un null, no tiene reserva de espacio en memoria, entonces 00:32:57

al intentar acceder a uno de sus métodos, pues nos da un fallo. Fijaros, si hacemos aquí la ejecución, 00:33:01

bueno, aquí nos da un fallo. Fijaros que los mensajes que nos saca es 00:33:08

de excepción, bueno, en particular de null pointer exception, 00:33:11

el a apunta a null, entonces da 00:33:16

una excepción de null pointer exception, entonces estas excepciones 00:33:19

se pueden trabajar desde el código, 00:33:23

no las puedes evitar si se dan, pero 00:33:26

puedes hacer que el programa no se termine y gestionar 00:33:29

cómo quieres tú procesar cuando se dé una de esas excepciones. 00:33:33

Lo veremos en algún otro tema. Otro caso típico, este es uno muy típico para 00:33:37

provocar una excepción y que lo podáis ver y que se os puede dar, y otro es 00:33:41

si por ejemplo se produce una división entre cero. Si tú cualquier número 00:33:45

lógicamente lo divides entre cero, pues el número que te da es infinito. 00:33:49

entonces el procesador no es capaz de gestionar un número 00:33:52

que sea infinito y nos da una excepción 00:33:58

entonces esta excepción nos daría un mensaje de este tipo 00:34:00

y cuando se produce una excepción 00:34:05

si no está controlada el programa se termina 00:34:06

suponed que es un programa 24-7 00:34:09

está ahí en un cajero 00:34:14

que queremos que esté trabajando de forma continuada 00:34:15

y hay una situación en la que en base a unos datos 00:34:17

que puedas meter tú por teclado, podría darse una excepción. 00:34:21

Cuando metes otros datos, que son los razonables, 00:34:25

el programa hace el procesamiento que corresponda, 00:34:27

pero bajo ciertos datos sí que da esa excepción. 00:34:30

Si no la tienes controlada, ¿qué sucedería? 00:34:34

Que acabaría el programa y nos quedaríamos sin cajero 00:34:36

hasta que fuera a reiniciarlo algún operario. 00:34:38

Si lo tienes controlado, puedes gestionar lo que tiene que pasar 00:34:41

cuando se dé esa excepción y mantener el programa en funcionamiento. 00:34:45

Otra posible excepción es que si vamos a intentar cargar en una variable numérica un dato alfanumérico, pues nos da una excepción también y el programa se terminaría, pues otra de otro tipo. 00:34:50

Que sería lo que nos podría suceder aquí en caso de que si vamos a cargar en una variable de tipo numérico una cadena de caracteres y decimos que el número de frigoríficos es hola, pues nos daría una excepción. 00:35:02

Vamos a hacer el programa sin errores y pues ponemos la gestión de excepciones para cuando lleguemos a su tema. 00:35:13

Entonces bueno, pues para cargar el número de frigoríficos, pues fijaros, podríamos poner que el número de frigoríficos sea igual a mi scan.nestint. 00:35:23

esto me devuelve un entero que lo cargaría 00:35:36

aquí y me dejaría en el buffer de lectura todavía 00:35:53

disponible el enter, cuando yo escribo aquí en la 00:35:56

consola el número, pues pondré un 4, un 3 y luego 00:36:01

le daré enter, este NSINT me leerá el 3 y ese 00:36:04

enter quedará pendiente en el buffer de lectura y bueno, pues 00:36:08

en ciertas circunstancias podría llegar a darnos algún problema, una posibilidad 00:36:12

hace es limpiar el buffer de lectura, haciendo un nestline aquí 00:36:16

sin cargárselo a nadie, con lo cual esto me cargaría 00:36:20

el 4 y esto me cargaría el enter sin metérselo a nadie, pero limpio el buffer 00:36:25

de lectura. Y otra alternativa, bueno, pues la que yo estoy 00:36:28

acostumbrado a hacer, que os digo siempre, es leerlo siempre con 00:36:32

un nestline y luego hacer la conversión que corresponda. Cualquiera de las dos opciones 00:36:35

en verdad están bien. Pues yo defino por aquí una variable SAUS 00:36:42

aunque aquí estoy leyendo un número 00:36:48

voy a leer de escáner un next line 00:36:52

con lo cual aquí podría tener algo que es un número 00:36:56

pero en realidad es una cadena de caracteres, sería el 3 como cadena de caracteres o el 2 00:37:12

o lo que correspondiese y ahora para pasar esto a número 00:37:16

utilizamos integer. 00:37:19

Recordad que el número de frigoríficos es de tipo int 00:37:25

que es un dato primitivo y los datos primitivos pues tienen sus características particulares, no es necesario hacer el new, pero no tienen como cuando definimos un dato referenciado, por ejemplo un frigorífico, ciertos métodos propios de una clase. 00:37:30

Entonces, para poder trabajar con métodos, hacer acciones que tengan que ver con el entero, que el int en particular no tiene esos métodos, utilizamos su clase graper o envoltoria. 00:37:44

Entonces, todas las clases en verdad tienen estas primitivas, tienen su clase envoltorio, la int pues tiene la integer. 00:37:56

entonces esta sí que tiene una serie de métodos entonces el método parseInt 00:38:03

que ya lo conocemos recibe como atributo un string 00:38:07

y devuelve hacia la izquierda una variable de tipo 00:38:11

como nos chiva aquí, como nos chiva eclipse 00:38:17

una variable de tipo entero, veis por aquí 00:38:21

con lo cual aquí ya tendríamos el frigorífico y como hemos hecho una lectura con nestline 00:38:24

aparte de coger el número pues ha limpiado el buffer porque ha considerado 00:38:30

el enter. En definitiva aquí de esta parte de la ejecución 00:38:35

tendremos que tenemos o cero frigoríficos o n frigoríficos 00:38:43

pues podríamos decir sí. El número 00:38:46

de frigoríficos es mayor que cero 00:38:51

bueno pues vamos a trabajar con los frigoríficos. Una primera cosa 00:38:57

que podemos hacer es decir que si el número de frigoríficos es mayor 00:39:05

que cero vamos a indicar en este boolean que hay frigoríficos por si queremos 00:39:09

utilizar esto luego en algún momento para algo. Bueno, como el número de frigoríficos 00:39:12

ha sido mayor que cero, vamos a, tendemos 00:39:18

el número de frigoríficos, el boolean ya indicando que es cero y el otro 00:39:22

lo que vamos a hacer va a ser construir el array, dimensionarlo 00:39:26

según el número de frigoríficos y meter la información 00:39:30

que corresponda. Recordad que para los frigoríficos la información era indicar 00:39:34

su marca. Bueno, pues podemos utilizar un bucle 00:39:38

y aprovecharnos de los datos que tenemos. 00:39:43

Entonces decimos int i igual a cero, vamos a recorrer todo el bucle, 00:39:47

mientras i sea menor que el número de frigoríficos, i más más. 00:39:52

Y aquí vamos a ir trabajando en el array construyéndolo. 00:40:09

Una primera cosa que podemos hacer aquí, como ya sabemos, 00:40:12

el número de frigoríficos es dimensionar el array. 00:40:15

Entonces podemos coger y decir que mi array de frigoríficos 00:40:18

new frigorífico 00:40:22

inundefrigoríficos. Fijaros que aquí lo que hemos hecho ha sido 00:40:29

fijaros que esto no es el constructor del frigorífico, hemos puesto los corchetes 00:40:37

y no los paréntesis, lo que significa que no estamos 00:40:42

dando de alta el espacio de memoria para un determinado frigorífico, lo que estamos 00:40:46

construyendo es un array de referencias a frigoríficos 00:40:50

tantas referencias como hayamos indicado de frigoríficos que hay, pero cada uno 00:40:53

esos frigoríficos todavía no tiene su espacio en particular donde por ejemplo aplicar la marca 00:40:58

que tiene ese frigorífico ese frigorífico entonces aquí lo que hemos dado es dimensionado en la red 00:41:04

de frigoríficos y ahora en este ford lo que vamos a hacer es lo que hacemos es recorrer cada uno de 00:41:12

los frigoríficos para ir trabajando con él. Entonces cogemos y decimos 00:41:18

mi 00:41:24

arfrig y daros cuenta que esto 00:41:25

en la primera iteración del bucle for será cero, en la segunda 00:41:33

como incrementamos será uno, la tercera será dos, la cuarta será tres 00:41:38

y nos saldremos del for cuando hayamos recorrido todos los 00:41:42

frigoríficos y ahora hacemos un new frigorífico 00:41:46

Y aquí sí que ponemos el constructor del frigorífico. Aquí estamos pidiendo al sistema operativo espacio de memoria donde guardar información de esto, que esto es un frigorífico en particular, uno de todo ese grupo de frigoríficos que están recogidos dentro y quito el corchete de este nombre que es una red de frigoríficos. 00:41:52

Esto es, mi ARFRIG es un array de frigoríficos, mi ARFRIG, y entre corchetes con un número ahí, es un frigorífico en particular, y para ese frigorífico en particular llamamos al constructor, igual que lo haríamos si definiésemos un frigorífico fuera del array, diríamos frigorífico A, esto es un frigorífico, igual que esto es un frigorífico, igual a new frigorífico. 00:42:16

y para este frigorífico A en particular 00:42:49

lo que estamos haciendo es llamar al constructor del frigorífico 00:42:54

después del new, para este frigorífico en particular 00:42:57

estamos llamando al constructor del frigorífico después del new 00:42:59

aquí que no llamamos al constructor 00:43:02

lo que hacíamos era dimensionar el array de frigoríficos 00:43:05

pero un array de referencias a frigoríficos 00:43:09

no de frigoríficos ya con todo su cuerpo 00:43:11

digamos, vale pues una vez hecho esto 00:43:15

lo que tenemos que hacer para cada uno de los frigoríficos es pedir por teclado su marca. 00:43:23

Entonces decimos system.out.println, dime la marca del frigorífico. 00:43:28

Ponemos un system.out.print para que nos quede la misma línea. 00:43:49

Y aquí, bueno, con escáner podemos recuperar la marca. 00:43:53

Fijaros, si queremos que este nombre en cada una de las iteraciones, 00:43:58

pues vaya un poquito más acorde a, ya estoy pidiendo la marca del primero de los frigoríficos, del array y del segundo, pues tenemos la i que nos va recorriendo en cada ejecución del bucle tiene un valor diferente, la primera será 0, pues si el frigorífico del array 0 lo queremos enumerar como primero de los frigoríficos, pues aquí podríamos poner, dime la del frigorífico y aquí poner, si ponemos i nos diría el frigorífico 0, 00:44:02

Y si queremos que el frigorífico 0 en el mensaje sea el frigorífico 1, 00:44:32

pues podemos poner i más 1. 00:44:35

Para que 0 más 1 se convierta en 1 y nos diga, dime la marca del frigorífico 1. 00:44:38

En la siguiente iteración, que i valga 1, pues ya este i más 1 será 2. 00:44:43

Entonces dirá, dime la marca del frigorífico 2. 00:44:48

Y después de eso ponemos los dos puntos, un espacio aquí, 00:44:55

y dejamos el cursor, porque hemos puesto el método print en lugar de println, 00:44:57

justo en esa línea a continuación para meter la marca. 00:45:02

la marca en principio va a ser un string y vamos a querer que termine guardada 00:45:04

la variable se marca que es un atributo de que tienen todos los frigoríficos fijaros que como 00:45:14

bueno pues que es un atributo de clase pues entonces podríamos si queréis cargarlo 00:45:21

directamente en este atributo entonces decimos mi frío y esto que es un frigorífico el que está 00:45:24

en esta iteración trabajando, setMarca 00:45:31

y aquí podríamos poner, ahora después la rompemos esta línea 00:45:35

en varios, myScan.nextLine 00:45:44

¿Cómo se ejecutaría esta línea? 00:45:53

Después de esto se quedaría parada aquí esperando a recibir una información 00:45:58

esto devuelve un string que se pasaría al método setMarca 00:46:02

y el método setMarca se lo asignaría a 00:46:06

ese marca atributo de la clase frigorífico. 00:46:10

Si esto os cuesta verlo todavía un poco, algunos, pues lo que 00:46:15

podríamos hacer es decir, pues mira, vamos a coger en la variable 00:46:19

esta SAUS que habíamos utilizado por aquí, la tenemos, fijaros 00:46:22

aquí, podemos decir SAUS igual a mi scan punto next line, aquí 00:46:26

cojo la marca del frigorífico y la tengo en SAUS y ahora podría 00:46:34

llamar al método setMarca del frigorífico 00:46:38

pasándole ese aus. 00:46:41

Esta línea recoge 00:46:52

estas dos en una sola, como más os guste. 00:46:54

Y bueno, yo creo que no habría mucho más que hacer 00:47:01

con los frigoríficos. Si el número de frigoríficos es mayor que 0 00:47:02

que no lo he archivado aquí, si es 0, no hace 00:47:05

el if, ve frigorífico, lo hemos inicializado 00:47:08

por aquí a false, con lo cual no habría frigoríficos 00:47:12

y el número de frigoríficos sería cero, como hay cero 00:47:15

pues no hemos dimensionado el array de frigoríficos 00:47:18

pues no habría que hacer nada si es cero, y si es mayor que cero 00:47:22

pues entonces es cuando hay algún frigorífico, decimos que si hay algún frigorífico 00:47:26

dimensionamos el array para un frigorífico, para 10, para 20, para los que sea 00:47:30

y con este bucle para cada uno de ellos, creamos 00:47:34

cada uno de los frigoríficos y cogemos su marca 00:47:38

nombre de la cocina recuperar información de frigoríficos vale ahí tenemos el nombre los 00:47:41

frigoríficos pues vamos a por las placas recuperar información de placas vamos a utilizar un poquito 00:48:11

todo lo que podamos por aquí con los copies pegas entonces dice dime el número de placas lo cargamos 00:48:21

y en lugar de guardar la variable de número de frigoríficos lo vamos a guardar en el de número 00:48:31

de placas. Tendremos 0 00:48:35

o n placas. No validamos que sea un número, ya os digo, ya lo haremos 00:48:39

cuando toque eso. Y para cargar información 00:48:43

de las placas, vamos a hacer copy-paste de esto y lo vamos modificando 00:48:47

que va a ser más rápido. Entonces, si el número de placas es mayor que 0 00:48:51

si el número de placas no es mayor que 0, no se ejecuta este 00:48:55

if, el código se vendría por aquí. Entonces ya el número 00:49:04

de placas lo habíamos inicializado por aquí 00:49:08

a cero 00:49:10

y la existencia o no existencia de 00:49:11

placas la habíamos puesto a false. 00:49:14

Si resulta que el número 00:49:17

no es cero, pues entonces 00:49:18

el boolean este de placas 00:49:20

lo primero que hacemos es decir que 00:49:22

hoy hay alguna placa ya 00:49:24

y aquí en el caso 00:49:25

anterior habíamos dimensionado el array de frigoríficos 00:49:28

pues vamos a dimensionar el array 00:49:31

de placas. Decimos 00:49:32

el array de placas 00:49:36

new, pero ahora no, new de 00:49:38

frigoríficos, a ver, perdón, el array de placas aquí y no hacemos un new de frigoríficos 00:49:40

sino que hacemos un new de placas y ahora el número de placas que tenemos es el que 00:49:51

tenemos aquí. Se llama placa la clase, fijaros, placa por aquí, entonces por eso se queja, 00:49:57

placa, tan, ahí lo tenemos, aquí acabamos de dimensionar el número de placas, hacemos un recorrido por cada una de las placas, desde I0 hasta el número de placas y más más y en cada una de estas vueltas estamos trabajando con cada una de las placas, entonces para cada una de las placas que tenemos en el array, hacemos un new para esa placa en particular, 00:50:03

Igual que comentábamos antes para los frigoríficos, aquí fijaros que estamos dimensionando el array, son corchetes, no son paréntesis, no es el constructor. 00:50:36

Y aquí para cada una de ellas, esto es una placa, esto sería el array de placas, si le metemos los corchetes y el i, esto sería una placa en particular. 00:50:45

Esta placa en particular, para ella no hemos hecho el new, porque esto es un array de referencias a placa, lo que acabamos de dimensionar aquí. 00:50:54

Para esta placa le hacemos un new y ahora sí que llamamos al constructor de la placa. 00:51:00

fijaros que aquí es más sencillo que en el caso de los frigoríficos porque hemos hecho el trabajo ya previamente 00:51:04

cuando estamos haciendo el new de la placa, llamamos al constructor que no recibe parámetros 00:51:13

y aquí el constructor que no recibe parámetros, recordad que lo que hacía era llamar al método setColor 00:51:19

y el método setColor de forma aleatoria a través del método random de la clase mat 00:51:23

aplicaba al color de la placa un determinado color, marrón, verde o azul 00:51:31

Con lo cual, para las placas poco más que hacer yo creo por aquí. Y ahora lo que nos decía por aquí el ejercicio es que la clase cocina tendrá como método, este método, el método informof, que es el que nos saca estos resultados en base a, bueno, por la información que tengan los arrays que tiene como atributos. 00:51:35

vamos a construir este método 00:52:00

aquí lo llamamos informof 00:52:02

no me compila de momento 00:52:08

porque no lo tengo construido 00:52:12

el método informof 00:52:13

a ver si nos dice que tiene que devolver el string 00:52:18

o no nos lo indica 00:52:21

habría dos opciones, que el método informof 00:52:23

devuelva un string con esto 00:52:25

y luego mostrarlo desde el main 00:52:26

o que el método informof 00:52:29

directamente haga el system of println 00:52:31

de esto, no veo por aquí 00:52:33

que lo diga o si 00:52:37

construye bueno no parece que sea un requisito ni de una forma ni de otra 00:52:38

bueno vamos a hacer lo que lo escriba directamente informó y luego si no que lo devuelva después si 00:52:47

lo escribe directamente ponemos aquí un public void si lo escribe directamente no necesitamos 00:52:53

que devuelva nada informó hemos decidido en principio que no reciba ningún atributo o sea 00:53:00

ningún parámetro, este método en principio no parece que vaya a ser necesario 00:53:13

porque vamos a trabajar con los atributos de la clase 00:53:17

cocina y precisamente este es un método de la clase cocina, estos atributos 00:53:21

están disponibles para cualquier método de la clase, ¿por qué? porque 00:53:26

pertenecen al ámbito de la cocina y el ámbito de la cocina empieza ahí 00:53:29

y termina aquí, con lo cual están dentro. 00:53:33

Es cierto que 00:53:39

aquí nos está dando un error y el motivo es lo mismo que nos pasaba antes 00:53:40

cuando estábamos hablando de utilizar de forma estática 00:53:45

estos métodos, el nombre de la cocina cuando empezábamos a desarrollar 00:53:49

el main. Y lo que está pasando aquí es que desde el método 00:53:53

main, que según está definido en el ejercicio es un método de la 00:53:57

clase cocina, es estático, con lo cual se podría estar ejecutando 00:54:01

para cualquier cocina. Y aquí estamos llamando a un método 00:54:05

informof que no es estático, es decir, cada cocina en particular 00:54:09

tendría su método informof. Entonces dice, informof 00:54:13

exactamente de qué cocina quieres informarme. Fijaros, aquí 00:54:17

podríamos tener cocina, coz1 00:54:21

igual año cocina 00:54:26

el ejercicio solo nos pide una cocina, pero bueno, para justificar 00:54:29

por qué no nos está compilando. Fijaros que aquí tenemos dos cocinas y podríamos 00:54:36

tenemos que tener claro, definidas muchas más, cada una de estas dos cocinas 00:54:41

al no ser este método estático, tendrá, digamos, la posibilidad 00:54:45

de ejecutar su propio método informof. Y aquí estamos llamando a un 00:54:49

informof y hay ambigüedad, porque dice de la cocina 1, de la cocina 2, 00:54:53

de otras cocinas que puedas definir por ahí, no tengo ni idea. 00:54:57

Si pusiéramos esto, pues ya me compilaría y diría 00:55:02

ya no hay lugar a dudas, este método informof está diciendo que es 00:55:06

que se ejecute justo el método relativo a la cocina 1 00:55:10

no a la cocina 2, no hay ambigüedad, compilo 00:55:13

en este ejercicio nos podemos permitir el lujo 00:55:15

de convertir este método también en static 00:55:20

entonces ya me compila perfectamente 00:55:23

porque hay ambigüedades ahora de que método 00:55:27

informof se va a ejecutar si lo llamo aquí 00:55:29

sin indicar un objeto de la clase cocina 00:55:33

no, ninguno, si este método es común absolutamente a todas las cocinas 00:55:36

pues ya está, es el único que hay 00:55:39

desde un sitio estático, estamos llamando a un sitio estático 00:55:41

no hay problema en ningún caso porque todo pertenece a la clase cocina 00:55:45

pues ya está, este es el método que pertenece a la clase cocina y está compartido con 00:55:49

todos los objetos posibles que tengamos definidos de cocinas 00:55:53

dentro del código. Una vez que me compila, pues nada, pues a trabajar 00:55:57

un poco con el ejercicio. Aquí 00:56:05

lo que podemos hacer es poner un system.out.println 00:56:08

Bueno, pues podemos primero definir un string aquí, ese mensaje o esa información, ese mens, y decir que es lo que voy a escribir aquí. 00:56:14

Y ahora podríamos dentro de aquí entre medias construir el mensaje que quiero escribir por pantalla y mostrarlo aquí al final. 00:56:35

por ser los atributos de clases 00:56:44

compila aunque no los inicialices, pero las variables locales tienes que 00:56:52

inicializarlas, si no, no compila 00:56:57

aquí se queja y dice, oye, está sin asignar ningún valor 00:56:59

si ya tienes los inicializados, pues ya dice, vale, me parece bien 00:57:04

compilo, me gusta, entonces bueno, el mensaje 00:57:11

si os acordáis, por aquí tenemos 00:57:17

diferentes opciones de mensaje. Todos los mensajes tienen aquí un bloque 00:57:21

que es común y siempre aparece porque todas las cocinas tienen 00:57:25

un nombre. Ya está, pues podemos empezar construyéndolo con esto 00:57:28

y luego ya en función de si hay frigoríficos o no hay placas y el número de frigoríficos 00:57:33

y placas que hay, pues construimos el resto 00:57:37

del mensaje. Pero este bloque sí que es común. Entonces, como 00:57:41

ese bloque es común y siempre va a salir una vez que hagamos el System of Println 00:57:45

pues lo podemos poner aquí decimos la cocina y el nombre de la cocina lo tenemos aquí en esta 00:57:49

variable y luego podemos aquí poner un espacio que nos separe el nombre de la cocina es lo que 00:58:00

le está pasando aquí más aquí después del nombre de la cocina siempre hay un espacio y bueno hay 00:58:14

un espacio bueno pone tiene o no tiene o sea que ahí habría que jugar con esto este mensaje ahora 00:58:25

vamos a construir el mensaje de no tiene frigoríficos o tiene el número 00:58:32

de frigoríficos que sea. Y luego ya después, pues trabajaremos 00:58:36

para construir la parte de las placas. 00:58:40

Para el número de frigoríficos, pues tendremos que comprobar 00:58:48

si hay frigoríficos. Tenemos la verdad duplicada de información 00:58:52

aquí, porque aquí sabemos si hay frigoríficos o no, pero ya que hemos definido 00:58:56

esta variable de si hay frigoríficos booleana, vamos a utilizarla. 00:59:00

estas variables en verdad, hubieran sido 00:59:03

prescindibles, porque el dato de si lo hay o no lo hay, lo tenemos aquí 00:59:07

mirando a ver si el número de frigoríficos y de placas es cero o no lo es 00:59:11

pero bueno, ya que lo tenemos, vamos a decir, si hay frigoríficos 00:59:15

pues tendrá que pasar algo, y si no hay frigoríficos 00:59:19

pues tendrá que pasar algo también, a ver como es 00:59:26

el mensaje, si no tiene frigoríficos nos iremos por el else 00:59:40

y si tiene frigoríficos, pues dice 00:59:47

tiene el número de frigorífico, bueno si es uno 00:59:50

frigorífico y si son varios, frigoríficos 00:59:54

bueno, pues esto podemos ir trabajándolo con if else 00:59:57

vamos a, desde luego 01:00:00

habremos ido por la zona de frigoríficos 01:00:03

para todas estas, tiene que poner tiene 01:00:06

un y frigorífico, frigoríficos 01:00:08

si llegamos aquí, podemos decir ese mensaje 01:00:11

será igual a ese mensaje, ¿verdad? Para no perder lo que tenemos hasta ahora. 01:00:17

Aquí, si he entrado por aquí y resulta que tiene frigoríficos, pues ponemos 01:00:23

tiene más y el número de frigoríficos 01:00:27

lo tenemos en esta variable. Y ahora, después 01:00:32

de este número, hay que poner o frigorífico o frigoríficos. 01:00:50

Si es uno, será frigorífico. Si es más de uno, sería frigoríficos. 01:00:57

El espacio se lo he puesto ya aquí, entonces no se lo pongo aquí. 01:01:25

y si le voy a poner un espacio para luego después 01:01:28

y si no, pues aquí sería frigoríficos 01:01:35

y si nos hemos venido por aquí, que este es el else 01:01:38

entonces el mensaje tendrá que ser 01:01:44

que no tiene frigoríficos 01:01:49

a ver cómo es exactamente, no lo dice el enunciado 01:01:51

no tiene frigoríficos 01:01:57

hasta aquí hemos construido por aquí el nombre 01:02:01

y yo creo que aquí tenemos construido los frigoríficos 01:02:16

no sé si nos falta algo, si no luego con la ejecución 01:02:20

lo retocamos. Y ahora vamos a trabajar 01:02:31

con las placas. Decimos 01:02:44

if, vamos a ver si tiene placas o no 01:02:48

bPlaca 01:02:52

aquí 01:02:55

tenemos garantía de que hay alguna 01:02:57

placa, una o varias, pero hay placas 01:03:01

y por aquí no hay placas. Vamos primero 01:03:04

que es más cortito por aquí tendríamos toda la jugada de los frigoríficos y no tiene placas 01:03:16

si no hay placas pues por aquí tenemos que poner y no tiene placas pues ahora vamos a ponerlo por 01:03:26

aquí y por aquí estamos donde sí que hay placas bueno aquí nos falta por poner las marcas es 01:03:37

verdad en caso de que tenga frigoríficos no sé si tiene un frigorífico de marca favor de marcas 01:03:50

vaya vale ahí bueno pues tenemos que poner esto de las marcas frigorífico de marca tiene un 01:03:59

frigorífico de marca vamos a abrir el paréntesis y por aquí tenemos que recorrer el bueno si es 01:04:09

un solo frigorífico entonces sería mucho más directo en el caso de ser uno porque diríamos 01:04:20

esto más está en la posición como son solo frigorífico pues será la posición 0 de la 01:04:26

raíz primero de los frigoríficos posición 0 punto get perdón frigorífico no eso es el nombre de la 01:04:34

clase mirar fríos de frigoríficos posición 0 punto get marca y luego cerramos esto es así 01:04:47

es como queda con un frigorífico solo y luego un espacio para lo de las placas, espacio y si tienen 01:05:05

más de un frigorífico pues sería frigoríficos de marcas y aquí tendremos que hacer un recorrido 01:05:20

por el bucle, con un for, le decimos for inti igual a cero mientras i sea menor que el número 01:05:32

de frigoríficos y más más. Y cada uno de los frigoríficos pues tendrá que añadir su marca. 01:05:51

pues lo que cogeremos será esto 01:06:03

aquí en lugar de 0 tendrá que ser i 01:06:11

esto habrá que añadirlo al mensaje 01:06:15

y a ver cómo es el texto exactamente 01:06:18

y hay un espacio por lo que veo por aquí 01:06:28

para cada uno de estos hay un espacio 01:06:33

pues vamos a meterle un espacio 01:06:35

para separar cada uno de ellos 01:06:37

más un espacio 01:06:39

y luego el mensaje 01:06:45

cuando ya han terminado todos 01:06:51

que cierre el paréntesis, es cierto, luego si queréis 01:06:53

incluso lo intentamos manejar, algún paréntesis me falta 01:07:07

que el último no tendría este espacio para que cierre el paréntesis junto a la marca 01:07:10

del último, lo podemos intentar luego si os parece 01:07:15

lo manejamos aquí o lo dejamos así tal cual, a ver 01:07:19

que es lo que me pasa por aquí, este me sobra, bueno vamos a meter 01:07:22

las placas, dice aquí no tiene placas, en caso de tener placas pues será algo 01:07:35

parecido a esto, en verdad, voy a hacer un copia y pega y lo adaptamos 01:07:39

en lugar de decir aquí tiene inund de frigoríficos, habrá que decir el número 01:07:48

de placas, aquí lo cogemos, el número de placas 01:07:58

tiene estas placas, si es un solo frigorífico 01:08:04

a ver, el formato para poner el color también es así, es 01:08:13

el mismo estilo, entonces array de frigoríficos no 01:08:17

sino tendrá que ser el array de placas, mi array de 01:08:24

placas por aquí, placa de color y en lugar de get marca, punto get color, ahí está y si tiene más, tiene placas de colores y hacemos un recorrido en el bucle igual que habíamos hecho antes con los frigoríficos, sobre el array de frigoríficos recuperando sus colores, se van asignando al mensaje y luego cerramos por aquí, 01:08:31

bueno, podemos hacer un intento de ejecución, a ver qué pasa 01:09:12

en otras tutorías os he dicho que quizás no sea lo más recomendable 01:09:20

bueno, pues como lo hago yo aquí en las tutorías 01:09:26

de meter todo el código y no lanzar ninguna ejecución, siempre es mucho más 01:09:29

aconsejable, sobre todo cuando estéis empezando, ir haciendo ejecuciones 01:09:34

parciales para ir detectando posibles errores que vayáis teniendo 01:09:38

y así normalmente los errores que vayan apareciendo 01:09:42

de una ejecución a otra, pues estarán integrados dentro 01:09:46

del último código que habéis puesto. Si hacéis todo y ahora no funciona, pues 01:09:50

en verdad tenemos mucho código donde mirar para intentar resolverlo. Mejor ir haciendo 01:09:54

ejecuciones parciales e ir probando cosas poco a poco. Bueno, 01:09:58

ya que no lo he hecho, pues vamos a ver qué pasa. Dice, ¿cómo se llama 01:10:02

la cocina? Es la cocina primavera, vamos a llamarla. 01:10:08

La cocina primavera tiene, vamos a decir que no tiene frigoríficos de momento. 01:10:19

Fijaros, he puesto un System of Print LN aquí, que decía que no lo iba a poner. 01:10:23

Y dice, dime el número de placas de primavera. Decimos que no tiene tampoco placas. 01:10:29

Bueno, y de momento, este primer mensaje parece que ha salido como esperábamos. 01:10:34

A ver, ahora, en cambio, la cocina otoño tiene un frigorífico. 01:10:40

Y la marca del frigorífico es Fagor. 01:10:46

y tiene una placa 01:10:49

entonces le dicen 01:10:53

Toño tiene un frigorífico de marca Fagor 01:10:56

nos hemos comido un i 01:10:58

que había en el otro sitio pero bueno sería cuestión 01:11:01

de ponerlo en el texto justo antes del 01:11:02

del tiene y tiene 01:11:04

una placa de color verde 01:11:06

la verano 01:11:08

resulta que tiene tres 01:11:13

frigoríficos de marca Fagor 01:11:16

Zanussi 01:11:18

y vos 01:11:21

y va a tener tres placas también, pues nada, no sale bien 01:11:23

fijaros este espacio, nos falta el i, aquí justo no lo he separado y aquí 01:11:29

hay un espacio de más, bueno, pues sería cosa que podríamos manejar 01:11:34

ahí dentro del código, y vamos a hacer 01:11:38

alguna prueba con la combinación de que tenga frigoríficos y no tenga 01:11:42

placas y de que tenga placas y no tenga frigoríficos, la invierno 01:11:46

pues esta si va a tener frigoríficos, vamos a decir que tiene dos frigoríficos 01:11:54

Zagor 01:12:02

y Zanussi 01:12:04

no sé si Zanussi es con dos S ahora mismo 01:12:06

pero bueno, y cero placas 01:12:09

parece que le va 01:12:11

y luego 01:12:13

vamos a crear una 01:12:19

cocina para nosotros, para Adam 01:12:21

que no tenga frigoríficos 01:12:23

y en cambio tiene seis placas 01:12:25

uno, dos, tres 01:12:27

cuatro, cinco, seis, el random también 01:12:30

funciona, hay variedad aquí de colores 01:12:31

y dice que no tiene frigoríficos por aquí. 01:12:34

Bueno, pues parece que en general funciona el programa. 01:12:38

Con algún pequeño ajuste por aquí. 01:12:42

Aquí habría que poner un y no tiene frigoríficos. 01:12:47

No, y no tiene frigoríficos, no sé, y no tiene placas, perdón. 01:13:02

Ah, pues y no tiene placas. 01:13:09

¿No ha salido la i antes? No sé. 01:13:11

Y placas, este de aquí. Y placas de colores. 01:13:15

Bueno, había un espacio por ahí también. No vale la pena mucho enredar con esto. ¿Alguna preguntilla tenéis? ¿Más o menos se entiende bien todo el desarrollo? ¿No? ¿Todo bien? ¿Seguís por ahí, verdad? Vale, pues nada, la tarea esta la dejamos ya cerrada. 01:13:17

si queréis 01:13:52

un ratito más 01:13:54

porque todavía son menos cuarto 01:13:56

si no tenéis ninguna pregunta 01:13:58

de esto en general 01:14:00

pues si queréis podemos 01:14:02

plantear un poco 01:14:04

el ejercicio, no sé los que estuvisteis 01:14:06

de vosotros, algunos 01:14:09

que estuvisteis, de los que estáis 01:14:10

en la tutoría, si queréis podemos 01:14:12

plantear un poco, por ejemplo, el segundo ejercicio 01:14:14

que había 01:14:17

para desarrollar que 01:14:19

se recibía un array de personas me parece o el primero de ellos que entre un número había que 01:14:20

buscar aquellos que era múltiplo de 7 y que terminaban en 4 alguno de esos podemos hacer 01:14:25

si queréis y con eso ya hacemos un ratito más y terminamos la tutoría si no te si no tenéis nada 01:14:33

así en particular que queráis ver bueno vamos a hacer eso vamos a utilizar este proyecto mismo 01:14:41

lo borro directamente 01:14:52

bueno, lo mantengo 01:15:06

por si acaso queremos retomar el ejercicio 01:15:09

en algún momento 01:15:11

bueno, pues 01:15:12

uno de los ejercicios planteaba 01:15:15

pedir números 01:15:17

era pedir números 01:15:20

hasta 01:15:23

no me acuerdo 01:15:23

cómo era el enunciado, la verdad 01:15:26

entre dos 01:15:27

determinados valores 01:15:30

bueno, pero eso era muy fácil, yo creo 01:15:31

un ejercicio pedía 01:15:33

acumular el valor 01:15:36

de números que estuvieran entre un rango o algo así 01:15:40

había que hacer un método, me parece recordar 01:15:44

vamos a definir aquí un método, por ejemplo, y si no es justo el del examen 01:15:47

es que no me acuerdo exactamente del enunciado, pues algo parecido y ya está 01:15:56

vamos a llamarlo método 01:15:59

y que reciba int 01:16:02

y val uno 01:16:06

int y val dos 01:16:08

que no devuelva nada 01:16:13

yo creo que he borrado cosas de más 01:16:21

es que he borrado el main 01:16:30

lo he comentado 01:16:32

ahí está 01:16:49

bueno entonces vamos a definir 01:16:50

lo static también 01:16:53

y vamos a llamar al método 01:16:54

con dos valores 01:16:57

luego hacemos variantes si es necesario 01:16:58

Entonces uno de los ejercicios pedía que sacáramos el resultado de sumar valores comprendidos entre estos dos, que fuesen o bien múltiplo de un número, vamos a poner 7, o que terminase en 4, algo así. 01:17:15

Pues lógicamente lo primero que tenemos que hacer es, bueno, pues vamos a definir una variable donde ir guardando el resultado final. 01:17:47

El enunciado, yo leyéndolo me daba la impresión de que podía dar la interpretación de que o bien terminar de hacer un resultado para los que terminasen en 4 y otro resultado para los que terminasen en 7 o que simultáneamente tuviera que cumplir los dos valores. 01:17:56

como él me parecía que estaba un poquito ambiguo el denunciado pues a los que lo habéis planteado 01:18:15

de una forma me lo he puesto como bien y en los que lo habéis planteado de otra forma pues también 01:18:20

como bien al final el trabajo en la algoritmia con el programa era muy parecido y bueno pues 01:18:24

era un poco lo que buscaba no entonces bueno pues mirad podemos definir una variable una 01:18:29

variable resultado digamos que vale 0 y esta palabra va a ser donde vamos a ir acumulando 01:18:36

pues en los vamos a ir sumando aquellos valores que estén comprendidos entre estos dos y que y 01:18:44

que cumplan esta condición como vamos a recorrer todo ello pues podemos definir un bucle que 01:18:52

típicamente inicializamos los for lo hemos hecho por aquí para los arrays entre voy a tener que 01:19:00

quitar todo esto, porque si no, no me va a permitir ejecutarlo. 01:19:10

Lo solemos inicializar desde cero, en este caso 01:19:16

como queremos ir desde este valor 01:19:19

mientras i sea menor que el valor definitivo 01:19:20

aquí vamos a ir entre estos dos valores 01:19:25

justo, que es una de las cosas que nos pide 01:19:27

y como queremos recorrer todos ellos, pues le hacemos 01:19:30

un i++. Y ahora, bueno, pues tenemos que buscar 01:19:33

la condición de que o bien sea 01:19:41

múltiplo de 7 o bien termine en 0. 01:19:44

Entonces la forma de comprobar si un número es múltiplo de otro, pues es dividir entre ese número y en lugar de fijarnos en el resultado de la división, pues no vamos al resto. Si el resto es cero, pues resulta que es que efectivamente ese número es divisible por el que estamos dividiendo. 01:19:47

entonces podríamos coger y decir if 01:20:05

sí, y en particular con el que estemos trabajando ahora 01:20:08

tanto por ciento, que es el que nos da el resto 01:20:12

siete, claro esto no va a dar un número y aquí necesitamos 01:20:15

una condición que se pueda evaluar como verdadera o falsa 01:20:20

entonces, si esto resulta que es igual a cero 01:20:23

quiere decir que este número, el que estamos 01:20:28

con el que estamos trabajando en esta iteración del for, es divisible entre 7. 01:20:35

Entonces podríamos coger y decir aquí result, es igual a result más i. 01:20:42

Bueno, aquí lo tendríamos si es divisible entre 7. 01:20:56

Y para ver si termina en 4, pues lo que podríamos hacer es, 01:21:03

Entonces la forma más rápida que se me ocurre a mí es muy parecida a esta, ¿verdad? Poner aquí un else if y lo que podemos hacer es sacar el resto pero dividirlo por 10. 01:21:07

entonces el resto si es igual a 4 01:21:25

pues quiere decir que el número con el que estamos trabajando es un 4 01:21:28

si el i en este caso vale 34 01:21:32

pues al dividir entre 10 nos quedará 3 01:21:36

y el resto 4, esto como nos devuelve el resto 01:21:40

si resulta que el resto ha sido igual a 4, pues resulta que ese número termina en 4 01:21:44

de la forma yo creo más rápida 01:21:48

luego hay alternativas, ahora después de hacer esta 01:21:52

intentamos probar alguna otra, bueno, en este caso también 01:21:55

le sumaríamos esto, fijaros aquí lo que estamos haciendo es 01:22:02

poner, con las dos alternativas 01:22:06

estas denunciado que os decía, estamos acumulando el resultado 01:22:10

tanto si es divisible por 7 como si 01:22:13

termina en 4, en ambos casos lo que hacemos es acumular 01:22:18

el valor que tenga ahí en esta 01:22:22

iteración del for al resultado. 01:22:24

Se lo sumamos. Si por el 01:22:26

contrario decidiésemos que es que tiene que 01:22:29

cumplir las dos condiciones, porque así lo 01:22:31

interpretamos del enunciado, pues entonces habría que poner 01:22:33

un if 01:22:35

de este tipo. 01:22:36

Si el número 01:22:39

es divisible por 7 01:22:40

y termina en 4, 01:22:42

en ese caso sería cuando 01:22:55

acumularíamos el resultado. 01:22:56

En este caso tendrían que ser las dos condiciones 01:22:58

simultáneas. Ya os digo, depende 01:23:00

de cómo se interpreta el enunciado a la hora de leerlo. 01:23:02

Estas son las dos simultáneas y en esta una u otra. 01:23:06

Si resulta que no es divisible por 7 ni termina en 4, 01:23:11

pues nada, no se ejecuta ni el if ni el else, 01:23:15

con lo cual no se acumula nada por aquí, 01:23:17

y no se acumula nada, pues ya está. 01:23:20

Y luego el método, si queremos que saque por pantalla el resultado, 01:23:23

pues una vez acabado el for 01:23:27

pues podríamos hacer aquí un system.out.println 01:23:30

o que terminen 01:23:34

en 4 entre 01:23:50

si alguien pregunta que no entiende para qué estamos acumulando 01:23:54

porque ha denunciado 01:24:06

que estamos planteando para el ejercicio que igual no era justo 01:24:08

el del examen pero el que estoy planteando yo a la hora de hacerlo 01:24:12

aquí es que el resultado a sacar 01:24:15

sea la suma de todos los números comprendidos entre estos dos 01:24:18

y que cumplan esta condición. 01:24:29

Entonces, para que sea la suma, al principio es 0 01:24:33

y luego ya vamos acumulando el número que toca al resultado 01:24:36

para que con todo acumulado termine saliendo por aquí. 01:24:40

Vale, pues entonces sería la suma de los números divisibles por 7 y por 4. 01:24:48

Bueno, esto es para adornar el resultado que quede un poquito más acorde a lo que dice el enunciado. 01:24:52

Entre, y ponemos, y, ponemos aquí, es, y ahora ya por fin ponemos lo que de verdad es el resultado. 01:24:59

Es aquí el irresol. 01:25:24

Aquí me falta un más y, bueno, pues vamos a hacer una ejecución. 01:25:25

dice los números, entre 4 y 100 es, bueno, pues nos da este número 01:25:33

que en principio no lo tenemos que creer, vamos a hacer una llamada 01:25:41

con unos números que se pueda calcular, por ejemplo, vamos a poner 01:25:45

entre 3, que aparece el 4, y entre 8, con lo cual tenemos un 4 01:25:50

y tenemos el 7, 7 más 4, 11 debería dar de resultado, yo creo esto. 01:25:57

Bueno, pues nos dice el 11. Vamos a poner entre 3 y 14. El 14 es divisible por 7 y además termina en 4. Entonces tendríamos el 4, tendríamos el 7 y el 14. 01:26:02

4, 7 y 14, entonces sería 14 más 4, 18 más 7 01:26:27

yo creo que debería dar 25, vamos a ver, pues no 01:26:31

es 11, debería dar el 4, el 7 01:26:37

ah vale, bien, ya sé lo que ha pasado 01:26:50

lo que ha pasado es que aquí le he puesto la condición 01:26:55

de que i sea menor que i val 2, con lo cual como he puesto menor 01:26:59

no está considerando el 14, se ha quedado en el 13 01:27:04

tendré que poner aquí que sea menor o igual para que considere 01:27:07

para que este lo opere 01:27:12

vamos a ejecutar, efectivamente 25 01:27:16

entiendo que en entornos, la asignatura, no sé si la habéis 01:27:22

cursado ya, hay un momento en el que se hacen las pruebas de caja blanca 01:27:27

pruebas de caja negra, una serie de cosas ahí, y dentro de las pruebas 01:27:32

hay que decidir qué valores probar, entonces entre los que 01:27:37

se suelen probar, siempre hay que mirar los números límite. 01:27:40

Entonces, si la ejecución la hacemos a 14, pues uno de los valores 01:27:45

a probar sería aquí, o sea, utilizar la prueba 01:27:48

14 porque es un valor límite de los que cumplen la condición. 01:27:52

Bueno, pues ya está, mirad, aquí ha salido este. Y si 01:27:58

tuviéramos la otra consideración que habíamos dicho, que tengan que ser 01:28:01

de forma simultánea las dos cosas, pues justo con estos datos 01:28:05

el 14 vale para los dos, entonces podríamos poner aquí if 01:28:10

vamos a comprobar que también funciona eso 01:28:14

si es igual a 7 y and 01:28:17

la otra condición está, pues acumulamos 01:28:28

en este caso, en este caso ya se tienen que dar las dos condiciones 01:28:40

para que se acumule, entonces si se tienen que dar las dos condiciones 01:28:44

con estos datos, el 4 que está entre el camino 01:28:47

del 3 y el 14 cumple que acaba en 4 pero no es divisible entre 7 01:28:52

el 7 es divisible entre 7 pero no acaba en 4 01:28:56

entonces el único valor que sería correcto sería el 14, entonces con esta nueva condición 01:29:00

es de esperar que el resultado que nos salga es en lugar de 25 01:29:04

14, efectivamente por aquí nos da los 01:29:08

y nada, pues esto era uno de los ejercicios que pedíamos 01:29:12

fijaros que al final 01:29:23

pues es esto 01:29:26

en lo que consiste el ejercicio 01:29:27

también es cierto que hay que caer 01:29:30

y estáis ahora entrenando pero que 01:29:32

cuando a veces os dábamos 01:29:34

poco espacio 01:29:36

ahí en el folio 01:29:38

en realidad se resolvía 01:29:39

pedía el método, incluso este que es un poquito 01:29:41

más largo, bueno pues 01:29:44

se resolvía en este trocito 01:29:48

si, vamos a 01:29:50

repasarlo, si queréis más o menos 01:30:13

como más o menos me acuerdo yo que no estará 01:30:14

muy lejos de como era el enunciado 01:30:16

Vamos a definir una clase Persona, y en esta clase Persona ponemos dos atributos. 01:30:20

No me acuerdo, era int dni, vamos a poner el dni como un número, y luego int edad, int y dni. 01:30:33

Entonces resulta que había un método que recibía un array de personas y un número. 01:30:47

static, vamos a llamar al método 01:31:03

por ejemplo per 01:31:09

yo creo que el enunciado venía a decir algo como que se recibía un array 01:31:10

y había que mostrar algo así como el valor 01:31:35

también acumulado de las edades que tenían todas las personas 01:31:40

cuyo DNI acabase en un determinado valor 01:31:43

vamos a poner inum, entonces fijaros que 01:31:47

las personas tienen un dni y una edad es esto lo que lo que se pide es este desarrollo que 01:31:58

en algún momento le llegará el array y el número en algún sitio habría construido un array o sea 01:32:07

definir aquí una rey persona de personas igual año persona o sea a dimensionar el array por 01:32:13

ejemplo con tres personas y ahora para cada una de las tres personas vamos a darle uno de unos 01:32:27

determinados valores esto no tenéis que hacer tenéis que hacer esta parte ya se recibía la 01:32:33

raíz y el número pero bueno para la ejecución pues es necesario también hacer esta parte para 01:32:39

la ejecución aquí dentro del ide entonces cogemos y ponemos a arpear la posición 0 aquí podríamos 01:32:44

hacer un bucle, ¿verdad? Pero bueno, no nos enredamos con eso ahora, persona 01:32:51

lo construimos y decimos que 01:32:55

arp0.idni, vamos a decir que 01:33:02

tiene el dni 14, el número sería 01:33:05

no es un dni real, pero bueno, para persona 1 01:33:09

y vamos a poner un nombre también, no, es una edad 01:33:13

arp0.iedad 01:33:17

punto, y edad, yo que sé, que deciros, pues que tiene de edad 10 años, como hemos dimensionado esto para 3, vamos a dar valores a 3 personas, voy a ponerle 24, para que el DNI coincida el último número, que es la condición que dice el enunciado, vamos a decir edad 11, esta, segunda persona, y luego la tercera de las personas, este lo vamos a poner diferente, vamos a hacer que su DNI no acabe en 4, vamos a hacer coincidir el último número del DNI de 2 de ellas, 01:33:23

Y de una no, luego si acaso lo cambiamos, ¿vale? Y hacemos diferentes pruebas con diferentes valores. Y este que tenga una edad de 12. Y lo que vamos a hacer va a ser llamar a este método, ver, le vamos a pasar el array y el número que queremos que valide como último del DNI para, como criterio para acumular las edades. 01:34:05

entonces he aprovechado para poner 01:34:42

este de 14 y este de 24 para que 01:34:44

dos acaben en 4 y ahora vamos a 01:34:46

hacer una primera ejecución aquí 01:34:48

diciéndole que el número que queremos que se utilice 01:34:49

sea el 4 01:34:52

a ver 01:34:53

¿por qué no me compila esto? 01:34:55

vale, es que he puesto aquí 01:35:21

que recibe una persona 01:35:22

y no una raíz de personas, ¿veis? 01:35:24

le estoy pasando una raíz de personas 01:35:27

y aquí le he dicho 01:35:28

oye, mira, el primer parámetro es una persona 01:35:30

y lo que recibe es un array de personas. 01:35:33

Ahora ya me compila. 01:35:36

Pues nada, entonces aquí, independientemente de que esta llamada 01:35:39

se está haciendo con este array y un 4, 01:35:43

podría ser con cualquier array de personas y con cualquier otro número, 01:35:46

ahora trabajamos en el método para dar solución 01:35:49

a lo que tiene que gestionarse dentro de ese método 01:35:51

y estos datos para probar que efectivamente luego funciona el método. 01:35:55

Luego le damos variantes. 01:36:00

entonces lo que nos venía a decir el ejercicio es 01:36:01

vamos a acumular las edades de aquellas personas cuyo 01:36:05

DNI termine en 4, pues algo parecido a esto 01:36:08

a la hora de acumular, cogemos y decimos int 01:36:11

y result 01:36:14

igual a 0, vamos a acumular, bueno result vamos a poner 01:36:16

edad, o suma edad 01:36:20

para que tenga un dato, inicialmente todavía no 01:36:23

hemos comprobado ninguna persona, pues la edad acumulada 01:36:26

será de cero. Esto lo que recibe es una referencia de este array de personas. 01:36:29

Este array de personas, cuando hicimos su new, pues ya hubo una reserva de memoria 01:36:39

y luego para cada una de las personas tiene su reserva de memoria. 01:36:43

Entonces, esto estará apuntando a la misma posición de memoria al pasarlo por aquí 01:36:46

que esta otra. Entonces, el array de personas que está recibiendo aquí 01:36:50

ya tiene su espacio de memoria reservado con ciertos datos, porque es una posición 01:36:54

de memoria en particular porque se hizo esa reserva por aquí con lo cual aquí podemos trabajar con el 01:36:58

array de personas y en esta ejecución en particular teniendo en cuenta que los datos son estos y en 01:37:06

otra ejecución en particular definiríamos otro array de personas posiblemente dimensionado con 01:37:12

un tamaño diferente y con otros datos distintos con lo cual ese otro array de personas sería el 01:37:16

que al que apuntaría esta variable local al método per entonces para recorrer cada una de las personas 01:37:21

¿Cómo lo hacemos con el array? Pues con un bucle for int i igual a cero. Mientras i sea menor que el tamaño, porque queremos recorrer todas las personas, que es su longitud, hacemos un i más más. 01:37:29

para cada... Fijaros, esto es un array de personas, ¿verdad? 01:37:46

Esto es una persona, lo que estamos comentando. 01:37:59

¿Y qué queremos comprobar? Como esto está dentro de un bucle 01:38:03

recorriendo todo el array, en cada una de las ejecuciones esto iterará para una de las 01:38:07

personas en particular de ese array. Y lo que queremos 01:38:11

comprobar es si su DNI justo termina en este 01:38:15

número. Lo hemos hecho aquí. Fijaros. 01:38:19

Entonces podemos decir, if punto idni es igual, perdón, módulo 10, si esto es igual a el número que recibo aquí, ¿qué es lo que hago? Pues acumulo edades. 01:38:24

entonces el y suma edad será igual a lo que ya lleva acumulado hasta ese momento más la edad de 01:38:53

la persona está en particular como esto lo recuerdo para cada una de las personas aquellas que cumplan 01:39:03

esta condición es decir que su último dígito en el dni coincida con el parámetro este que está 01:39:14

recibiendo veis aquí la condición esa del if en ese caso acumulamos la edad y luego que nos queda 01:39:21

hacer después del for cuando hayamos recorrido todas las personas vamos a dar un poco el 01:39:28

resultado como siempre de las edades de las personas cuyo dni termina en es pues está aquí 01:39:48

lo tenemos entonces ejecutamos por aquí vamos a ver si de verdad funciona fijaros que la ejecución 01:40:20

la estamos haciendo, ahora modificamos en alguna otra ejecución 01:40:27

los datos, cargamos el array este de personas 01:40:29

y decimos que compruebe 01:40:33

como último dígito del DNI 01:40:35

que sea un 4, entonces ese criterio lo cumple 01:40:38

tanto esta como esta, pero esta no, que es 22 01:40:41

y las edades son 10 y 11 01:40:44

con lo cual es previsible que el resultado que nos dé 01:40:47

si el código lo hemos puesto bien, si no pues habrá que depurar 01:40:50

sea 10 más 11, 21 01:40:53

entonces le damos aquí a la ejecución y aquí nos lleva 01:40:55

que es 21, ¿veis? 01:40:57

si hacemos una ejecución 01:41:00

en lugar de decir 14 y 24 01:41:01

que el DNI acabe en 2 01:41:03

pues como es 01:41:05

solamente esta 01:41:07

la que lo cumple, pues es de esperar 01:41:08

que nos diga que la edad es 01:41:11

12, ahí lo tenéis 01:41:13

si decimos que sea en 3 01:41:15

pues nos tendría que decir que es 0 01:41:19

porque ahora mismo ningún DNI está acabando en 3 01:41:20

pues nos dice que es 0 01:41:23

y bueno pues 01:41:25

vamos a poner aquí 34 01:41:28

y vamos a decir que compruebe el 4 01:41:30

para que se cumplan todas ellas 01:41:32

con lo cual sería 10, 21 01:41:35

23, 33 01:41:39

entonces el código 01:41:41

pues sería este 01:41:47

el que pedíamos ahí 01:41:50

que bueno ya veis que 01:41:53

bueno pues si que es 01:41:57

que no digo yo que sea fácil 01:41:58

que estáis ahora aprendiendo, bueno, algunos lo habéis hecho bien, pues yo que sé, se ve que tenéis 01:42:00

destreza ya con Java, por lo que habéis aprendido, por el bagaje que tengáis anterior 01:42:04

y los que estáis ahora sobre todo arrancando más con Java, pues 01:42:08

pues cuesta a lo mejor llegar a la conclusión de plantearlo así 01:42:12

pero lo que quiero deciros es que no, en principio pues no pedimos 01:42:16

grandes cantidades de código ahí para que os tengáis que volver locos 01:42:20

ya veis que en realidad se resolvía con 10 líneas de código 01:42:24

con las dificultades que tiene 01:42:28

y bueno, pues eso, que estéis entrenando 01:42:31

para saber hacer 01:42:32

todo esto. ¿Lo veis? 01:42:34

Sí. Vale. 01:42:42

Vale. Sí. 01:42:44

Bueno, pues 01:42:46

pues nada, yo creo que ya no os voy a contar 01:42:47

nada más. Ya estamos en las siete y cuarto 01:42:49

a no ser que tengáis alguna duda por ahí. 01:42:51

Os he puesto, a los que os habéis presentado 01:42:53

os he puesto las notas ya ahí en el aula virtual 01:42:56

bueno, pues echarle un ojo 01:42:58

y he pensado que mejor que 01:42:59

cerrar un día que sé que andáis con trabajo 01:43:01

y os resulta mejor 01:43:04

complicado venir en un momento en particular 01:43:05

pues lo dejo abierto 01:43:08

a cualquier lunes, si alguien quiere ver 01:43:10

su examen cualquier lunes 01:43:11

luego claro, esto tiene el inconveniente de que sí 01:43:13

que es cierto que tenéis que cerrar conmigo 01:43:15

cuando vais a venir, porque yo 01:43:17

en principio mi jornada de trabajo es por la 01:43:19

mañana, solo vengo a daros la tutoría 01:43:21

y en cuanto acabo me marcho a casa 01:43:23

entonces a ver si alguien se va a pegar un viaje desde lejos 01:43:25

va a llegar aquí y ya no me va a pillar 01:43:27

entonces quien quiera ver su examen 01:43:29

me lo decís y justo al terminar la tutoría 01:43:31

quedamos 01:43:34

uno o dos, los que sean, este lunes 01:43:35

el siguiente, me da igual cuando sea 01:43:38

o si uno no puede, os digo, este no puedo, a ver al siguiente 01:43:40

que lo concretamos, es decir, lo tenemos que concretar 01:43:42

y nada, os paséis 01:43:44

a verlo cuando queráis 01:43:46

vuestro examen si queréis 01:43:47

nada, nada, sobre 10, sobre 10 01:43:49

sí, sí, sí, sí 01:43:59

sí, sí 01:44:00

que conste que me di cuenta 01:44:01

y digo, va, voy a poner la aclaración 01:44:04

Luego se me pasó, pero no, no, es sobre 10, sobre 10, sí, sí. 01:44:06

Sí, no tiene nada que ver una nota en particular si es sobre 10 o si es sobre 100, nada que ver, sí, sí, no, sobre 10. 01:44:11

Y nada, pues nada, si no tenéis nada que consultarme, pues aquí cerramos ya, por hoy, la semana que viene más. 01:44:21

La semana que viene repasamos cosas del tema 7, ¿sí? 01:44:30

pues nada, venga 01:44:37

como siempre os subo 01:44:39

la clase al aula por si la queréis 01:44:43

volver a echar un ojo en algún momento 01:44:45

venga, buena tarde, hasta luego 01:44:46

2025-02-17-Programacion - Contenido educativo

Del mismo autor…

Video STEM 25-26

EXPLORADORES DEL HIELO

Vídeo resumen Rebeldes

Video motivación 1

Vídeo resumen Nunca seré tu héroe

Lágrimas de Shiva

ipe04