Saltar navegación

Examen Feb23 parte1 - 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 14 de febrero de 2023 por Stefano C.

12 visualizaciones

Más información Transcripción

Descargar la transcripción

Voy a grabar un vídeo, por lo tanto, si habláis, me dais la autorización a grabar vuestra voz, ¿vale? 00:00:00
Entonces, vamos a corregir el examen del 13 de febrero, que me he equivocado y he puesto enero. 00:00:07
Entonces, esto es el enunciado. Decíamos que queríamos hacer un archivo de documentos directos. 00:00:16
Si necesitáis que en algún momento me pare o tenéis dudas sobre lo que estoy haciendo, paradme, ¿vale? 00:00:23
Es decir, me lo interrumpo la grabación eventualmente y os contesto 00:00:29
O lo grabamos y ya está 00:00:33
Entonces, la idea es que haya documentos secretos y hay operadores que trabajen con estos documentos 00:00:35
Vale, fenomenal 00:00:41
Empezamos con la interfaz autorizada 00:00:42
La interfaz autorizada la necesito, por lo tanto me creo una nueva interfaz 00:00:45
Que sea la interfaz autorizada 00:00:49
Y esta interfaz 00:00:52
Tenga 00:00:56
Tenga este método de aquí 00:00:59
Entonces 00:01:02
Public int 00:01:03
Autorización 00:01:05
.com 00:01:07
¿Vale? 00:01:11
Es una interfaz, por lo tanto no tiene que 00:01:13
Implementar esto, ¿vale? 00:01:15
Tiene que ser solo una interfaz, se queda allí 00:01:17
Y ya veremos cuando la 00:01:19
La implementaremos 00:01:21
Donde la tenemos que implementar, ¿vale? 00:01:23
Fenómeno 00:01:25
Cuarto 00:01:26
Siguiente 00:01:27
Aquí define que hace este método 00:01:29
Pero claro, este método se tendrá que implementar 00:01:32
Allá donde haya un objeto 00:01:34
Que implemente esta interfaz 00:01:36
¿Vale? 00:01:38
¿Podría hacer una implementación por defecto? 00:01:38
No, porque no tengo el int que tengo que devolver 00:01:43
Podría hacer una implementación por defecto 00:01:46
Que devuelva siempre 00:01:48
Que no estás autorizado 00:01:49
Pero ¿qué número representa que no estás autorizado? 00:01:51
Ninguno 00:01:55
Podría inventarme que el "-1", o sea, si el número es negativo, quiere decir que no tienes autorización nunca, ¿vale? 00:01:55
Pero esto no me lo dice por ningún lado, por lo tanto, no hago una implementación por defecto, ¿vale? 00:02:02
Voy a la clase Operador, clase Operador, creo una nueva clase, la clase la llamo Operador, esto representa un operador, ¿vale? 00:02:07
que tiene se caracteriza por su nombre vale entonces string nombre punto y 00:02:24
coma public operator al que le doy un string nombre y lo que me crea es un 00:02:33
Dis.nombre 00:02:50
Es igual a nombre 00:02:52
¿Vale? 00:02:54
Y poco más, porque la clase operador 00:02:58
No puede hacer nada más 00:03:00
¿Sí? Entonces esta es la clase operador 00:03:02
Vale 00:03:04
Luego está operador autorizado 00:03:05
Por lo tanto, creo una nueva clase 00:03:07
Bueno, puedo hasta copiar esta 00:03:10
No, he copiado hoy la que no es 00:03:13
Esta 00:03:16
Control-C, Control-V 00:03:17
Operador autorizado 00:03:18
Abro operador autorizado 00:03:22
Y tengo las mismas cosas 00:03:32
La única cosa es que 00:03:34
Este de aquí 00:03:37
Extende 00:03:38
Operador 00:03:39
Y además 00:03:42
Añade el nivel 00:03:46
De autorización 00:03:48
Entonces tendrá un int 00:03:49
Nivel autorización 00:03:53
Entonces cuando creo un operador autorizado 00:03:56
Además del nombre 00:04:02
Le paso un int 00:04:04
Nibout 00:04:06
¿Dudas? 00:04:08
¿Cómo funcionará este de aquí? 00:04:14
¿Qué hago ahí dentro? 00:04:16
Supernombre 00:04:19
Utilizo el constructor 00:04:20
De mi superclase que 00:04:24
Pilla nombre, por lo tanto me rellena nombre 00:04:25
Y después 00:04:28
Dis.nibout 00:04:29
Cuando creo un operador autorizado 00:04:32
Tengo su nombre y su nivel 00:04:41
El nombre lo utilizo para crear un operador 00:04:42
Con ese nombre 00:04:45
Y luego el nivel de autorización 00:04:47
Para el nivel de autorización 00:04:49
¿Dudas? 00:04:50
Vale 00:04:53
Además, este señor tiene que implementar 00:04:54
Autorizado 00:04:57
¿Vale? Ningún problema, puedo extender 00:04:58
Operador e implementar 00:05:00
autorizado 00:05:03
¿vale? 00:05:06
para implementar autorizado 00:05:08
necesita implementar 00:05:09
este método de aquí 00:05:12
entonces 00:05:13
aquí debajo 00:05:16
me creo 00:05:17
este señor de aquí 00:05:21
que lo que hará es 00:05:22
dudas 00:05:24
este de aquí 00:05:38
así evito que la gente 00:05:40
acceda inoportunamente 00:05:48
Su nivel de autorización 00:05:50
Y se lo cambie 00:05:52
¿Sí? 00:05:53
Ah, yo no lo he metido 00:05:55
Fallito 00:05:56
Pequeño 00:05:58
¿Sí? 00:06:00
Este de aquí 00:06:02
Está pensado justo 00:06:03
Para que yo pueda acceder 00:06:04
A este objeto 00:06:05
Pero no lo pueda modificar 00:06:06
En un cierto sentido 00:06:08
¿Vale? 00:06:09
También el nombre 00:06:11
Podría ser privado 00:06:12
Para no cambiarme el nombre 00:06:13
Pero 00:06:14
Esto es más interesante 00:06:14
Que sea privado 00:06:17
Por respecto a que sea privado 00:06:18
El nombre 00:06:19
Entonces 00:06:19
Sigo con este de aquí 00:06:22
Vale, entonces la parte de los operadores 00:06:24
Ya lo he hecho, luego ya los utilizaré 00:06:27
En futuro 00:06:29
Ahora voy a la parte de los documentos 00:06:30
Entonces me dice que tengo un documento 00:06:32
Con estos atributos de aquí 00:06:34
Entonces creo una nueva 00:06:36
Clase 00:06:48
La clase documento 00:06:49
La clase documento 00:06:52
Que tiene, tiene un 00:06:55
String id 00:06:56
Tiene un int 00:06:58
Nivel 00:07:00
Confidencialidad 00:07:01
Y tengo un string 00:07:06
Contenido 00:07:09
Cuando creo un nuevo 00:07:09
Documento, que hago, no lo sé 00:07:13
Porque aquí me dice que no puedo 00:07:15
Crear un nuevo documento, vale 00:07:17
Puedo utilizar un 00:07:18
Constructor, si, public 00:07:21
Documento 00:07:22
que recibe una string id 00:07:24
string int 00:07:27
nivel confidencialidad 00:07:30
y string contenido 00:07:33
que hace esta cosa aquí 00:07:37
para inicializar 00:07:40
id es igual a 00:07:51
dis.id 00:07:52
es igual a id 00:07:53
dis.nivel 00:07:56
¿Qué más tiene que hacer? 00:08:01
Tiene que implementar la interfaz 00:08:15
Mostrable 00:08:18
Que todavía no tengo 00:08:19
Entonces por ahora lo dejo así 00:08:20
Y luego hago la interfaz mostrable 00:08:21
Y luego lo implemento 00:08:24
Y la otra cosa interesante 00:08:25
Es que no se pueden crear instancias de documento 00:08:28
¿Por qué he hecho esto? 00:08:30
¿Cómo hago para que no se creen instancias 00:08:31
De este documento? 00:08:34
¡Vale! 00:08:41
Ya no se pueden crear documentos 00:08:42
De hecho, los documentos no tienen sentido 00:08:44
Yo no quiero documentos 00:08:48
Yo quiero audio o textos 00:08:50
A lo mejor en un futuro 00:08:52
Pondrán vídeos, pondrán cosas 00:08:54
Pero documento por sí mismo es sólo 00:08:56
Un comodín que yo gestiono 00:08:58
Ahora, ¿un comodín abstracto no puede 00:09:01
Tener un constructor? Sí 00:09:02
Porque yo luego desde cualquier otro tipo de documento 00:09:04
Llamaré super 00:09:07
De este constructor de aquí 00:09:09
Pero no estoy construyendo un documento 00:09:11
Estoy construyendo un audio 00:09:14
Estoy construyendo un lo que sea 00:09:15
¿Si? 00:09:16
Entonces 00:09:19
Pausa en documento 00:09:20
Y voy a la interfaz mostrable 00:09:23
Creo 00:09:24
Una nueva interfaz 00:09:26
Que me diga 00:09:29
Que se llame mostrable 00:09:30
Esta de aquí 00:09:32
Tiene dentro 00:09:37
Public void 00:09:38
Mostrar 00:09:41
The object 00:09:42
Oh, vale 00:09:44
Vuelvo a 00:09:48
Sí, vuelvo a 00:09:50
Documento y digo 00:09:58
Documento, tú implementas 00:09:59
Mostrable 00:10:01
Teniendo en cuenta que 00:10:04
Al ser abstracta 00:10:08
No me importa 00:10:10
Implementar el mostrable 00:10:12
Porque 00:10:15
Yo he importado este señor de aquí 00:10:17
Si aquí no lo implemento 00:10:19
Él lo considerará como si fuera 00:10:24
Si fuera un extracto 00:10:26
Y me lo deja para 00:10:28
No eres tú quien lo implementa 00:10:29
Será una 00:10:31
¿Cómo se dice? 00:10:33
Una heredada 00:10:37
Que lo tendrá que implementar 00:10:39
Porque él sabe que, vale, no me lo has implementado 00:10:40
Sí, pero en ningún momento creerá esto 00:10:42
Os recuerdo que aquí 00:10:45
¿Qué está escrito aquí? 00:10:46
Aquí está escrito abstract 00:10:48
Las interfaces 00:10:57
Son todos métodos abstractos 00:11:00
¿Vale? 00:11:03
Son tan abstractos que ni siquiera lo pongo abstract 00:11:03
Porque asumo que si estoy 00:11:07
Identificando una interface 00:11:08
Aquí seguramente son todos abstractos 00:11:10
Sus métodos 00:11:12
Entonces es como si hubiese creado este método abstracto 00:11:13
En esa clase abstracta 00:11:16
Y es perfectamente legítimo 00:11:17
Crear un método abstracto en una clase abstracta 00:11:19
La pregunta es 00:11:22
¿Lo implemento aquí o no? 00:11:23
Es decir, ¿puedo 00:11:25
El mostrable por cómo tiene que funcionar 00:11:27
Mostrarlo aquí 00:11:31
Crearlo aquí 00:11:32
O es mejor que espere y lo haga más adelante 00:11:33
Y a lo mejor 00:11:36
No lo sé 00:11:37
Yo creo que esperar es más sencillo 00:11:38
Creo que también es posible 00:11:42
De alguna forma hacerlo a este nivel 00:11:45
Pero se complica la cosa 00:11:48
¿Vale? 00:11:49
Y no gano casi nada 00:11:52
A implementarlo aquí 00:11:54
Porque el discurso es que luego 00:11:55
Por lo que dice aquí 00:11:57
Este mostrar tiene un comportamiento distinto 00:11:58
Si es en texto o en audio 00:12:01
Entonces me compensa crearlo directamente 00:12:02
En texto o en audio 00:12:05
Y tirar del polimorfismo 00:12:06
Esta es la parte de diseño 00:12:08
En que se está preguntando 00:12:10
¿Has entendido algo del polimorfismo? 00:12:12
Entonces 00:12:15
A ver 00:12:17
Entonces por ahora lo dejo así 00:12:19
Si luego tengo que retocarlo 00:12:22
Volveré al documento otra vez 00:12:24
Me voy a mostrar 00:12:25
Ya lo he creado y te dice que tiene que hacer 00:12:27
Con todo esto del operador 00:12:30
Autorizado, etc, etc, etc 00:12:32
Pues 00:12:33
Me lo pregunto 00:12:35
Vale 00:12:38
Vamos a ver como lo hacemos 00:12:54
Luego vemos si lo mejoramos o no 00:12:56
Entonces, vamos, sigamos adelante con texto, texto tiene dentro, extende, perdón, documento, y me dice ya, oye, mira, cuidado que hay cosas raras, ¿vale? 00:12:58
Entonces vamos a crear un texto, public texto, para crear un texto que necesito lo mismo que el documento, string ente contenido, y luego también la cosa extra, que era el número de páginas. 00:13:32
Entonces un texto tiene int num páginas, que me lo paso por aquí, int num páginas, y aquí dentro lo que haré es super d y d, nc, contenido. 00:13:56
Utilizo 00:14:19
El constructor de documento 00:14:21
Para crear la parte 00:14:23
Digamos que es relacionada con documento 00:14:25
Y luego 00:14:27
This.numpad 00:14:28
Es igual a np 00:14:30
¿Vale? 00:14:33
Entonces ya tengo esto 00:14:38
Me dice también que 00:14:39
El tipo texto 00:14:40
Tiene que implementar 00:14:42
El método abstracto ineditado 00:14:44
Mostrable.mostrar 00:14:47
¿Sí? 00:14:49
Entonces lo voy a implementar 00:14:51
Public 00:14:53
Void 00:14:56
Mostrar 00:14:58
Object 00:15:01
Y ¿qué tengo que hacer? ¿Vale? 00:15:04
Esto de aquí me dice si 00:15:09
Tened en cuenta que esto de aquí es un método 00:15:10
Que se está 00:15:14
Ejecutando sobre un objeto 00:15:16
texto, vale, y que se le 00:15:17
pasa un objeto o, vale 00:15:20
este objeto o es un operador 00:15:22
y yo tengo que comprobar 00:15:24
si este operador es un operador y si 00:15:26
me vale, vale, entonces 00:15:27
la primera cosa que voy a hacer 00:15:29
es comprobar si lo que me han 00:15:31
pasado es alguien que 00:15:34
podría de alguna forma 00:15:35
hacer lo que yo quiero hacer, como lo hago 00:15:37
primera trampa del día 00:15:42
y que 00:15:57
Hacemos por partes 00:16:04
Luego optimización en otro momento 00:16:12
Cuidado, esto podría ser null 00:16:15
Si yo te paso cuando llamo a mostrar de null 00:16:17
O mostrar de un objeto que no está analizado 00:16:29
Podría ser null 00:16:31
Entonces cuidado con lo que hacemos 00:16:33
O instance of null 00:16:35
¿Qué hace? 00:16:38
Perdón, null instance of 00:16:39
Operador autorizado 00:16:41
¿Qué hace? 00:16:44
Ni idea 00:16:46
¿Vale? Entonces solo pruebo 00:16:47
O si no le pongo aquí simplemente 00:16:49
Si O 00:16:52
No es null 00:16:53
O instance of es 00:16:57
Operador 00:16:59
Autorizado, pues aquí dentro 00:17:00
Estaría 00:17:04
En un sistema 00:17:05
En el que 00:17:07
efectivamente el objeto que me han pasado 00:17:08
es correcto, no es 00:17:11
null y es 00:17:13
un operador autorizado 00:17:15
por lo tanto ya aquí puedo 00:17:16
ir a mirar si efectivamente 00:17:18
él es un operador 00:17:21
correcto, si le puedo enseñar las cosas o no 00:17:23
si no 00:17:25
¿qué hago aquí? 00:17:26
no tienes acceso 00:17:37
fijaos que es un void, entonces no devuelve 00:17:38
nada, entonces se asume que el 00:17:43
Mostrarlo, escriba directamente 00:17:44
De hecho lo dice, no, cuando yo mostrar 00:17:46
Tiene que escribir esta cosa por pantalla 00:17:48
Por lo tanto, si 00:17:50
El objeto es null 00:17:51
O el objeto no es instancia 00:17:53
De operador autorizado 00:17:56
Vete directamente aquí 00:17:58
Y le dices, no tienes acceso 00:17:59
¿Dudas? 00:18:02
¿Y qué pasa si en vez 00:18:06
Esto es verdad? Entonces estoy en la situación 00:18:10
En que ahora tengo que comprobar 00:18:12
Si, ok, eres un operador autorizado 00:18:14
Pero hay que ver 00:18:16
Si tu autorización, nivel de autorización 00:18:18
Es correcto o no 00:18:20
¿Vale? Entonces aquí dentro sería 00:18:21
Sí 00:18:24
Ahora puedo hacer un casting, ¿vale? 00:18:24
Porque como sé que este de aquí es un operador 00:18:32
Autorizado, puedo castear 00:18:34
Pues entonces 00:18:36
Operador 00:18:37
Autorizado 00:18:44
De o 00:18:46
Punto 00:18:48
Y fijaos que ahora aquí 00:18:51
Salen los métodos como si fuera 00:18:52
Un operador autorizado 00:18:54
Incluido 00:18:55
Get, como se llama, autorización 00:18:57
¿Vale? 00:19:00
Esta autorización me da 00:19:01
El nivel de autorización del objeto 00:19:03
Y lo comparo con que 00:19:07
Si este nivel de autorización es por ejemplo 00:19:09
Menor, o sea tiene más autorización 00:19:12
Que que 00:19:15
Igual 00:19:16
De quien 00:19:19
Que documento 00:19:22
Dice punto 00:19:24
Nivel confidencialidad 00:19:29
No, porque este objeto lo tiene 00:19:30
Lo tiene 00:19:33
Porque tú lo estás llegando de este objeto aquí 00:19:34
Creo que te daría como resultado lo mismo 00:19:40
Pero 00:19:42
Aquí luego lo pienso 00:19:42
Si esto en vez de menor habéis puesto mayor 00:19:46
No os funciona nada, pero es un fallo menor 00:19:48
¿Vale? No es el problema aquí 00:19:50
El problema es 00:19:52
Haber accedido aquí y haber accedido aquí 00:19:53
Estas son las dos 00:19:56
Cosas que estoy comparando 00:19:57
Si luego me doy cuenta que esto 00:19:59
Tenía que ser mayor en vez que menor 00:20:01
Pues veo que no me funciona nada 00:20:03
Lo hago un poco de debugging y lo encuentro 00:20:05
Eso me interesa menos 00:20:07
Eso lo digo de cara al examen 00:20:08
Si os habéis equivocado aquí 00:20:10
Importante haber utilizado estas otras cosas 00:20:13
¿Vale? 00:20:15
Si esto es verdad 00:20:18
Entonces quiere decir 00:20:19
Que puedo 00:20:21
Puedo hacer algo 00:20:22
Justo, o sea que te puedo mostrar 00:20:28
el contenido entonces eso tenía que prescribir puedes leer el siguiente texto lees texto dos 00:20:31
puntos más 10 punto contenido puedes hacer nota contenido lo quiero privado pero lo dejamos así 00:20:46
luego estas son cosas pequeñas la idea sería que de alguna forma solo desde aquí pueda acceder al 00:21:06
contenido vale pero vamos a ver como seguimos esto por ahora lo dejamos así si no porque fijaos que 00:21:13
si yo entro aquí dentro y luego tú no estás autorizado no te escribo ni esto ni esto 00:21:35
Entonces aquí tengo que escribir algo más. 00:21:42
¿Qué tengo que escribir? 00:21:45
Lo mismo. 00:21:49
Entonces, sobre esta base, seguramente se puede hacer algo para mejorar un poco este código. 00:21:52
Para que no tenga que escribir dos veces este mensaje. 00:22:00
Una opción, independientemente, es poner un string aquí. 00:22:06
Que sea el resultado. 00:22:12
Rellenarlo con este texto si pasa por aquí. 00:22:14
Con este texto si pasa por aquí. 00:22:16
Con este texto se pasa por aquí 00:22:18
Y luego al final siempre imprimir res 00:22:19
Pero no cambia mucho 00:22:21
De lo que tenemos que hacer ¿Vale? 00:22:23
Lo que si podemos hacer para ahorrarnos uno de estos 00:22:25
Es directamente esta condición de aquí 00:22:28
Ponerla en el primer if 00:22:30
Aquí 00:22:36
Porque al fin y al cabo este if 00:22:42
Tiene que comprobar tres cosas 00:22:47
Que o sea null 00:22:49
Que sea una instancia de operadora 00:22:49
Autorizado 00:22:51
Y si es verdad todas estas cosas 00:22:53
Pues entonces que tenga el nivel de autorización 00:22:55
Si estas tres cosas son verdaderas 00:22:56
Entonces me escribes el contenido 00:22:58
Si no 00:23:01
Me escribes malvamos 00:23:04
Y se acabó 00:23:06
Esto debería funcionar 00:23:09
Os recuerdo también que cuando utilizáis el end end 00:23:13
Lo que estamos haciendo 00:23:17
Lo que estamos haciendo es 00:23:24
Valoramos esta 00:23:27
Si esta es falsa 00:23:28
Como esto será verdadero solo si los tres son verdaderos 00:23:29
Como una sea falsa, las otras ni se miran 00:23:33
¿Vale? 00:23:36
Entonces, como esto sea falso 00:23:37
Ya está, salgo, se acabó 00:23:39
Si este es falso 00:23:41
No llegaré nunca a hacer esta operación 00:23:44
¿Sí? 00:23:46
Entonces, llego a hacer esta operación 00:23:48
Si, solo si 00:23:50
Esto y esto han dado verdadero 00:23:52
Entonces, tengo un objeto porque no es null 00:23:54
Y tengo una instancia de operador autorizado 00:23:56
Ahí 00:23:59
¿Dudas? 00:24:00
Te daría, no tienes el C 00:24:01
No, digo 00:24:11
Si ocurriese en plan 00:24:12
No flota, ¿no? 00:24:14
Si pusieras aquí un null 00:24:16
Esto te daría false, no debería explotar 00:24:20
Imagínate que no está esa parte 00:24:22
Que directamente pasas al instance of 00:24:23
No me acuerdo si instance of 00:24:25
Está con null o no 00:24:28
Vale, era mi duda 00:24:30
Es posible 00:24:32
Que te diga false 00:24:33
Cuando tú comparas un objeto 00:24:35
O sea, un null con cualquier 00:24:38
cualquier otra cosa, pues es posible que te diga falso. 00:24:40
¿Vale? Porque la instancia, 00:24:42
técnicamente, no es una instancia de hasta aquí. Te debería 00:24:44
explotar. Te debería decir, no, no lo es. 00:24:46
Vale, era por saber por... 00:24:48
Vale, pero es que no me acuerdo. Esto 00:24:50
lo pruebas una vez 00:24:52
y ves como... 00:24:54
¡Preguntas para vosotros! 00:24:56
¿Os gusta esto? 00:24:58
¿Por qué no? 00:25:02
¿No os gusta esto 00:25:04
porque el profesor os ha preguntado, os gusta esto? 00:25:06
Esto es un 8, asumiendo que luego a lo mejor no me he dado cuenta de algunos errores, pero por como lo veo ahora, sería un 8. 00:25:08
¿Dónde están los dos puntos que faltan? 00:25:26
¿Qué pasa si mañana yo me invento operador secreto? 00:25:28
Que también tiene un nivel de autorización. 00:25:41
¿Qué pasa con este código? Que hay que rehacer el objeto, texto, audio, video, cocodrilo, todo lo que sean los que estén detenidos. 00:25:45
No podría yo hacer algo aquí para que esto funcione un poco mejor. 00:25:59
¿Por cuál razón retorcida mi profesor me ha puesto la interfaz mostrable en vez de haber puesto esto directamente dentro de documentos y olvidarme de la interfaz mostrable? 00:26:06
Perdón, no mostrable, de autorizado. 00:26:26
O sea, no es operador autorizado que me permite sacar la autorización. 00:26:33
Es el hecho que implemente autorizado que me hace poder pedir la autorización 00:26:39
Entonces aquí esto está bastante mejor 00:26:46
Porque ahora me da igual que sea un operador autorizado 00:26:58
Cualquier elemento, cualquier clase que yo cree que implemente la posibilidad de autorizarse 00:27:05
Me funciona 00:27:12
Porque podrá llamar el método de autorización 00:27:14
Y yo es el método de autorización que me da su nivel de confianza 00:27:18
Y que yo lo miro con respecto al nivel de confidencialidad del documento 00:27:22
Y veo si está bien o no 00:27:28
Y si mañana y además de operador autorizado 00:27:30
Tengo superjefe general, presidente del estado 00:27:33
Que también tiene un nivel de confidencialidad 00:27:36
Porque implementa y implementa autorizado 00:27:39
porque es autorizado y tiene su nivel 1 00:27:41
pues yo puedo utilizar tranquilamente aquí 00:27:44
para leer un documento confidencial el presidente 00:27:47
en vez del operador autorizado 00:27:50
eso es un ye 00:27:53
bueno, no lo sé, a lo mejor tiene errores 00:27:59
esto es haber pensado 00:28:01
en el diseño del programa 00:28:05
y haber pensado por qué me han dado la interfaz autorizada 00:28:08
Si lo hago sustancialmente a la interfaz autorizada 00:28:12
Casi no la uso 00:28:15
Porque 00:28:16
Imaginaos que quito esta 00:28:18
Y quito esta cosa aquí 00:28:20
Implemento autorizado, cambia algo 00:28:22
¿No? 00:28:24
Porque aquí me estoy inventando un método de autorización 00:28:27
Que devuelve una autorización 00:28:30
Esto funciona perfectamente 00:28:31
¿Y entonces por qué me han dado esta interfaz? 00:28:35
Para esto 00:28:40
Vale 00:28:41
que hago ahora con 00:28:49
texto, pues ctrl c 00:28:53
ctrl v, lo llamo 00:28:55
audio 00:28:57
le doy ok 00:28:58
en vez de numpad, ah no, lo abro 00:29:00
bien, en vez de 00:29:03
numpad era longitud 00:29:05
longitud 00:29:07
y esto lo copio aquí 00:29:07
y esto l 00:29:15
Esto es exactamente igual 00:29:17
¿Vale? Solo que en vez de 00:29:21
Lees texto, dice 00:29:24
Escucha audio 00:29:25
Ahora, el hecho que esto cambie 00:29:27
Es la razón de por qué lo estoy 00:29:35
Haciendo en texto y en audio 00:29:37
Si esto no cambiara 00:29:38
Siendo exactamente el mismo 00:29:40
Método para uno y para el otro 00:29:43
A lo mejor lo habría podido llevar 00:29:45
O implementado en la clase documento 00:29:46
Y heredado directamente 00:29:49
También aquí no estoy utilizando longitud y numpad, entonces no lo sé, es muy relativo 00:29:51
Pero la idea era que se os pedía que funcionara distintamente, uno pone lee y uno pone escucha 00:30:02
Justo para que vosotros implementáreis esto de aquí 00:30:10
Es posible que esta parte de alguna forma la ponga en un documento 00:30:13
O haya un método de documento que luego de aquí llamo el método de documento que es el mismo 00:30:23
Por ejemplo la parte esta de aquí 00:30:28
Que me devuelve un true o false de un método de documento 00:30:30
Aquí llamo super este método 00:30:34
O directamente aquí porque tanto lo he redado 00:30:36
Y luego hacer, se puede hacer 00:30:39
¿Vale? Para evitar de repetir 00:30:41
El mismo código de una forma o de otra 00:30:43
Que si luego me doy cuenta que he hecho algo mal 00:30:45
Aquí, en vez de tener que cambiarlo 00:30:47
En todos lados, pues lo tenga centralizado 00:30:49
En un punto, cambio ese 00:30:51
Y luego simplemente cuando tengo la autorización 00:30:52
Lo que hago es cambiar 00:30:55
El texto de cada uno de ellos, se puede hacer 00:30:56
¿Vale? Pero esto ya 00:30:59
No lo tendré en cuenta 00:31:01
¿Sí? 00:31:04
¿Dudas? 00:31:08
Y con esto hemos acabado, digamos, la parte de, ¿cómo decirlo?, de entidades, de lo que voy a manejar, ¿vale?, en un cierto sentido. 00:31:09
Ahora empiezan las partes donde combino estas cosas, ¿vale?, como el archivo de documentos, que hace operaciones sobre este de aquí, 00:31:25
y luego el main, que lo que hace es llamar operaciones sobre el archivo de documentos, ¿vale? 00:31:34
En un cierto sentido, archivo de documentos es lo que me abstrae 00:31:39
Como está hecho el archivo por debajo 00:31:42
El archivo de documentos 00:31:44
Me proporciona una serie 00:31:47
De operaciones 00:31:48
Que puedo hacer sobre el archivo 00:31:50
Y yo lo que haré es pedir esas 00:31:51
Todo lo que son documentos, como se crean 00:31:53
Como se borran, como se autorizan 00:31:56
Pues está escondido 00:31:58
Por debajo de esta capa de 00:32:00
Archivo de documentos 00:32:02
¿Dudas? 00:32:04
Autor/es:
Stefano Chiesa
Subido por:
Stefano C.
Licencia:
Reconocimiento - No comercial
Visualizaciones:
12
Fecha:
14 de febrero de 2023 - 14:05
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
32′ 10″
Relación de aspecto:
1.78:1
Resolución:
1280x720 píxeles
Tamaño:
269.07 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid