Saltar navegación

20241212 POO-Clases-Ejer_2 - 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 13 de diciembre de 2024 por Raquel G.

23 visualizaciones

Más información Transcripción

Descargar la transcripción

A ver, habéis arrancado esto, como de costumbre, leyéndolo todo entero, haciéndonos una visión global de para qué sirve esta aplicación. 00:00:00
Si uno después de leer un enunciado, algo que le han planteado, no entiende qué utilidad tiene eso, 00:00:11
entonces o el enunciado está mal explicado o uno tiene que volverse a leer, porque una aplicación tiene que ser útil, 00:00:16
tiene que trabajar, tiene que servir para algo. 00:00:23
Entonces, bueno 00:00:25
Esto en particular 00:00:28
Se supone que es una aplicación 00:00:30
Para tener tú los datos de tus amigos guardaditos 00:00:35
Entonces, cuando tú quieres información sobre algún colega 00:00:40
Pues le das a un botoncito 00:00:44
Y te da la información de ese colega 00:00:46
Lo que sea que tenga 00:00:48
Que en este caso es el nombre, la edad y la dirección 00:00:51
Bueno, pues ya está. Esos tres datos son los que parece ser que te interesan, ¿vale? Entonces, para que esa aplicación sea útil, pues tú además tienes que poder incorporar amigos nuevos o eliminarlos cuando ya no son tus amiguitos, ¿vale? Pues ya está, simplemente para eso, para guardar información de personas, de amigos, de compañeros, de lo que sea, y tener ahí esa información guardada para cuando quieres visualizarla. 00:00:54
Vale, pues entonces 00:01:17
Para eso, esta aplicación 00:01:19
Tiene dos entidades solo 00:01:21
¿Con qué trabaja? 00:01:23
Con personas, pues ya está, una entidad 00:01:25
Persona, y luego 00:01:27
Lo que guarda 00:01:29
La información es una libreta 00:01:31
Una libreta que tiene un montón de personas 00:01:33
Pues entonces hay otra entidad 00:01:35
La libreta que tiene la información 00:01:37
Y la persona 00:01:39
Pues dos entidades, pues ya está 00:01:41
Pues entonces empezamos con 00:01:43
Persona, y ahora 00:01:45
como fruto del análisis y del diseño 00:01:58
nos tiene que haber quedado claro 00:02:01
qué atributos nos interesan 00:02:02
de la persona 00:02:05
pues en este caso pone ahí 00:02:06
nombre, edad y dirección, pues ya está 00:02:08
pues entonces decidimos el tipo de datos 00:02:10
y ya 00:02:13
nos sale 00:02:15
de corrido, porque es 00:02:17
lo habitual, que las propiedades 00:02:18
sean privadas 00:02:21
¿vale? y luego yo según el curso 00:02:22
de la aplicación 00:02:25
pues decido si los get y los set 00:02:26
son necesarios los dos o solo uno 00:02:29
porque solo son propiedades de lectura 00:02:30
entonces quito el set 00:02:32
entonces 00:02:33
en nombre como dirección también es 00:02:35
string y edad 00:02:41
privadas 00:02:47
entonces si son privadas 00:02:51
para que otras clases 00:02:53
puedan recuperar sus valores 00:02:55
o puedan cambiar 00:02:57
sus valores si es que yo quiero dar permiso 00:02:59
vamos a necesitar los get y los set 00:03:01
Porque con el modificador privado 00:03:03
Nadie fuera de la clase 00:03:05
Va a poder acceder al punto nombre 00:03:07
Punto dirección, punto edad 00:03:09
Entonces o los escribimos a mano 00:03:10
Porque tecleamos muy rápido 00:03:12
O hacemos generar getter and setters 00:03:14
Seleccionamos todos 00:03:17
Pues lo que hice el otro día 00:03:19
¿No lo habéis visto en la grabación 20 veces? 00:03:24
Source 00:03:27
O vosotros sois muy lentos 00:03:28
Una de dos 00:03:36
Source 00:03:38
Generate Getter Sunsetters 00:03:41
Con mi inglés 00:03:44
A ver, yo hablo mejor inglés de lo que parece 00:03:45
Pero aquí 00:03:48
Lo leo así para que no quede duda 00:03:49
De la opción que queremos 00:03:51
¿Ya está? 00:03:52
Pues ya está 00:03:58
Entonces, todos entendemos ya estos métodos, lo que son, para qué sirven, que tenemos que seguir un convenio de nombres para que se llamen de esta manera, GET, SET con la propiedad en mayúscula, con la inicial de la propiedad en mayúscula, que son métodos public porque se van a usar desde cualquier sitio para acceder a las propiedades, etc. 00:03:59
Vale, ¿qué más hacemos siempre por sistema en una clase? 00:04:19
Ahora crear los constructores. 00:04:24
Los constructores. 00:04:25
Uno vacío y otro... 00:04:27
Claro, porque si no, tengo yo siempre 00:04:28
que instanciar el objeto y luego con los set 00:04:30
irle dando valores, que muchas 00:04:32
veces lo hacemos así, creamos el objeto 00:04:34
y luego con los set le damos valores, pero 00:04:36
si hacemos un constructor con parámetros, 00:04:38
pues puedo 00:04:43
a la vez que instancio una persona 00:04:44
en concreto, a la vez que la instancio, 00:04:46
pues puedo ya darle unos valores 00:04:49
iniciales. El super 00:04:50
sí que lo quito, porque el super sí que seguimos 00:04:52
sin tener ni idea de lo que significa. 00:04:54
Vale, entonces, 00:04:57
desde el momento en que 00:04:58
he sobrescrito el constructor que está 00:04:59
por defecto por debajo sin yo verlo 00:05:02
que es el sin parámetros 00:05:04
desde que lo he sobrescrito con esto 00:05:05
ese sin parámetros me ha desaparecido 00:05:07
pues una pena, porque seguramente 00:05:09
hay gente que quiere crear personas 00:05:12
sin darle valores todavía 00:05:13
pues entonces vamos a ponerle también 00:05:15
el constructor sin parámetros 00:05:18
ay, que sueño 00:05:19
vale 00:05:26
Perdón 00:05:37
Que super 00:05:45
Ah, sí, sí, sí 00:05:46
Este es super 00:05:48
Vale, voy a ir haciendo en paralelo 00:05:50
Un main para ir viendo 00:05:53
Ciertas cosas, ¿vale? Aunque no sea el main 00:05:55
De mi aplicación 00:05:57
El main de mi aplicación ya pues 00:05:58
No sé si me dice aquí que haga un main con un menú 00:06:00
O con tonterías 00:06:02
No, bueno, pues podemos hacer un main 00:06:04
Con un menú 00:06:07
Para probar las funcionalidades 00:06:09
De esto 00:06:12
Y así lo vamos entendiendo mejor 00:06:12
Vale 00:06:18
Bueno, lo que pasa es que antes de 00:06:22
Arrancar con el main, vamos a hacer la otra entidad 00:06:26
La libreta de direcciones, porque el main tendrá que 00:06:28
Crear una libreta 00:06:30
¿Vale? Y ya con esa libreta trabajar 00:06:31
Metiendo personas o no 00:06:34
Bueno, pues entonces 00:06:35
La clase persona por ahora está, ya no necesita nada más 00:06:38
Porque la clase persona 00:06:40
No tiene métodos 00:06:44
La libreta es la que va a tener 00:06:46
Los métodos para hacer las cosas 00:06:48
Para meter una persona nueva, para quitarla 00:06:50
En la libreta es donde están las personas dentro 00:06:52
Y la libreta 00:06:54
Es la que va a tener las funcionalidades 00:06:56
De incorporar persona, quitarla 00:06:58
Porque es la que tiene las personas dentro 00:07:00
Esta no tiene funcionalidades 00:07:02
Esta sirve solo para 00:07:06
Guardar el objeto 00:07:07
¿Vale? 00:07:09
Pues venga, hacemos la 00:07:11
Otra entidad 00:07:12
Vale, pues la libreta, ¿por qué se va a caracterizar? 00:07:15
Única y exclusivamente 00:07:26
Por los contactos que tiene dentro 00:07:27
Ya está, se va a caracterizar por los contactos 00:07:29
Que tiene dentro 00:07:31
¿Cuántos contactos va a tener? Muchos 00:07:32
Entonces, si va a tener muchos 00:07:35
La propiedad va a tener que ser 00:07:37
Un array, ¿vale? 00:07:39
Porque ese es el tipo de dato 00:07:41
Para guardar muchos de algo 00:07:43
Hasta ahora 00:07:45
Que no hemos incorporado ningún otro 00:07:47
Bueno, pues muchos de qué 00:07:48
persona 00:07:53
lo voy a llamar contactos 00:07:55
que queda más bonito que persona 00:07:59
vale, pues esta es 00:08:00
la propiedad 00:08:02
persona, perdón 00:08:03
la propiedad contactos, que caracteriza 00:08:06
la libreta, que es toda su colección de 00:08:08
contactos, y como son muchos 00:08:10
pues tiene que ser array, porque son muchos 00:08:12
ahora, si yo le doy el privado 00:08:14
pues lo mismo, tengo que ofrecer 00:08:17
un get y un set 00:08:18
De esta única propiedad 00:08:19
Y vamos a ponerle 00:08:24
Constructor con y sin parámetros 00:08:29
Ya casi como rutina 00:08:32
No te confíes 00:08:35
Vale 00:08:51
Pues desde el momento en que ya hemos decidido 00:08:58
Que la libreta 00:09:00
Solo se caracteriza por eso 00:09:02
Es lo único 00:09:04
La libreta se caracteriza por los lazos que tiene dentro 00:09:05
A la aplicación no le interesa 00:09:07
Ni el color de la libreta 00:09:09
ni en qué sitio está guardada 00:09:11
no le interesa nada más, solo esto 00:09:14
pues del momento en que me he llegado a esa conclusión 00:09:15
esta parte de aquí ya 00:09:17
prohibida, ahí ya no se 00:09:19
escribe absolutamente nada más 00:09:21
no se escribe nada más, porque cualquier 00:09:23
cosa que se escribiera ahí 00:09:25
sería algo que caracteriza la libreta 00:09:27
y no necesitamos nada más 00:09:30
para caracterizarla, solo los contactos 00:09:32
que tiene dentro, luego esa zona ya está 00:09:33
prohibida, ahí ya no se mete nada 00:09:36
si yo necesito algo para operar con mis métodos 00:09:37
Pues serán variables locales del método 00:09:40
O parámetros que pasó desde fuera 00:09:42
En la llamada, lo que sea 00:09:44
Pero ahí ya nada, esa zona ya 00:09:45
Está protegida 00:09:47
Vale, pues entonces 00:09:49
Ahora ya esta aplicación tiene funcionalidades 00:09:53
Lógicamente, que son 00:09:56
Meter una persona 00:09:57
Aquí, en la libreta 00:09:59
Sacar una persona de la libreta 00:10:02
Verla, ver 00:10:03
Las personas que hay 00:10:05
Buscarla por nombre, etc 00:10:08
Ya tiene funcionalidades. ¿Esas funcionalidades de qué son? De la libreta. Pues entonces tiene sentido que lo pongamos como métodos aquí, no aquí. Yo hacer un método con una, no, aquí. Bueno, pues ¿cuáles me han pedido? Pues vamos a meter una persona en la lista. Agregar persona, contacto, como lo queráis llamar. 00:10:10
Vale, pues este método 00:10:30
Voy a poner public 00:10:32
Porque en principio 00:10:35
Esto lo podría usar 00:10:36
Desde cualquier otro paquete 00:10:38
Una vez que yo tengo ya esta libreta hecha 00:10:40
Pues la puedo distribuir 00:10:43
Y cualquier otra aplicación puede usarla 00:10:44
Bueno, pues entonces 00:10:46
El método 00:10:50
Que va a devolver 00:10:53
El método este de 00:10:54
Pero 00:10:55
De verdad estáis diciendo todos un estriño 00:11:03
Si estáis quedando tan anchos 00:11:05
¿de verdad estáis diciendo 00:11:06
todo eso? a ver, esto no es tan trivial 00:11:16
claro, esto os permito que lo digáis 00:11:17
sin enfadarme 00:11:19
a ver 00:11:21
agregar persona, vale 00:11:23
pregunta 00:11:25
¿me tiene que devolver algo este método? 00:11:26
ah, vale, es que como he dicho me tiene que devolver un array 00:11:31
ya me estabais asustando 00:11:33
no, porque el efecto 00:11:35
de este método 00:11:37
se hace ya aquí 00:11:38
en esta variable 00:11:40
es decir, este método accede directamente 00:11:41
a la variable esta, accede a esta variable 00:11:45
entonces no hay que pasársela 00:11:46
y el efecto del método 00:11:48
el efecto va a ser modificar esta variable 00:11:50
el efecto va a ser ese, hacer que sea 00:11:53
raíz ya más grande, entonces el efecto 00:11:55
de este método ya se registra 00:11:56
aquí 00:11:58
otra cosa es que a veces se hace 00:11:59
que no lo vamos a incorporar, porque en este caso 00:12:02
pues hacerle que devuelve un boolean 00:12:04
y que el método devuelva true 00:12:07
si ha funcionado correctamente y false si no 00:12:09
y así es una manera de controlar desde fuera 00:12:11
el que lo llame, pero eso es cuando ese 00:12:13
método interacciona con bases de datos, con cosas 00:12:15
que pueden fallar, pero aquí 00:12:17
no estamos interaccionando con nadie, entonces que el método 00:12:18
falle si lo probamos bien es imposible 00:12:21
porque está todo en variables locales 00:12:23
pues entonces un void, vale 00:12:25
efectivamente 00:12:27
¿qué necesita este para 00:12:29
trabajar? 00:12:31
Que le pasemos la persona 00:12:32
Si no, no la va a poder agregar nunca 00:12:34
Vale, pues venga 00:12:35
Y ahora ya está 00:12:38
Ahora ya hacer este método 00:12:40
Pues como es meter una nueva en el array 00:12:41
Array auxiliar, patatín, patatán, etc 00:12:43
Entonces 00:12:46
Hacemos un array 00:12:47
Auxiliar 00:12:50
De personas 00:12:51
Que tenga una posición 00:12:54
Más 00:13:00
Que el array que quiero modificar 00:13:01
contactos 00:13:04
vale 00:13:08
pues hacemos una raya auxiliar con una 00:13:14
posición más 00:13:16
copiamos el 00:13:17
antiguo en el nuevo 00:13:20
aux de i 00:13:22
igual a 00:13:41
contactos 00:13:43
de i 00:13:47
cuando ya hemos copiado 00:13:48
todos excepto la última 00:13:51
posición extra que hemos hecho en aux 00:13:53
pues esa última 00:13:55
posición extra, que es esta 00:13:56
que es 00:13:58
aux.length 00:14:00
menos uno, esta es la última 00:14:03
posición de length, la última 00:14:04
que se ha quedado por ahora vacía 00:14:06
bueno, puede ser contactos.length 00:14:08
pero así se ve claro 00:14:13
que estás accediendo a la última 00:14:14
posición de aux 00:14:17
se ve más claro 00:14:18
vale, esta va a ser la persona 00:14:19
nueva que me han pasado 00:14:23
Y ya este aux es el bueno 00:14:24
El array bueno 00:14:27
Pues entonces 00:14:28
El array antiguo 00:14:30
Este, al que tengo 00:14:33
Jolín con personas 00:14:34
Al que tengo acceso directo a este 00:14:35
Ya le sustituyo por este otro 00:14:38
Y agregar 00:14:42
Joder, aux 00:14:45
No, aquí viene dentro del bucle 00:14:47
¿Hasta cuándo? 00:14:53
¿Hasta cuándo va a ser lo de la llave? 00:14:55
Vale, pues ya está 00:14:57
Agregar persona está 00:15:07
¿Verdad? 00:15:08
Entonces, aquí por supuesto 00:15:10
Me da igual poner el dis 00:15:12
Que no ponerlo, porque me estoy 00:15:15
Refiriendo a lo mismo 00:15:17
Aquí yo podría arrastrar el dis todo el rato 00:15:18
Si quisiera, pero 00:15:20
No hace falta, ¿por qué? 00:15:24
Porque no hay confusión, no hay ninguna 00:15:26
Otra variable aquí dentro que se llame contactos 00:15:28
No hay una variable local contactos 00:15:31
Si yo a este auxiliar 00:15:32
Le hubiera llamado contactos 00:15:34
Entonces ya 00:15:36
Distinguiría discontactos 00:15:39
El viejo 00:15:41
Y contactos sin más el nuevo 00:15:42
¿Vale? 00:15:44
Pero como lo he llamado aux 00:15:46
Pues no hay ninguna duda sobre quién es contactos 00:15:47
Es el de arriba 00:15:50
No hace falta que ponga el dis 00:15:50
Si no quiero ponerlo 00:15:52
¿Vale? 00:15:54
Si hubieran dos que se llamaran 00:15:57
contactos, uno de ellos 00:16:00
por ejemplo, este que me acabo de crear 00:16:02
que lo hubiera llamado contactos en vez de 00:16:04
aus, ahí ya hay ambigüedad 00:16:05
dis.contactos para referirse 00:16:07
al de arriba y contactos a palo 00:16:10
seco para referirse a este 00:16:12
vale 00:16:13
bueno 00:16:15
pues ya está este método 00:16:16
vale, vamos a hacer una 00:16:19
libreta de direcciones y agregarla a una primera 00:16:24
persona, ahora este es mi main 00:16:26
mi main trabaja con una libreta de direcciones 00:16:28
para hacer cosas, pues tengo 00:16:30
Que instanciarla, aquí ya es donde aparecen los objetos 00:16:32
Mi libreta de direcciones 00:16:34
Esta, vale 00:16:37
Y ahora vamos a hacer rápidamente 00:16:48
Menú, un coso 00:16:51
Con las opciones 00:16:55
Que vayamos poniendo 00:16:57
Vamos a poner ya la de salir 00:16:58
Y ahora leemos la opción 00:17:13
Estoy ya deseando 00:17:18
Que veamos lo del escáner 00:17:25
Para olvidarnos 00:17:26
Uy del escáner, del static 00:17:27
Para hacernos nuestra propia librería 00:17:28
De entrada y salida 00:17:31
Y olvidarnos del scanner y del next line 00:17:32
Y de las tontas esas 00:17:35
Poco a poco no 00:17:37
Ya mismo 00:17:39
Vale, pues 00:17:40
Voy hijo 00:17:43
Por favor, estaba en ello 00:17:47
Está fatal 00:17:49
Pues mi criatura 00:17:51
me ha salido fatal, voy a tener que eliminarla 00:17:58
a ver 00:18:00
¿hasta qué edad es legal abortarles? 00:18:01
hasta los 57 años 00:18:06
yo creo 00:18:08
a ver 00:18:08
scan.nextline.charat 00:18:11
no pongo 00:18:20
el next in a propósito 00:18:21
para no andar arrastrando el problema 00:18:24
de la esa 00:18:26
Vale, y ahora ya sí que viene el switch up. 00:18:30
Y ahora, en el caso de que me hayan dado el char cero. 00:18:38
Char, lo estoy leyendo como... 00:18:45
A ver, espera, voy a cambiarlo así para que no haya... 00:18:47
Pero bueno, vale. 00:18:50
En caso de que el char este que me han dado sea el cero. 00:18:51
Vale, pues entonces pedimos los tres datos y se acabó. 00:18:56
Vamos a poner un solo mensaje 00:18:59
Para que introduzca en el mismo orden 00:19:01
Introduzca nombre 00:19:03
Dirección 00:19:09
Y edad 00:19:11
Vale, pues uno 00:19:12
Ya está 00:19:17
Mira, ya está, que difícil 00:19:18
Vale 00:19:25
String nombre 00:19:28
Igual a scan.nextline 00:19:31
Y lo mismo 00:19:38
Nombre, dirección 00:19:42
Y la verdad es que lo podríamos haber metido en el constructor directamente 00:19:50
¿Vale? 00:19:55
Pero bueno, por si 00:19:58
Así vamos a usar las variables 00:19:59
Y edad, scan.nextint 00:20:02
Si metes en el constructor no te paras por comas 00:20:06
Claro, claro 00:20:08
Y así nos ahorramos líneas de código 00:20:09
Pero bueno, como queda así muy larga y no se ve en la pizarra 00:20:11
Vale, pues ya está 00:20:13
Hacemos la persona 00:20:15
Y gracias a que tenemos el constructor 00:20:17
Cuidado en el mismo orden 00:20:20
Que en el 00:20:22
Constructor nuestro 00:20:24
Persona 00:20:26
Si yo le pongo ahí 00:20:31
Nombre, dirección y edad 00:20:32
Es el nombre en el que lo he puesto 00:20:36
Si apoyáis el cursor sobre el S 00:20:37
Igual ya os habéis dado cuenta 00:20:40
Os dice el eclipse 00:20:41
La declaración, vale, pues entonces 00:20:43
En nombre, dirección y edad es el orden en el que 00:20:45
Lo tenemos que meter 00:20:48
Y ahora ya que tenemos la persona 00:20:49
Pues vamos a usar 00:20:58
El método de la libreta 00:21:00
Agregar persona 00:21:02
Que coge ese objeto persona 00:21:06
Y lo mete en el array 00:21:08
Y ahora hacemos aquí un break 00:21:10
Vale, entonces esto ha acabado 00:21:12
El switch, esto acaba el while 00:21:16
mientras la opción 00:21:19
sea distinta 00:21:20
y ahora, antes de ejecutarla 00:21:22
que nadie la ejecute 00:21:25
decidme, ¿qué va a salir? 00:21:26
un error 00:21:31
yo creo que va a salir un error 00:21:31
¿por qué lo has ejecutado? 00:21:33
no, ni lo he ejecutado 00:21:36
ya sé lo que sale 00:21:38
¿qué tipo de error? 00:21:39
el error en la línea 27 00:21:42
no, si va a salir un error 00:21:43
no, pero no sé 00:21:46
pero va a salir un error 00:21:49
no sabéis que 00:21:50
una excepción, empecemos a hablar 00:21:52
con propiedad, no sabéis 00:21:54
que excepción va a salir, no lo intuís 00:21:56
así lejanamente 00:21:58
la excepción 00:21:59
¿eh? 00:22:01
pero esa 00:22:05
¿cómo se llama? 00:22:06
no va a salir esa 00:22:10
esa sale cuando accedes 00:22:12
a una posición 00:22:16
que no 00:22:16
Que no está dentro del rango 00:22:18
De posiciones habilitadas para la RAI 00:22:22
A ver 00:22:24
Vamos a ver 00:22:26
Bueno, input mismatch 00:22:27
Si hay algo que 00:22:28
Pero yo creo que ahora mismo 00:22:29
Con lo que tenemos 00:22:29
Vale, a ver 00:22:30
Bueno, vamos a ejecutarlo 00:22:34
Vamos a ejecutarlo 00:22:35
Vamos a agregar una persona 00:22:39
Introduzca nombre 00:22:41
Dirección 00:22:43
Y edad 00:22:45
Vale 00:22:47
esta es la que yo 00:22:48
esperaba que me dijerais 00:22:51
null pointer exception 00:22:53
esta es la eterna excepción 00:22:54
del mundo mundial de Java 00:22:57
de hecho hay una clase 00:22:58
que ya os contaré en el futuro 00:23:00
que es la clase optional 00:23:02
que se ha hecho solo para evitar 00:23:05
los null pointer exception 00:23:07
la clase optional se ha hecho para 00:23:08
envolver a un objeto 00:23:10
e incorporar la opción de que el objeto 00:23:12
esté ausente o esté presente 00:23:14
Entonces, si el objeto está ausente 00:23:17
No te da un 00:23:21
Es null, no te da un null pointer exception 00:23:22
Lo que te dice es un opcional vacío 00:23:24
Pero bueno, esto es otro rollo 00:23:26
Y es muy útil lo del opcional 00:23:28
Pero bueno, para 00:23:30
Ha salido un null pointer exception 00:23:31
¿Y por qué? 00:23:33
Era 00:23:36
Podíamos preverlo 00:23:36
Vamos a mirar a 00:23:39
Agregar persona 00:23:42
¿Qué ha hecho agregar persona? 00:23:43
pues se ha hecho ahí un 00:23:45
contactos.length 00:23:47
y contactos 00:23:49
que es, la primera vez 00:23:52
que arranca, cuando instanciamos 00:23:54
el objeto libreta direcciones 00:23:56
aquí hay un pedazo de 00:23:57
array null 00:23:59
claro, entonces cuando creamos 00:24:00
la libreta, creemos ya 00:24:04
directamente una libreta con 00:24:06
cero posiciones, que eso no es 00:24:07
null, no es lo mismo una libreta 00:24:10
un array con cero posiciones que un array null 00:24:12
entonces, o bien lo hacemos 00:24:14
aquí en el constructor, o ya como 00:24:17
cuando declaramos una propiedad 00:24:19
podemos ya, en el momento de declarar las propiedades 00:24:20
de un objeto, darle un valor 00:24:23
y eso significa, cuando 00:24:25
instancia es un objeto 00:24:27
va a recibir este primer valor 00:24:28
luego ya se llama el constructor, si el constructor 00:24:31
lo modificara, se quedaría modificado 00:24:35
pero si aquí añadimos un valor en cualquier propiedad 00:24:36
aquí también, en estas 00:24:39
si aquí pusiéramos unos valores 00:24:40
cuando el objeto se instancia 00:24:42
esas propiedades reciben ese 00:24:44
valor por defecto al principio 00:24:46
ese valor por defecto 00:24:48
vale, pues nosotros 00:24:50
todas las libretas de direcciones que se instancien 00:24:52
todas, queremos que se instancien 00:24:54
ya con un array 00:24:56
a cero 00:24:58
posiciones, todas 00:25:00
aquí no tiene sentido 00:25:02
porque yo cuando creo una persona 00:25:04
cada persona tendrá un nombre, una dirección 00:25:06
pues pasaselo por aquí y ya está 00:25:08
pero aquí 00:25:10
Sea cual sea la libreta que tú crees 00:25:11
Sea cual sea, vas a querer que se cree 00:25:14
Con un array vacío ahí 00:25:16
¿Vale? 00:25:17
Entonces ahora si hacemos esto 00:25:20
Bueno, ahora vamos a ver 00:25:22
¿Qué error sale? 00:25:24
Introduzca nombre 00:25:29
Dos años 00:25:30
Vale, pero esto es otro error 00:25:33
¿Vale? Este ya es otra cosa 00:25:35
El index 0 de 00:25:37
sí, pero esto es por el 00:25:39
escáner que cuando leo las opciones 00:25:42
me ha cogido, pero que vamos a revisar esos 00:25:44
vamos a revisar esa 00:25:46
es que a ver si llevamos el static de una vez y cambiamos 00:25:47
esto 00:25:50
eh? 00:25:51
sí, o sea, es que yo no lo he 00:25:55
revisado, lo he dicho, bueno, aquí habrá que 00:25:56
poner el next line donde toque 00:25:58
y vale, entonces aquí 00:25:59
el problema ha sido, obviamente, que después del 00:26:03
next line se queda el salto de línea, este 00:26:06
Next line, coge el salto de línea, char a cero 00:26:08
El salto de línea, strain in, desbound 00:26:10
¿Vale? Entonces, aquí 00:26:12
Después de este next int, nos falta el 00:26:14
Scan punto 00:26:16
Next line 00:26:18
¿Vale? 00:26:19
Sí, a ver, si yo hubiera leído esto 00:26:24
Con next int 00:26:26
Pues después de este next int 00:26:27
No habría problema, porque, pero 00:26:30
El problema es leer una cadena 00:26:31
Después de un número 00:26:34
Eso, cuando viene un line 00:26:35
Después, porque si viene un next 00:26:38
In o un next double, el salto de línea lo elimina 00:26:40
Pero es el next line el que lo coge 00:26:42
Como válido 00:26:44
Entonces 00:26:44
Ahora ya sí 00:26:46
Vale 00:26:49
A ver 00:26:52
Confiamos en que lo ha agregado 00:26:54
A lo mejor no lo ha agregado 00:26:57
Vamos a hacer desde ya el método 00:26:58
De mostrar la persona para ver si realmente 00:27:00
La ha mostrado 00:27:03
Venga, agregar persona 00:27:04
Vamos a hacer el método, obtener información 00:27:07
De todas las que hay 00:27:09
Ya está 00:27:11
Ni siquiera buscamos por nombre ni nada 00:27:13
Tendría más sentido buscar la información por nombre 00:27:14
Pero bueno 00:27:17
Vale, pues como lo vamos a hacer 00:27:17
Directamente 00:27:21
Como es un montón de cosas las que hay que mostrar 00:27:23
Que ya te haga el system out dentro 00:27:25
Porque como te devuelva todo en un stream 00:27:27
Te va a devolver un pedazo de stream 00:27:29
Te podría ir 00:27:30
Formando un stream, concatenando 00:27:33
Con toda la información y devolverte el stream 00:27:35
para que luego tú la muestres donde te dé la gana. 00:27:37
Pero bueno, que directamente lo muestre el método dentro 00:27:40
y se acabó. 00:27:43
Vale, mostrar información, ¿necesita algún dato de fuera? 00:27:49
Pues no, porque va a mostrar la de todas. 00:27:53
Vale, entonces, toda la información que necesita 00:27:58
está aquí en este array. 00:28:01
Luego no necesita nada desde fuera. 00:28:03
Vale, pues entonces ahora ya este será un bucle. 00:28:05
Aquí sí que podemos hacer un 00:28:08
For each, ¿vale? 00:28:13
Porque vamos a consultar solamente 00:28:15
Y si no 00:28:17
Pues estarás restringiendo 00:28:19
Tus opciones de aprendizaje 00:28:21
Te estarás limitando a ti mismo 00:28:23
Si no lo usas nunca 00:28:29
Bueno, como en colecciones 00:28:31
Lo usamos todo el rato en conjuntos 00:28:37
Vale, entonces 00:28:38
Esto ya, como, a ver 00:28:40
el forEach cuando elegimos usarlo. 00:28:42
Cuando vamos a recorrer un array 00:28:44
entero de principio a fin. 00:28:46
Entero de principio a fin. Y cuando 00:28:48
solamente vamos a consultar 00:28:50
información. Ahí el forEach es muy 00:28:52
cómodo, porque ya sabemos lo que significa. 00:28:54
Va recorriendo este array 00:28:56
de principio a fin. No tengo opción 00:28:58
de salirme a la mitad, a menos que haga un break 00:29:00
ahí porque me dé la gana. Lo recorre de principio 00:29:02
a fin. Y en cada iteración 00:29:04
esta cosa P 00:29:06
es cada uno de los 00:29:08
objetos del array contactos. 00:29:10
sí, pero para mostrar 00:29:12
me da igual mostrar a través de la copia 00:29:16
que de sí mismo 00:29:18
vale, entonces vamos a 00:29:18
aprender un poquito más 00:29:21
una chorradita pero útil, imprescindible 00:29:24
vale, entonces 00:29:25
nosotros queremos mostrar 00:29:27
todos los datos de la persona 00:29:29
menudo rollo es poner aquí 00:29:31
p.get 00:29:34
nombre 00:29:35
más 00:29:36
p.get dirección 00:29:39
Dirección más p.get edad. 00:29:47
¿Qué es lo que tengo que usar para mostrarlo? 00:29:56
Porque el p.nombre sin más no podemos porque p es privado. 00:29:58
Perdón, nombre es privado. 00:30:02
p.dirección no podemos porque dirección es privado. 00:30:03
Con lo cual, para acceder, obtener esas propiedades, obtenerlas, 00:30:06
tengo que hacerlo a través del get. 00:30:11
No hay otra. 00:30:12
Vale, pues hombre, menudo rollo. 00:30:14
Vaya sistema más largo. 00:30:16
Bueno, vamos a probarlo antes de intentar modificarlo 00:30:16
A ver si nos ha 00:30:19
Agregamos a una persona 00:30:20
Ala 00:30:25
Que 00:30:26
Bueno, si no he puesto la opción 00:30:28
De mostrar información, es muy complicado 00:30:34
Que pueda mostrar la información 00:30:36
A ver 00:30:37
Vamos a 00:30:39
Poner la opción 00:30:42
De mostrar información 00:30:44
Vale, case2 00:30:53
Venga, vamos a hacer el case2 00:30:55
Y ahora, aquí lo único que habrá que hacer es 00:30:59
Pues esto, llamar al método 00:31:05
Libreta.mostrarInformación.break 00:31:07
Ya está 00:31:10
No hay que pedir datos de entrada al usuario 00:31:11
No hay que pedir nada porque no hay que pasar nada al método 00:31:14
Pues venga, vamos a probarlo 00:31:17
Agregamos a 1 00:31:21
Y ahora vamos a ver si ese se ha agregado 00:31:24
Pues sí, está aquí agregado 00:31:29
Vale 00:31:32
Pero cómo no va 00:31:33
Los que no vais hoy, vosotros 00:31:38
Él está haciendo exactamente lo que tú le has mandado 00:31:39
Si lo has mandado mal 00:31:42
Algo tienes que tener distinto 00:31:45
No, sí, sí, tranquilo 00:31:49
Bueno, estamos 00:31:51
No hace falta descansar, ¿no? 00:31:57
Un poquito 00:32:03
dime 00:32:04
al método este 00:32:08
es un system out 00:32:11
con las tres propiedades 00:32:15
sacadas a través del get 00:32:17
¿qué error te da? 00:32:18
que no me lo muestra 00:32:23
a ver, a lo mejor 00:32:24
el que tienes mal es al agregar que no te lo agrega 00:32:29
mostrarte lo está haciendo bien 00:32:31
pero no lo estás agregando 00:32:33
a lo mejor tienes mal el otro método 00:32:34
hay veces 00:32:36
algo no funciona y buscamos en el sitio 00:32:37
incorrecto, muy bien 00:32:40
me alegro mucho y eso 00:32:44
te convierte en mejor persona 00:32:46
bueno 00:32:48
vale, está claro 00:32:58
no, bueno sí pero no 00:33:01
venga pues entonces 00:33:04
menudo rollo ha sido este system out 00:33:07
Poner 00:33:11
Todo esto de aquí 00:33:13
¿Verdad? 00:33:15
Vale 00:33:17
Claro 00:33:18
Entonces, ojalá, si nosotros queremos mostrar 00:33:20
La persona enterita 00:33:23
¿Por qué no podemos hacer esto? 00:33:24
Ese 00:33:32
El famoso tu stream 00:33:32
No, si queremos mostrar la persona entera 00:33:34
¿Por qué no podemos hacer esto? 00:33:37
¿Por qué no podemos hacerlo? 00:33:40
Muestro la persona 00:33:42
hombre, porque si lo hacemos, mirad lo que nos sale 00:33:43
no, no nos sale 00:33:45
ningún error, ¿qué es lo que nos sale? 00:33:47
tres 00:33:54
y ahora 00:33:55
muestro información 00:33:56
me sale una información 00:33:57
que está relacionada con la persona 00:34:00
pero no es la que yo quiero 00:34:02
¿vale? me sale una información 00:34:04
vale 00:34:06
entonces, ¿por qué nos sale esta cosa rara? 00:34:07
¿cómo funciona 00:34:11
el system out este de aquí? 00:34:12
este sistema, tú le pasas algo 00:34:16
y él 00:34:18
como tiene que mostrarlo por consola 00:34:20
fuerza su conversión a string 00:34:22
entonces para 00:34:24
forzar la conversión de string a algo 00:34:26
tiene que llamar a 00:34:28
un método que tienen 00:34:30
todas, todas, todas las 00:34:32
entidades, aunque nosotros no lo hayamos 00:34:34
hecho, todas las entidades tienen un método que 00:34:36
se llama toString 00:34:38
que lo que hace dentro es 00:34:39
convertir a string ese 00:34:42
objeto, y ese método está 00:34:44
oculto, ya entenderemos por qué está oculto cuando 00:34:46
hablemos de la herencia, es como cuando yo os decía 00:34:48
cuando hacéis una entidad 00:34:50
siempre hay un constructor sin 00:34:51
parámetros que está ahí oculto aunque no lo veáis 00:34:54
pues aunque no lo veáis 00:34:56
ahí hay un método toString 00:34:58
oculto que sirve 00:35:00
para convertir a cadena el 00:35:02
objeto, pero claro, ese método 00:35:04
toString hace lo que le da 00:35:06
la gana, bueno, más que lo que le da la gana 00:35:08
lo que tiene programado debajo, ya veamos 00:35:10
ya veremos, y lo que tiene programado 00:35:12
es hacer esto 00:35:14
y es que 00:35:16
esto no nos interesa lo más mínimo 00:35:18
entonces, vamos 00:35:19
a hacernos nosotros en nuestra clase 00:35:22
profesor, nuestro propio 00:35:24
nuestro propio método toString 00:35:26
que sustituya a ese oculto 00:35:28
que no nos ha gustado 00:35:30
vamos a hacerlo 00:35:31
perdón 00:35:33
persona 00:35:41
vale, a ver, hablar 00:35:42
y pensar a la vez 00:35:45
de lo que creéis 00:35:47
vale, pues vamos a hacernos en persona 00:35:48
nuestro propio método toString 00:35:51
para que no funcione 00:35:53
como con la versión 00:35:56
del oculto, que es esta versión 00:35:57
y sino que funcione como la versión que nos demos 00:35:59
nosotros, y ese método 00:36:01
toString tiene que 00:36:03
tener, para que el system.out.println 00:36:05
lo encuentre 00:36:07
tiene que tener una cabecera específica 00:36:08
podemos escribirle 00:36:12
y recordarla, pero sobre todo 00:36:13
esto va a ser interesante cuando hagamos herencia 00:36:15
entonces, para no tener que escribir y recordarla 00:36:17
pues de nuevo tenemos el botón derecho 00:36:19
el source 00:36:21
y en el source, ¿no veis aquí 00:36:22
un generate to stream? 00:36:25
pues 00:36:28
él te genera, dices, vale, te dice 00:36:29
en el to stream, ¿qué quieres 00:36:31
convertir a stream? ¿qué campos 00:36:32
quieres convertir a tu stream? venga 00:36:35
los tres, que en el to stream me aparezca todo 00:36:37
y él te ofrece esto, te hace 00:36:39
un método, esta anotación si queréis 00:36:41
la podéis quitar, yo la voy 00:36:43
a quitar por ahora, porque como no sabemos lo que significa 00:36:45
la quito 00:36:47
¿vale? y él te ofrece 00:36:47
eso, te dice, vale, pues voy a convertir 00:36:51
a string este objeto, devolviéndome un string 00:36:53
y ese string 00:36:55
tiene esta forma 00:36:57
¿te gusta esta? 00:36:58
si no te gusta, la cambias, hombre, a mí me gusta 00:37:00
nombre igual al 00:37:03
valor de nombre, dirección igual 00:37:05
al valor de dirección, edad igual 00:37:07
al valor de edad, hombre, pues me gusta este tu string 00:37:09
que no me gusta, pues lo cambio 00:37:11
vale, entonces ahora ya 00:37:12
si volvemos a ejecutar esto 00:37:14
pues hombre 00:37:16
me sale ya la información de la persona 00:37:24
más bonita 00:37:27
y no hemos tenido que 00:37:27
en nuestro 00:37:30
mostrar información, no hemos tenido que sacarla 00:37:32
nosotros una por una, p.get, no hombre 00:37:35
p.no se que 00:37:37
le hemos puesto el objeto entero 00:37:38
y ya el system out se ocupa 00:37:40
de llamar al toString 00:37:43
coge el string 00:37:44
correspondiente que le ha dado el toString 00:37:46
que es todo esto 00:37:48
y ese toString es el que nos muestra 00:37:49
entonces esto nos va a ser muy cómodo 00:37:52
para mostrar contenido de objetos 00:37:54
sin tener que irlo separando 00:37:56
propiedad por propiedad 00:37:58
entonces es algo que se suele hacer 00:37:59
por defecto 00:38:02
cuando uno hace una entidad 00:38:04
pues hace los get, los set 00:38:07
los constructores y suele poner un toString 00:38:09
para si pasa ese objeto 00:38:11
en un system out 00:38:14
pues que se muestre 00:38:15
con algo inteligible 00:38:16
¿verdad? 00:38:19
vale, pues mostrar 00:38:20
información, obtener información, ya lo tenemos 00:38:34
entonces 00:38:37
obtener conteo, este método 00:38:38
no hace falta ni hacerle, es 00:38:40
retuncontactos.led 00:38:42
ya está 00:38:45
¿cuántas personas hay? retuncontactos.led 00:38:46
eliminar persona 00:38:49
vamos a hacer eliminar persona 00:38:51
vale, obtener 00:38:52
información, lo que pasa es que aquí dice 00:38:55
que te lo muestre en una 00:38:56
cadena así, pues hombre, podríamos 00:38:59
a adaptarlo a esta cadena. Poner la libreta de direcciones 00:39:00
contiene tres personas. Ir 00:39:02
construyendo esto nosotros. Pero bueno, eso es 00:39:04
lo de menos, ¿no? 00:39:06
Que yo aquí me he limitado en mi obtener información. 00:39:08
Me he limitado a 00:39:11
mostrar la lista 00:39:12
de personas tal cual. Pero podríamos 00:39:14
haber puesto aquí un system out. 00:39:16
La libreta tiene, no sé nombre, 00:39:18
get patatín. Podríamos haber construido 00:39:20
todo ese string y ya está. Para que se adaptara 00:39:22
a esto. Pero bueno, es lo de menos. 00:39:24
Obtener conteo. No hace 00:39:27
falta hacerlo. Es return el array. 00:39:28
Vamos a hacer eliminar personas 00:39:30
Eso sí 00:39:31
Espera, porque no queremos largas 00:39:32
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
23
Fecha:
13 de diciembre de 2024 - 18:06
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
39′ 37″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
180.07 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid