Saltar navegación

Objectos: Ejemplo Hospital-Medico-Paciente-Enfermedad - 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 5 de diciembre de 2024 por Stefano C.

17 visualizaciones

Más información Transcripción

Descargar la transcripción

Voy a grabar este ejercicio, que es un ejercicio sobre una modelización de un hospital. 00:00:00
Hemos dicho y decidido hasta ahora que queremos pacientes en nuestro hospital. 00:00:04
Entonces, estamos aquí diciendo, vamos a definir cuáles son las características y los atributos de los pacientes. 00:00:09
Y os recuerdo que si habláis, me autorizáis a que grabe vuestras voces. 00:00:17
Decidme, nombre. 00:00:23
Es que a mí me dices enfermedad y a mí me has dicho nada. 00:00:43
Porque ¿cómo lo hago? ¿Con un código numérico? ¿Lo hago con un double? ¿Lo hago con un bulletin para saber si está enfermo o no? ¿Lo hago con un...? ¿Qué le hago? 00:00:47
Sí, al único que levanta la mano. Motivo. No sé. ¿Qué dicen los otros expertos informáticos? 00:01:00
O lo otro con la cosa. ¿El paciente tiene un departamento? Pero estamos haciendo paciente. 00:01:13
diagnóstico. 00:01:24
String diagnóstico. 00:01:30
Me gusta. 00:01:32
Terrible, ¿eh? Lo estáis haciendo. 00:02:00
¿Por qué no? 00:02:05
A ver. 00:02:07
Vamos a ver cosas. 00:02:15
Pongamos orden aquí. Primero, 00:02:17
podemos poner un millón de cosas. 00:02:19
Pero cada cosa que ponemos, nuestro ejercicio 00:02:21
se complica. Entonces, 00:02:23
intentamos mantenerlo a algo 00:02:25
interesante, que no obstante 00:02:27
no nos interesa la vida del paciente, de los 00:02:29
médicos, pero lo que nos interesa es ser 00:02:31
informáticos. Entonces, pongamos 00:02:33
cosillas que puedan tener 00:02:35
sentido sin tener que luego 00:02:37
cuando haga un constructor, tener 00:02:39
45 parámetros que poner. 00:02:41
¿Se entiende? 00:02:45
Vale. Entonces, 00:02:46
quitamos cosas 00:02:48
y metamos cosas un poquito más interesantes. 00:02:49
Y reflexionemos sobre lo que 00:02:51
estamos haciendo. Poma. 00:02:53
No me has entendido. 00:02:58
Esto es prioridad. 00:03:00
¿El? 00:03:05
¿Triage? 00:03:07
Grupo sanguíneo 00:03:09
No me habéis entendido 00:03:14
No, porque A, B no conta 00:03:14
De esta forma, me seguís diciendo 00:03:19
Grupo sanguíneo, para mí grupo sanguíneo no es nada 00:03:23
Me tenéis que decir, tipo 00:03:26
¿Cómo lo quieres el grupo sanguíneo? 00:03:27
A mitad me sobra y lo que me habéis puesto 00:03:56
No me gusta 00:03:57
Vamos a ver, entonces un paciente 00:03:58
Tiene solo una enfermedad 00:04:03
Es solo un diagnóstico, en un hospital 00:04:05
Con que tenga otra enfermedad, lo desechamos. 00:04:08
Vete a otro sistema que tenga la posibilidad de meter dos enfermedades. 00:04:13
Aquí ni queremos una enfermedad sola. 00:04:17
Ah, ponemos un string largo así para luego buscar allí dentro 00:04:19
dónde está la enfermedad que estoy buscando. 00:04:23
Ah, perdonadme. 00:04:25
¿Dónde pongo los arrays? 00:04:36
¿Dónde? 00:04:41
Diagnóstico. 00:04:43
¿Qué más? 00:04:52
Vamos. 00:04:56
Para simplificarlo, ¿eh? 00:04:57
Ahora, antes decíamos, tenía un diagnóstico 00:04:59
Una enfermedad, y digo que está enfermo 00:05:06
No, ¿vale? 00:05:08
Eso es si ya ha curado o no, que si le creo un historial 00:05:09
¿Vale? Ahora, pero no puedo tener 00:05:12
Un buleano enfermo, ¿qué tendré? 00:05:14
Yo te pongo que en la posición cero 00:05:32
Tienes resfriado, si te pongo 00:05:34
True aquí, es que en este momento 00:05:36
Resfriado está activo 00:05:38
Si te pongo en activo false, en la posición cero 00:05:39
Te estoy diciendo que ya se ha curado 00:05:42
Has tenido en pasado 00:05:44
Un resfriado 00:05:46
Pero ahora está 00:05:48
curado. 00:05:49
Y así creamos un historial. 00:05:51
¿Eh? 00:05:53
Fuera. 00:05:54
¿Qué tal? 00:05:58
¿Para qué? 00:05:59
Fuera. 00:05:59
Lo dejamos así. 00:06:09
Easy. 00:06:10
¿Vale? 00:06:11
Son los primeros ejercicios. 00:06:11
Los complejos luego los hacéis vosotros. 00:06:13
Entonces, tenemos un nombre, tenemos una lista de enfermedades y tenemos asociadas 00:06:16
una enfermedad, si está activa o no, de esta forma. 00:06:21
¿Os gusta? 00:06:25
Sí, porque no sabéis pensar. 00:06:26
Vale. 00:06:28
Constructores 00:06:29
Creo un nuevo paciente 00:06:31
¿Cómo lo creo un nuevo paciente? 00:06:33
Con el nombre 00:06:41
No es que el tío que te mete en el sistema 00:06:42
Dice, entonces tienes un infarto 00:07:09
Pero es del paciente 00:07:10
Tengo un infarto, lo he visto en Google 00:07:17
Que es lo que pasa 00:07:19
O sea que podríamos ponerlo 00:07:24
Pero 00:07:26
Sí, claro 00:07:26
Vale, le pongo solo el nombre 00:07:29
Lo que hace este señor de aquí 00:07:32
dis.nombre 00:07:35
que era dis 00:07:38
para diferenciar entre este nombre 00:07:38
y este nombre, vale, dis.nombre 00:07:46
es el atributo de un objeto 00:07:48
¿de qué objeto? este objeto 00:07:50
que estoy creando 00:07:52
o este objeto que estoy definiendo 00:07:53
en esta clase, entonces dis 00:07:56
hace referencia a este de aquí 00:07:58
es igual a nombre, donde nombre 00:08:00
es esto, ¿sí? 00:08:02
¿y qué hacemos con enfermedades y activa? 00:08:07
Lo creo con cero posiciones 00:08:09
Lo creo con diez posiciones 00:08:18
Y luego considero 00:08:19
Que cuando dentro tiene un null todavía no está 00:08:21
No está metida 00:08:24
Y lo aumento solo cuando se llena 00:08:25
Lo aumento cada vez 00:08:28
¿Qué hago? 00:08:29
Si decidimos de aumentarlo de uno en uno 00:08:41
No lo pondría con uno 00:08:43
Porque entonces debería hacer la comprobación siempre 00:08:44
Y en vez de 00:08:47
Me quito la comprobación y asumo siempre 00:08:48
Que añadiendo una nueva enfermedad 00:08:51
No hay espacio, entonces lo hago más grande 00:08:53
La otra opción es hacerlo de 10, entonces se irá rellenando hasta que sean 10, y cuando son 10, pues lo pongo de 20. 00:08:55
Y lo voy llenando hasta 20, cosa por el estilo, ¿vale? 00:09:01
Da igual. 00:09:04
De 0. 00:09:07
Enfermedades es igual a new string de 0, boolean... 00:09:09
No, perdón, activa. 00:09:21
Es igual a new... 00:09:24
¿Cuánto sufre un pobre? 00:09:25
Sí, en realidad no hay 00:09:36
Aquí veis que te ponen azul 00:09:37
Porque no hay ambigüedad 00:09:39
Si quieres ser 00:09:41
Más 00:09:42
¿Sí? 00:09:44
Vale, entonces 00:09:48
Vale 00:09:49
Hagamos un método que pueda añadir 00:09:55
Una enfermedad 00:09:58
Que no será el paciente 00:10:00
que lo hace, lo hará 00:10:02
un método de diagnosticar 00:10:03
del 00:10:06
médico, pero 00:10:06
es al paciente que se añade 00:10:10
una enfermedad, por lo tanto 00:10:12
lo ponemos aquí, ¿vale? 00:10:14
Entonces, public 00:10:16
¿Devuelve algo? 00:10:17
Diagnóstico 00:10:31
Añade, que añade no lo quiero usar 00:10:31
Pero no puedo poner añade 00:10:34
porque te añe 00:10:39
Nuevo diagnóstico 00:10:40
Y le ponemos aquí un 00:10:44
String 00:10:48
Enf 00:10:50
Y lo que queremos hacer 00:10:52
Es añadir enf a esta 00:10:55
A la lista de enfermedades 00:10:57
Y también signar a que está activa 00:10:59
¿Sí? 00:11:02
Entonces 00:11:05
Lo mismo de siempre 00:11:06
Ah, para, para, para 00:11:11
¿Lo puedo hacer? 00:11:13
Sí, lo puedo hacer 00:11:15
Vale, entonces me creo un nuevo array de string 00:11:16
string array nuevo es igual a new string ¿de cuántas posiciones? de la longitud de 00:11:19
enfermedades más 1 punto y coma ahora copio todo lo que tenían enfermedades en el 00:11:37
nuevo, for int i es igual a 0, i menor que enfermedades.length i++, nuevo de i es igual 00:11:49
Enfermedades 00:12:18
Ahí 00:12:19
Con esto he copiado todo 00:12:22
Cuando salgo del for 00:12:26
Nuevo 00:12:28
Nuevo de 00:12:30
Enfermedades 00:12:33
Punto length 00:12:36
Es igual 00:12:37
Porque es el último 00:12:41
Es igual a enf 00:12:43
Si, dudas 00:12:44
Pero cuidado 00:12:49
Ah, y luego debería hacer que 00:12:51
enfermedades 00:12:53
es igual 00:12:56
a nuevo 00:12:58
nos hemos olvidado esto 00:12:59
hay que hacerlo 00:13:15
y esto y esto 00:13:20
tendrán la particularidad 00:13:22
que siempre tienen que tener 00:13:24
el mismo tamaño 00:13:26
por lo tanto puedo usar esta misma i 00:13:26
y puedo hacer que 00:13:30
además de string nuevo 00:13:32
tengo un boolean 00:13:33
nuevo 2 00:13:35
que es igual a new boolean 00:13:38
de esta misma cosa aquí 00:13:42
da igual, tanto estos valores serán iguales, esto debería ser 00:13:48
activa 00:13:54
y luego por cada una de estas de aquí, copio 00:13:56
esto, pero copio también, nuevo 2 00:14:02
de i es igual a activa 00:14:05
De ahí 00:14:09
Voy copiando los booleanos 00:14:10
Y cuando llego al final 00:14:14
Nuevo 2 00:14:16
De esta cosa de aquí 00:14:18
Es igual a 00:14:20
Se asume que si me han diagnosticado algo es porque lo tengo en este momento 00:14:24
En el otro que 00:14:32
Sí, ahora lo hago aquí 00:14:37
Dis, espérate 00:14:38
Déjate, estoy explicando otra cosa 00:14:40
Dis.activa 00:14:42
Es igual 00:14:45
A nuevo 2 00:14:47
Aquí dis, aquí dis 00:14:48
Es que como no hay 00:15:04
No hay ambigüedades 00:15:07
Y te lo pone en azul 00:15:10
Está pillando esta, pues me vale 00:15:11
El this es solo en situaciones 00:15:13
Como esta de aquí 00:15:15
O cuando tengo que trabajar con dos objetos 00:15:16
Del cual uno es este de aquí y otro es otro 00:15:18
Como por ejemplo cuando comparo un objeto con otro 00:15:20
¿Dudas? 00:15:22
¿Hasta aquí? 00:15:26
Vale, estamos en este examen 00:15:28
Me han dicho, haz el hospital 00:15:30
el hospital tiene que tener un nombre y tiene que tener una lista de enfermedades 00:15:32
y tengo que decir si están activas o no. 00:15:38
Y yo hago esto, lo entrego y saco un 3. 00:15:41
¿Por qué? Porque soy un vago. 00:15:53
El examen podía solo esto. 00:16:04
Ahora hacemos curarse, diagnosticar, medicar y todo esto. 00:16:06
Pero centremos en esto. 00:16:11
Me han dicho, tengo que hacer un hospital donde hay pacientes 00:16:13
si los pacientes tienen una lista de enfermedades 00:16:17
se tiene que decir que sean activas o desactivas 00:16:19
y pongo esto, suspenso 00:16:20
¿por qué? 00:16:22
porque esto es la solución que hacía 00:16:26
la semana pasada 00:16:28
cuando no tenía idea de objetos 00:16:29
entonces hacía dos array paralelos 00:16:32
pero ahora sé de los objetos 00:16:36
y entonces 00:16:40
me voy a crear 00:16:42
enfermedad 00:16:46
Como objeto 00:16:48
Y esta enfermedad tendrá 00:16:49
Un string nombre 00:16:54
Y un boolean 00:16:55
Activa 00:17:02
Y luego aquí que haré 00:17:04
Una red de objetos 00:17:11
Una red de enfermedades 00:17:18
Y el concepto de si está activa o no 00:17:20
Y cual es la enfermedad 00:17:23
Va todo empaquetado 00:17:25
En un único objeto 00:17:27
Aquí es más bonito 00:17:29
Pero no me lo habéis dicho 00:17:30
Vamos a cambiarlo, entonces yo tengo mi enfermedad, constructor de enfermedad, public, enfermedad, string nombre, this.nombre es igual a nombre, this.activa es igual a true, hemos dicho, ¿sí? 00:17:33
Mucho más bonito. Ahora me voy aquí, esto me lo cargo, bueno, puedo hacer esto, me lo cargo, esto lo transformo en enfermedad, un array de enfermedad que se llama enfermedades, ¿vale? 00:18:04
Y entonces ahora cuando yo creo un paciente con su nombre 00:18:22
Lo que hago es que this.enfermedades.new 00:18:27
Enfermedad de cero 00:18:30
¿Se entiende? 00:18:36
Porque esto lo entiendes 00:18:42
Pero esto no 00:18:46
¿Qué diferencia hay? 00:18:49
¿Qué hace? 00:18:56
Es un array 00:18:58
¿De qué tipo de objetos? 00:18:58
Cuando yo lo ponga aquí 00:19:02
de string 00:19:03
entonces le pondré dentro gato, perro y cocodrilo 00:19:05
cuando lo pongo así 00:19:09
tengo un array 00:19:10
cuando lo pongo así 00:19:14
lo que tengo es 00:19:23
una serie de celdas 00:19:25
en este caso son cero celdas 00:19:27
pero luego serán más 00:19:28
y en cada celda pongo 00:19:30
un objeto de un determinado tipo 00:19:32
antes ponía un objeto string 00:19:34
o podía enteros 00:19:36
que eran tipo primitivos 00:19:38
Pues ahora en esa celda hay espacio para una enfermedad 00:19:39
De hecho, no exactamente 00:19:44
Paint 00:19:46
Tengo mi array 00:19:47
Y en cada una de estas celdas habrá un puntero a un objeto que es una enfermedad 00:19:52
Aquí crearé otra enfermedad 00:20:02
Y aquí tendré un puntero a esta enfermedad 00:20:04
Y esto es mi array de enfermedad 00:20:08
¿Sí? ¿Se entiende? 00:20:10
¿Dónde se crean estos? 00:20:12
¿Sí? 00:20:30
Vale. 00:20:31
Ok, entonces, esto de aquí me está creando un array vacío de enfermedades. 00:20:34
Existe el array, pero tiene cero posiciones. 00:20:39
¿Qué pasa cuando declaro una nueva enfermedad? 00:20:41
Fijaos que aquí le paso el nombre de la enfermedad. 00:20:44
¿Vale? 00:20:47
Entonces, simplemente, en vez de hacerme los tríngulos, buleanes, cosas por el estilo, 00:20:48
pues tendré un enfermedad nuevo. 00:20:53
que es igual a new enfermedad del tamaño de enfermedades más 1, 00:21:00
voy copiando, el boolean ya no me sirve, 00:21:09
voy copiando por cada una de las enfermedades, 00:21:14
las enfermedades en la posición i, en el nuevo en la posición i, 00:21:17
en el último posición del array nuevo que estoy creando, 00:21:22
lo que tendré que poner es una enfermedad. 00:21:30
¿Cómo pongo una enfermedad? Aquí he copiado todo el array. Copiado, copiado, copiado, copiado. Me queda una última celda vacía. ¿Qué puede tener allí dentro? Un objeto enfermedad. ¿Cómo se crea un objeto enfermedad? Tercera pregunta del examen. 00:21:31
New, que es enfermedad, parámetro actual de este parámetro formal. 00:21:57
Estoy usando el constructor enfermedad. 00:22:23
Entonces lo que me está haciendo él es crearme un nuevo objeto enfermedad, 00:22:26
que como parámetro necesita un string, que es el nombre de la nueva enfermedad que le estoy pasando. 00:22:31
entonces esto me creará un nuevo objeto enfermedad con la nueva enfermedad 00:22:37
que tendrá activa true 00:22:43
y este objeto de aquí nuevo lo guardo en la última posición de la red de enfermedades 00:22:46
al final este nuevo se transforma en mis enfermedades y por lo tanto he añadido una 00:22:55
Ahora, si vosotros como se usan los arrays lo tenéis relativamente claro, aquí la dificultad es empezar a usar arrays de objetos. 00:23:03
Si vosotros no tenéis ni idea de que estoy haciendo con los arrays, pues esto se vuelve un infierno. 00:23:18
No entendéis que se está haciendo. 00:23:25
Pero esto es una cosa que hemos ya hecho mil veces 00:23:27
Con enteros o con otras cosas 00:23:30
Solo que en vez ahora de enteros 00:23:32
Estoy utilizando un objeto 00:23:34
Y cuidado, lo estáis haciendo con objetos 00:23:36
Desde el día uno de los arrays 00:23:39
Porque cuando usáis string 00:23:41
Un array de string 00:23:42
Ese es un array de objetos 00:23:43
Solo que vuestro cerebro 00:23:45
Acostumbrado a decir, no, no lo trato como objeto 00:23:48
Pero es un objeto, string es un objeto 00:23:50
Entonces, ahora tengo un nuevo diagnóstico 00:23:52
Le paso resfriado 00:24:00
Por algún lado haré paciente1.nuevodiagnostico y entre comillas le pongo resfriado 00:24:01
¿Qué hace esto? Pues me crea un nuevo array de enfermedades, de objetos enfermedad 00:24:09
Un poquito más grande, más uno 00:24:16
Me lo va rellenando con todas las enfermedades que tenía allí 00:24:19
Activas o no activas, eso dependerá de la misma enfermedad, del mismo objeto 00:24:24
Porque está aquí, ahora si está activo o no 00:24:29
Y después de haber copiado toda la que tenía antes 00:24:31
Me queda un espacio más, que será el último espacio 00:24:37
Y en este último espacio, creo una nueva enfermedad 00:24:40
Que es esta 00:24:45
¿No lo veis? 00:24:47
¿Lo veis mejor? 00:25:07
Me han pasado una enfermedad, el nombre de una enfermedad 00:25:13
He creado una nueva enfermedad 00:25:17
Es esta de aquí, nueva enfermedad 00:25:19
copio las enfermedades 00:25:21
viejas 00:25:24
añado en última 00:25:24
posición la nueva enfermedad 00:25:27
y asigno que 00:25:29
el nuevo objeto que he creado, el nuevo array que he creado 00:25:31
ahora son mis enfermedades 00:25:33
que incluirán todas las anteriores 00:25:35
más la nueva, que a veces lo pongo antes 00:25:37
funciona igual 00:25:49
esto para mí tiene más lógica 00:25:57
antes copio todo 00:26:03
y luego en el último espacio 00:26:05
no, ahora no 00:26:06
metodito que devuelve un array de enfermedad que copia y 00:26:23
extiende un array que le paso entonces esto lo que hace es 00:26:59
enfermedad array nuevo es igual a un array del tamaño de esto que me han dado 00:27:23
A mí me han pasado una red de enfermedades 00:27:39
Este objeto de aquí es 00:27:48
Copia este array 00:27:50
Y me devuelve un array 00:27:53
Igual con una posición 00:27:55
Extendida 00:27:57
¿Se entiende? 00:27:58
Entonces, me han pasado este array 00:28:02
Sea cual sea este array 00:28:04
Yo lo pillo un poquito más grande 00:28:05
Esto es la enfermedad 00:28:07
¿Cómo? 00:28:11
Ahora cambio 00:28:13
y ahora cambio, luego lo recorre, por cada uno de estos aquí, copia lo que me has dado en el nuevo array, 00:28:14
y al final devuelve nuevo, entonces yo aquí podría hacer que this.enfermedades es igual a esta cosa aquí, 00:28:24
Y luego this 00:28:41
Punto 00:28:46
Enfermedades 00:28:48
De enfermedad, de la buena 00:28:50
¡Voilá! 00:28:54
Sí 00:29:26
¿Cómo? Menos una 00:29:27
Eso sí 00:29:38
¿Se entiende que estoy haciendo así? 00:29:40
Os lo he hecho de forma básica 00:29:45
Y ahora lo estoy un poco mejorando 00:29:47
Un poco vamos hacia 00:29:50
Somos programadores 00:29:52
Entendemos lo que estamos haciendo 00:29:53
Pues hacemos las cosas un poquito más 00:29:55
En vez de hacerla en 25 líneas de códigos 00:29:56
Mezcladas con cosas raras 00:29:59
Pues la vamos a hacer lo más rápido posible 00:30:01
¿Vale? 00:30:02
Este aquí es un metodito externo 00:30:04
¿Por qué me lo saco fuera este código? 00:30:05
No solo, pero por reutilizarlo cuando haga falta 00:30:11
Este es un método general 00:30:14
Que yo le paso un array de enfermedades 00:30:16
Se me lo extiende y me lo copia 00:30:18
Ya está 00:30:20
¿Sí? 00:30:21
En un futuro, esto lo podré hacer como array de objetos 00:30:22
Entonces puedo copiar lo que me da la gana 00:30:27
Un futuro, ¿vale? Por ahora no 00:30:29
Entonces, se me queda el nuevo diagnóstico 00:30:32
Que me dan una enfermedad 00:30:36
Y lo que yo hago es extender mis enfermedades 00:30:38
Y luego añadir en la última posición la nueva enfermedad 00:30:42
Esto es muy claro 00:30:47
¿Y esto qué es el copia-extiende? 00:30:49
Que me están dando un array, y yo de este array me creo un array nuevo, más grande, lo copio entero y lo devuelvo. 00:30:52
Entonces, cuando llamo esto, lo que estoy haciendo es copiando enfermedades enteros y devolviendo un array que es igual a enfermedades, pero con un espacio vacío al final. 00:31:01
Y en ese espacio vacío es donde guardo la nueva enfermedad. 00:31:12
Vale, porque efectivamente cuando yo hago esto, a partir de aquí, enfermedades ya tienen una posición más. 00:31:15
Si aquí yo tenía 10 enfermedades, después de haber hecho esto, ahora enfermedades son 11 posiciones, que van de la 0 a la 10. 00:31:29
Entonces, si yo le quito esto, él intenta acceder a informe.length que es 11. 00:31:40
Y entonces la posición 11 no la tiene. 00:31:45
Antes lo podía hacer porque estaba usando nuevo 00:31:48
Y nuevo era el más grande 00:31:51
Enfermedades no había cambiado todavía 00:31:53
Hasta que hacía al final enfermedades es igual a nuevo 00:31:54
Enfermedades tenía 10 posiciones 00:31:57
Y nuevo tenía 11 00:32:00
Pero ahora no, porque ahora ya lo he extendido 00:32:02
Entonces cuando paso de esta línea de aquí 00:32:06
Ya esto tiene ya la última posición vacía 00:32:09
Entonces si yo acedo a esta de aquí 00:32:12
Estará intentando acceder a una posición que no existe 00:32:15
Entonces, a la última. 00:32:18
¿Dudas? 00:32:27
Este de aquí me lo guardo por algún lado. 00:32:31
Si lo hago tendré que copiar y extender otro array. 00:32:35
Pues a lo mejor copio este de aquí. 00:32:38
En vez de enfermedad lo hago de string o de int. 00:32:40
Es siempre esto. 00:32:43
Este de aquí no es la primera vez que lo vemos. 00:32:44
Este mecanismo de aquí. 00:32:46
Por eso también lo guardo fuera. 00:32:47
Porque no me moleste aquí dentro. 00:32:50
Y mis metoditos salgan muy bonitos, ¿vale? Y puedo comentarlo fácilmente poniendo, añado un nuevo espacio para la nueva enfermedad, añado la nueva enfermedad en el último espacio del array. 00:32:52
Pues ya está. Es muy fácil de entender, muy fácil de comentar. ¿Dudas? ¿Vale? Entonces, vamos a crear otros metoditos de paciente, ¿vale? Como por ejemplo, podríamos listar las enfermedades activas, ¿sí? 00:33:25
plan, yo aquí podría 00:33:56
listar todas las enfermedades 00:33:59
que tiene 00:34:01
pero a lo mejor lo que me interesa saber 00:34:02
es que tienes ahora 00:34:05
¿sí? entonces 00:34:06
¿qué devuelve este método? 00:34:09
le hacemos devolver una lista 00:34:14
le hacemos devolver un string, le hacemos devolver ¿qué? 00:34:15
un array 00:34:19
boolean 00:34:20
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Autor/es:
Stefano Chiesa
Subido por:
Stefano C.
Licencia:
Reconocimiento - No comercial
Visualizaciones:
17
Fecha:
5 de diciembre de 2024 - 14:19
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
1h′ 14′ 57″
Relación de aspecto:
16:10 El estándar usado por los portátiles de 15,4" y algunos otros, es ancho como el 16:9.
Resolución:
1152x720 píxeles
Tamaño:
255.08 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid