Saltar navegación

Clases Genéricas - 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 1 de marzo de 2023 por Stefano C.

14 visualizaciones

Más información Transcripción

Descargar la transcripción

Si habláis en este momento, como estoy grabando, me autorizáis a grabar vuestra voz. 00:00:00
Esta va a ser una sesión de teoría bastante breve, para introducir un concepto y para que sepáis que exista y que luego ahora lo utilizaremos en la otra parte de la clase. 00:00:09
No voy a grabar porque como es implementación, luego os doy el resultado de la implementación. 00:00:26
Y es el siguiente concepto. 00:00:31
Nosotros estamos acostumbrados a jugar, a utilizar clases que tienen dentro definidos los tipos de los atributos que vamos a utilizar. 00:00:34
Yo tengo la clase Persona, dentro tiene un objeto String que es el nombre, tiene un Int que es una edad, etc. 00:00:49
Puede haber situaciones y casos en el que yo tengo una clase que dentro utiliza algo, utiliza un atributo, pero el tipo de este atributo no me queda claro a priori. 00:00:57
Imaginaos, así es para hacer un ejemplo teórico, una bolsa. 00:01:16
Vosotros tenéis la clase Bolsa, donde dentro podéis poner lo que os da la gana. 00:01:22
Y un día dentro de la bolsa podéis poner el objeto Coche, otro día podéis poner el objeto Calculadora, y otro día podéis poner el objeto Rectángulo. 00:01:27
Y que luego vuestra bolsa haga algo con este objeto, dependiendo pero del tipo de objeto que yo estoy introduciendo. 00:01:37
Y que esto no está decidido a priori cuando yo creo la clase, sino que cuando uso la clase quiero especificar esta bolsa que puede contener. 00:01:48
Eso en Java es una clase genérica, es decir que yo en vez de decirme, mira este atributo aquí tiene un tipo String, pues le voy a dar un tipo genérico que luego cuando tú utilizarás esta clase me dirás que tipo es. 00:02:01
Entonces para utilizar un tipo genérico de este tipo, cuando yo declaro la clase aquí le pongo que esta clase se basa sobre un tipo genérico. 00:02:21
Normalmente para indicar un tipo genérico se utiliza una letra, y esta letra representa algo. 00:02:37
En realidad puedes utilizar lo que te da la gana, es un identificador. 00:02:45
Pero normalmente es una letra sola, por convención T estaría como tipo, o V podría ser como valor, o puedes usar lo que te da la gana. 00:02:48
Normalmente nosotros utilizamos T, no es obligatorio utilizar T. 00:02:58
Esto quiere decir que cuando crearé una clase genérica le tendré que especificar que tipo de objetos huye a esta clase genérica. 00:03:02
Y luego que puedo hacer, por ejemplo puedo decir, y tú tendrás un atributo 1, este T será el tipo que yo voy a utilizar. 00:03:12
Si aquí le digo que quiero hacer una clase genérica con tipo genérico String, pues automáticamente este atributo será un String. 00:03:26
Si yo le digo un coche, pues esto será un coche. Si yo le digo cocodrilo, pues esto será cocodrilo. 00:03:35
Y es un tipo genérico, yo ahora mismo mientras estoy haciendo la clase no lo sé que tipo es. 00:03:43
Cuando ahora en el Main me creo una clase genérica, pues le tendré que decir de qué quiero, y por lo tanto en automático este de aquí será un String. 00:03:50
O será un lo que sea. 00:04:01
Tengámoslo así sencillo. 00:04:03
Quiero crear una clase genérica. 00:04:08
Una clase genérica X es igual a new una clase genérica. 00:04:11
Esto sería un constructor normal y corriente de siempre. 00:04:23
Ahora le tendría que definir, si quiero, si no quiero posiblemente esto sería un Object. 00:04:30
Le puedo definir qué tipo de clase genérica quiero utilizar. 00:04:37
Definir esta cosa aquí. 00:04:46
Entonces la puedo definir aquí. 00:04:48
Cuando yo defino así, pues le estoy diciendo que el tipo que voy a utilizar aquí sería un String. 00:04:54
Por lo tanto, como aquí dentro yo utilizo un atributo T, pues este atributo de aquí será un String. 00:05:02
Y esto quiere decir que ahora si yo acedo a X.atrib1, como veis que para él es un String. 00:05:11
Si yo le dijera, no, mira, quiero hacer una clase genérica que dentro tiene objetos Scanner. 00:05:31
Son otros objetos que nosotros utilizamos. 00:05:40
Ahora cuando yo voy a mirar X.atrib1, para él ahora es un Scanner. 00:05:44
Esto nos viene principalmente útil ahora cuando haremos las colecciones. 00:05:54
Porque yo cuando creo una colección, tengo una colección que es una lista de objetos. 00:06:01
Sí, pero ¿qué objetos quieres ahí? 00:06:06
Entonces puedo hacer una lista de personas, puedo hacer una lista de String, puedo hacer una lista de Scanner, 00:06:08
puedo hacer una lista de cualquier objeto que yo identifique ahí. 00:06:14
La lista en general será un objeto general, será con un tipo genérico. 00:06:18
Pero si yo he hecho una lista donde puedo añadir objetos, le diré que puedes añadir objetos de tipo T. 00:06:27
Y si luego he hecho una lista de String, podrás añadir String. 00:06:34
Si le digo que has hecho una lista de coches, podrás añadir objetos de tipo coche. 00:06:38
Es como una abstracción, una generalización de lo que hay ahí dentro. 00:06:46
Y esto más o menos se indica aquí y luego se utiliza el tipo allá donde quieras. 00:06:52
Puedo crear un Array de objetos T. 00:07:00
Array conjunto de T. 00:07:08
Claramente cuando yo creo esto, pues esto tendrá más sentido. 00:07:17
Esto yo estoy enseñando más bien la sintaxis, el utilizo de esto. 00:07:22
Pero no estoy haciendo nada de eso, no lo estoy identificando ni nada. 00:07:27
Entonces, cuando yo he hecho esta cosa aquí de Scanner, si yo ahora hago x.conjunto de T, veis que es un Array de Scanner. 00:07:33
La idea es que donde yo haya utilizado T, ahora es lo que yo le he pasado aquí al momento de crear. 00:07:52
Y que yo pueda crear un public void método1 que pille como parámetros un T. 00:08:02
Un parámetro. 00:08:15
Y ahora sé que este método de aquí, cuando le tendré que pasar un parámetro, y este parámetro es de tipo el tipo que tú has seleccionado al momento de crear. 00:08:19
Si tú le has dado aquí String, pues este será método1 que pille un String. 00:08:29
Si te has puesto aquí coche, pues será que cuando tú lo haces aquí tendrás que pasarle como parámetro coche. 00:08:33
Y yo por ejemplo aquí podría hacer un param.toString y él utilizará el toString de la clase al que pertenece cuando será creado. 00:08:39
¿Dudas? 00:08:49
Tengo un objeto, creo un constructor, por ejemplo aquí, y voy a crear un objeto nuevo. 00:09:00
Y cuidado, por ejemplo, aquí tengo pequeños problemas, ¿vale? 00:09:13
Porque claro, cuando yo tengo que crear un objeto y tengo que instanciar este señor, yo no puedo, no sé qué objeto es. 00:09:17
Lo que no puede hacer es un mute. 00:09:28
¿Vale? 00:09:31
Porque si yo intento hacer esto, él se enfada. 00:09:32
Dice, oye mira, no puedo instanciar el tipo T porque no sé qué tipo es el T. 00:09:40
Y no existe. 00:09:45
¿Vale? 00:09:47
Entonces una opción que puede hacer es esta de aquí. 00:09:48
Digo, mira, yo te creo un nuevo objeto y este objeto lo castigo a T. 00:09:51
Pero cuidado, este es muy peligroso. 00:09:55
¿Por qué es peligroso esto? 00:09:57
Porque afectaría a cualquier tipo de T. 00:10:01
Porque tecnicamente yo estoy creando un objeto. 00:10:06
Un objeto genérico. 00:10:09
No estoy creando nada de T. 00:10:12
Y luego te estoy diciendo si es un T. 00:10:13
Pero no estoy usando el constructor de T. 00:10:15
Entonces este de aquí tiene muchas probabilidades que explote. 00:10:17
¿Vale? 00:10:21
Esta cosa aquí no me gusta mucho. 00:10:22
Lo más probable, lo más interesante sería, vale, pásamelo aquí. 00:10:24
Pásame un objeto de aquí. 00:10:28
Y yo lo que hago es ponértelo aquí dentro. 00:10:30
Entonces a la hora de utilizarlo. 00:10:36
Cuando tú vas a identificar que este de aquí es de tipo string. 00:10:39
Cuando tú me crearás un objeto me pasarás aquí un string. 00:10:44
¿Vale? 00:10:48
Que se corresponderá a eso. 00:10:49
Entonces esto ya lo guardaré como string. 00:10:51
Si yo aquí te he puesto que es de coches. 00:10:54
Pues entonces al crearlo aquí te paso un coche. 00:10:58
Y tú pondrás un coche aquí dentro. 00:11:01
¿Sí? 00:11:03
Otra opción es dejar esto vacío. 00:11:04
O sea, sin nada. 00:11:07
Y luego utilizar setter y getter. 00:11:11
¿Vale? 00:11:13
Y hacérmelo yo. 00:11:14
Yo me creo siempre un objeto de clase genérica vacío. 00:11:15
Y luego después voy añadiendo objetos con los métodos que se basan sobre el tipo genérico. 00:11:19
Y por lo tanto funcionará. 00:11:27
Entonces este de aquí no me da errores. 00:11:36
¿Vale? 00:11:39
Porque al fin y al cabo yo puedo guardar aquí un objeto. 00:11:40
Pero cuidado con el cast de esto porque podría enfadarse. 00:11:43
¿Sí? 00:11:47
Aquí también mismo problema. 00:11:49
¿Vale? 00:11:51
Estoy creando un objeto nuevo de tipo objeto. 00:11:52
Y luego lo estoy casteando a t. 00:11:56
Hay que ver si este t luego no se enfada. 00:11:58
¿Vale? 00:12:00
Aquí... 00:12:01
Da un error. 00:12:04
Ah, porque le he puesto esto. 00:12:11
Aquí es un par de ejemplos de utilizo. 00:12:15
¿Vale? 00:12:19
Entonces yo por ejemplo tengo un ejemplo clase genérica que es de tipo string. 00:12:20
Por lo tanto esta es la variable que define esta referencia aquí. 00:12:25
Y aquí lo que hago es un ejemplo clase genérica utilizando como tipo string. 00:12:30
¿Vale? 00:12:36
Entonces aquí he fijado que esta t es en realidad un tipo string. 00:12:37
¿Vale? 00:12:43
Entonces a este punto puedo acceder a un objeto, ponerle dentro y me lo acepta porque acepta strings. 00:12:44
¿Vale? 00:12:51
O en una red de objetos genéricos en posición cero y ponerle un string porque esto es una red de string ahora. 00:12:52
¿Vale? 00:13:00
Fijaos que puedo crearme otro objeto. 00:13:01
Otro objeto de clase genérica. 00:13:05
Es la misma clase. 00:13:08
Pero ahora le digo que oye tú no contienes strings y no contienes personas. 00:13:09
Entonces tu objeto t ahora está asociado con personas. 00:13:14
Y entonces ahora dentro donde antes le ponía un string que me decía todo bien, 00:13:18
ahora aquí le pongo una nueva persona. 00:13:23
Y me dice ok. 00:13:27
¿Vale? 00:13:28
Porque este objeto de aquí como clase genérica utiliza una persona y no un string. 00:13:29
La idea de fondo se entiende. 00:13:36
Es parametrizar en un cierto sentido un tipo sin ligarme a que esto tiene que ser un string y no puede ser otra cosa. 00:13:38
Sino dejarlo libre. 00:13:45
¿Vale? 00:13:47
A que yo pueda estanciar cuando lo necesito. 00:13:48
Fijaos que no es que se estancia a tiempo de ejecución. 00:13:51
Esto es siempre tiempo de compilación. 00:13:53
¿Vale? 00:13:55
Mientras yo estoy codificando, mientras yo estoy programando pues decido que este objeto de aquí tiene personas. 00:13:56
La idea es crear objetos, crear clases que sean suficientemente genéricas para que puedan trabajar con distintos tipos de objetos. 00:14:02
¿Vale? 00:14:11
Donde esto se usa en varias cosas pero donde esto viene intuitivamente claro es cuando ahora, y lo veremos en un minuto, 00:14:12
pues vamos a utilizar colecciones. 00:14:19
¿Vale? 00:14:22
Pensar de un array en un cierto sentido. 00:14:23
Con un array ya lo estamos utilizando esto porque tú puedes hacer un array de string o un array de enteros o un array de personas. 00:14:28
El concepto de array es siempre el mismo, como utilizáis el array, como accedes a cada una. 00:14:35
Es siempre lo mismo pero el tipo de datos que estáis almacenando pues varia. 00:14:40
En vez de utilizar los arrays que es una cosa que Java me proporciona directamente, 00:14:45
lo que estoy haciendo es creándome mi propia clase, mi propio objeto que trabaje como yo quiero que trabaje, 00:14:51
pero no me fijo en un determinado tipo que es el que trabaje sino lo dejo libre para que tú puedas utilizarlo cuando te vayas. 00:15:01
Si yo creo un objeto colección, es lo que decíamos antes de los arrays tienen el problema que tienen un tamaño fijo. 00:15:07
Si ahora quiero salirme de ese problema y decir quiero crearme una clase que oculte lo que haya debajo, 00:15:15
si es un array, si es otra forma de hacer las cosas, pero quiero que más o menos sea una colección de datos, 00:15:23
que yo pueda almacenar allí dentro datos. 00:15:29
Si tengo una nueva persona pues la almaceno allí dentro. 00:15:32
Si tengo 39 personas la almaceno allí dentro. 00:15:34
Y sigo adelante así y puedo buscar y puedo hacer cosas con esta clase. 00:15:36
Pero no quiero que esta colección sea solo de string. 00:15:43
No quiero hacer 37 veces la colección de string, colección de personas, colección de objetos, colección de... 00:15:47
porque cada vez que hay un objeto nuevo si no debería estar otra vez a crearme una nueva colección, 00:15:54
una nueva clase colección de el nuevo objeto que he creado. 00:15:59
Entonces la quiero hacer más abstracta, tener una colección de no sé qué, de clases genéricas, de tests. 00:16:02
Y luego sea la persona que lo va a utilizar que implemente que esta vez lo quiero hacer un array de aeropuertos. 00:16:10
Entonces esta es un poquito la idea de clase genérica. 00:16:23
Ahora la vamos a aplicar en lo que vamos a ver a continuación. 00:16:26
A continuación lo que vamos a hacer es esto. 00:16:32
Os he preparado una interfaz. 00:16:35
Que es la interfaz MyCollection. 00:16:39
La interfaz MyCollection de un tipo genérico. 00:16:42
La idea es que yo pueda crear objetos, digamos, clases que implementen esta interfaz 00:16:47
y que para implementar esta interfaz tengan que implementar estos métodos. 00:16:58
La idea es la que decíamos antes. 00:17:05
Es decir, yo hasta ahora cuando tenía que almacenar un conjunto de objetos 00:17:08
lo que podía hacer y lo que hacía era utilizar un array. 00:17:13
Entonces yo me creaba un array de 10 posiciones, empezaba a meter personas allí 00:17:17
y teníamos estos problemas de que hago cuando llego a que está lleno mi array 00:17:21
y tengo que añadir una persona nueva. 00:17:26
Y aquí había varias opciones que hemos visto. 00:17:28
Es decir, puedo añadir de uno en uno. 00:17:31
Tenía 10 posiciones, pues ahora pongo un array de 11 posiciones, copio las primeras 10 00:17:33
y en la última pongo la persona nueva. 00:17:39
Tenía la posibilidad de doblar, es decir, cuando 10 ya no son suficientes 00:17:41
pues creo un nuevo array pero lo creo de 20. 00:17:46
Y eso me permite añadir la siguiente y hasta 9 más. 00:17:50
Cuando ya no está aquí pues lo doblo otra vez y ya tengo 40. 00:17:54
¿Qué ventaja tenía esto? 00:17:57
Que perdía menos tiempo en copiar. 00:17:59
Porque cada vez que copio el array pues estoy perdiendo tiempo para nada. 00:18:02
Estoy sustancialmente haciendo una operación de copia de todas las referencias de los objetos 00:18:06
pero no me sirve de nada. 00:18:11
No me está aportando nada. 00:18:13
Es simplemente porque lo necesito por problemas técnicos de no tengo más espacio. 00:18:15
Entonces, quiero olvidarme de eso. 00:18:20
Quiero extraer eso y simplemente crear una colección donde yo le digo 00:18:24
añade un objeto y que sea él por debajo el que hace ese trabajo. 00:18:32
A partir de que yo haya hecho mi classes, mi collection, 00:18:37
pues no tengo que volver a preocuparme de cómo se hace eso de los arrays por debajo. 00:18:42
Yo lo que hago es le digo añádeme este objeto y él según la implementación que haya hecho yo 00:18:47
hará lo que tiene que hacer. 00:18:52
Y así con todas las otras funciones. 00:18:54
Si os fijáis, estas son funciones para manejo de colecciones de objetos. 00:18:58
Puedo añadir un objeto, puedo saber cuánta es grande la colección actual, 00:19:03
es decir, cuántos objetos tengo almacenados ahora. 00:19:07
Puedo decir vaciar a toda. 00:19:10
Puedo decir, oye, mira, esta colección contiene este objeto. 00:19:12
O puedo pillar un objeto en un índice específico. 00:19:16
Ahora ya veremos qué quiere decir esto cuando lo implementaremos. 00:19:21
Puedo remover un objeto, es decir, búscame este objeto aquí y quítalo. 00:19:25
O puedo hacer remuéveme el objeto en posición 7. 00:19:30
Ahora la colección tendrá que contar 7 elementos, sea como sea el contar estos elementos. 00:19:34
Y cuando llegue al elemento 7, pues eso lo borrará. 00:19:42
O tu array, es decir, tú tienes una colección, ahora transfórmame en un array y dame este array. 00:19:45
Porque a lo mejor luego a partir de aquí quiero hacer algo con este array y lo quiero borrar. 00:19:52
Estas no son todas las operaciones que se podrían hacer sobre una colección. 00:19:57
Luego veremos qué es la colección de Java, pero eso a posteriori. 00:20:01
Mi idea es que ahora lo vamos a implementar nosotros, vamos a hacer nuestras colecciones. 00:20:06
Y cuando ya hemos entendido qué quiere decir implementar una colección, 00:20:11
qué quiere decir hacer estas cosas y que hay formas distintas de hacerlas 00:20:16
y que me puedo inventar mis modos para hacer las mismas cosas. 00:20:20
A ese punto vamos a ver qué nos proporciona Java. 00:20:23
Que son las clases que existen ya en Java y que me permiten hacer esto 00:20:28
de una forma posiblemente más optimizada, más segura, con menos problemas 00:20:33
y sobre todo que yo no me pueda olvidar de tener que hacerlo cada vez. 00:20:37
Porque ya están dentro del jr. 00:20:41
De paso, vamos a repasar tanto gestión de array como otras cosillas un poquito más interesantes 00:20:47
que veremos y esto de aquí, cada uno de estos métodos, al fin y al cabo 00:20:58
será un pequeño algoritmo que tengo que implementar. 00:21:04
Por lo tanto nos viene bien a nosotros porque son ejercicios mirados 00:21:08
como eso de pillar un array y aumentarlo o cosa por eso. 00:21:12
Subido por:
Stefano C.
Licencia:
Reconocimiento - No comercial
Visualizaciones:
14
Fecha:
1 de marzo de 2023 - 11:25
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
21′ 22″
Relación de aspecto:
1.78:1
Resolución:
1280x720 píxeles
Tamaño:
178.64 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid