Programación

1º DAM/DAW - Curso 2024-2025

User Tools

Site Tools

Trace:
apuntes:genericos

Differences

This shows you the differences between two versions of the page.

Link to this comparison view

Next revision		Previous revision
apuntes:genericos [2021/03/10 13:16] – created Santiago Faciapuntes:genericos [2023/05/28 12:04] (current) – [El comodín ?] Santiago Faci
Line 1: Line 1:
 ====== Genéricos ====== ====== Genéricos ======
  
-\section{Genéricos}+===== Genéricos =====
  
 El uso más conocido de los genéricos lo vimos en el tema anterior, con las colecciones, ya que éstas están definidas como clases genéricas, El uso más conocido de los genéricos lo vimos en el tema anterior, con las colecciones, ya que éstas están definidas como clases genéricas,
 lo que permite que podamos definir estructuras de la siguiente forma: lo que permite que podamos definir estructuras de la siguiente forma:
  
-\begin{lstlisting}[language=java]+<code java>
 List<String> listaCadenas = new ArrayList<>(); List<String> listaCadenas = new ArrayList<>();
-\end{lstlisting}+</code>
  
 Lo que permite que, si cometemos algún error como este, podamos ser avisados en tiempo de compilación: Lo que permite que, si cometemos algún error como este, podamos ser avisados en tiempo de compilación:
  
-\begin{lstlisting}[language=java]+<code java>
 Integer i = listaCadenas.get(0);    // Error de compilación Integer i = listaCadenas.get(0);    // Error de compilación
-\end{lstlisting}+</code>
  
 Sin la existencia de los genéricos, la línea anterior sería como esta: Sin la existencia de los genéricos, la línea anterior sería como esta:
  
-\begin{lstlisting}[language=java]+<code java>
 Integer i = listaCadenas.get(0);    // Nunca daría error de compilación Integer i = listaCadenas.get(0);    // Nunca daría error de compilación
-\end{lstlisting}+</code>
  
 Y nunca produciría ningún error de compilación en caso de que estuvieramos cometiendo algún error. A este respecto conviene saber que los Y nunca produciría ningún error de compilación en caso de que estuvieramos cometiendo algún error. A este respecto conviene saber que los
-genéricos sólo existen a nivel de compilación, para evitar este tipo de fallos. En el código generado se añaden todos los \emph{casting}+genéricos sólo existen a nivel de compilación, para evitar este tipo de fallos. En el código generado se añaden todos los ''casting''
 necesarios para que el código pueda ejecutarse sin problemas. necesarios para que el código pueda ejecutarse sin problemas.
  
-\subsection{Definición de una clase genérica}+==== Definición de una clase genérica ====
  
 El siguiente fragmento de código se correspondería con la definición de una clase genérica: El siguiente fragmento de código se correspondería con la definición de una clase genérica:
  
-\begin{lstlisting}[language=java]+<code java>
 public class Grupo<E> { public class Grupo<E> {
     private List<E> participantes;     private List<E> participantes;
Line 59: Line 59:
     }     }
 } }
-\end{lstlisting}+</code>
  
 De esa forma, una definición genérica como la anterior, puede emplearse con distintos tipos de datos: De esa forma, una definición genérica como la anterior, puede emplearse con distintos tipos de datos:
  
-\begin{lstlisting}[language=java]+<code java>
 Grupo<Alumno> grupoAlumnos = new Grupo<>(20); Grupo<Alumno> grupoAlumnos = new Grupo<>(20);
 . . . . . .
 Grupo<Profesor> grupoProfesores = new Grupo<>(10); Grupo<Profesor> grupoProfesores = new Grupo<>(10);
 . . . . . .
-\end{lstlisting}+</code>
  
 Como has podido ver en la definición, al tipo genérico va entre los caracteres < y > definido con una sola letra mayúscula, y una vez Como has podido ver en la definición, al tipo genérico va entre los caracteres < y > definido con una sola letra mayúscula, y una vez
Line 74: Line 74:
 clase genérica. A este respecto se suelen utilizar diferentes letras para diferentes situaciones: clase genérica. A este respecto se suelen utilizar diferentes letras para diferentes situaciones:
  
-\begin{itemize} +  * ''E'' para definir un elemento de una colección 
-    \item \verb E  para definir un elemento de una colección +  * ''K'' para definir una clave en un mapa 
-    \item \verb K  para definir una clave en un mapa +  * ''V'' para definir un valor en un mapa 
-    \item \verb V  para definir un valor en un mapa +  * ''T'', ''U''  para definir tipos de datos (clases)
-    \item \verb T , \verb U  para definir tipos de datos (clases) +
-\end{itemize}+
  
-\subsection{Métodos genéricos}+==== Métodos genéricos ====
  
 Así como se pueden definir clases genéricas, también podemos definir métodos genéricos dentro de clases que no lo sean: Así como se pueden definir clases genéricas, también podemos definir métodos genéricos dentro de clases que no lo sean:
  
-\begin{lstlisting}[language=java]+<code java>
 public class Utils { public class Utils {
     public <T> T getUltimoElemento(ArrayList<T> lista) {     public <T> T getUltimoElemento(ArrayList<T> lista) {
Line 91: Line 89:
     }     }
 } }
-\end{lstlisting}+</code>
  
-De esa manera, se podrá invocar al método \verb getUltimoElemento  con cualquier \verb ArrayList , independientemente del tipo que sea.+De esa manera, se podrá invocar al método ''getUltimoElemento'' con cualquier ''ArrayList'', independientemente del tipo que sea.
  
-\subsection{El comodín ?}+==== El comodín ? ====
  
-También se puede utilizar el caracter comodín \verb ?  para indicar que se acepta cualquier tipo, definiendo, por ejemplo, como parámetro un+También se puede utilizar el caracter comodín ''?'' para indicar que se acepta cualquier tipo, definiendo, por ejemplo, como parámetro un
 \verb ArrayList  de la siguiente forma: \verb ArrayList  de la siguiente forma:
  
-\begin{lstlisting}[language=java]+<code java>
 . . . . . .
 public void metodo(ArrayList<?> elementos) { public void metodo(ArrayList<?> elementos) {
Line 107: Line 105:
 } }
 . . . . . .
-\end{lstlisting}+</code>
  
 Para este caso también podemos aprovecharnos de las características de la herencia para la definición de métodos genéricos, pudiendo definir el uso de la Para este caso también podemos aprovecharnos de las características de la herencia para la definición de métodos genéricos, pudiendo definir el uso de la
Line 114: Line 112:
 Para aceptar cualquier clase que extienda de una determinada clase: Para aceptar cualquier clase que extienda de una determinada clase:
  
-\begin{lstlisting}[language=java]+<code java>
 . . . . . .
 public void Zoo { public void Zoo {
Line 125: Line 123:
 } }
 . . . . . .
-\end{lstlisting}+</code>
  
 Y para aceptar cualquier clase que esté por encima de una determinada clase: Y para aceptar cualquier clase que esté por encima de una determinada clase:
  
-\begin{lstlisting}[language=java]+<code java>
 . . . . . .
 public void Zoo { public void Zoo {
Line 140: Line 138:
 } }
 . . . . . .
-\end{lstlisting}+</code>
  
 De esa manera, podremos invocar al método \verb anadir  de múltiples formas, siempre y cuando pasemos como parámetro \verb ArrayList un tipo De esa manera, podremos invocar al método \verb anadir  de múltiples formas, siempre y cuando pasemos como parámetro \verb ArrayList un tipo
Line 146: Line 144:
 siguientes clases: siguientes clases:
  
-\begin{lstlisting}[language=java]+<code java>
 public class Animal { public class Animal {
 . . . . . .
 } }
-\end{lstlisting}+</code>
  
-\begin{lstlisting}[language=java]+<code java>
 public class Leon extends Animal { public class Leon extends Animal {
 . . . . . .
 } }
-\end{lstlisting}+</code>
  
-\begin{lstlisting}[language=java]+<code java>
 public class Zoo { public class Zoo {
     . . .     . . .
Line 167: Line 165:
     . . .     . . .
 } }
-\end{lstlisting}+</code>
  
 Las siguiente invocaciones producirían un error de compilación por incompatibilidad de tipos: Las siguiente invocaciones producirían un error de compilación por incompatibilidad de tipos:
  
-\begin{lstlisting}[language=java]+<code java>
 . . . . . .
 Zoo zoo = new Zoo(. . .); Zoo zoo = new Zoo(. . .);
Line 178: Line 176:
 zoo.anadirAnimales(leones);                 // Error de compilación zoo.anadirAnimales(leones);                 // Error de compilación
 . . . . . .
-\end{lstlisting}+</code>
  
 Es por eso que tenemos que usar lo que se conoce como los comodínes. Es por eso que tenemos que usar lo que se conoce como los comodínes.
Line 184: Line 182:
 Para el caso de las clases genéricas y métodos genéricos también podemos jugar con las características de herencia, utilizando las mismas Para el caso de las clases genéricas y métodos genéricos también podemos jugar con las características de herencia, utilizando las mismas
 expresiones que podemos usar con el comodín, pero con el caracter que empleemos para referirnos a la clase genérica. A diferencia del uso expresiones que podemos usar con el comodín, pero con el caracter que empleemos para referirnos a la clase genérica. A diferencia del uso
-del comodín \verb ? , podremos hacer referencia a la clase genérica a lo largo de la implementación del método o clase.+del comodín ''?'', podremos hacer referencia a la clase genérica a lo largo de la implementación del método o clase.
  
-\begin{lstlisting}[language=java]+<code java>
 public class Grupo<E extends Persona> { public class Grupo<E extends Persona> {
     private List<E> participantes;     private List<E> participantes;
Line 215: Line 213:
     }     }
 } }
-\end{lstlisting}+</code>
  
-\begin{lstlisting}[language=java]+<code java>
 . . . . . .
 public <T extends Animal> T getAnimal(ArrayList<T extends Animal> animales) { public <T extends Animal> T getAnimal(ArrayList<T extends Animal> animales) {
Line 226: Line 224:
 } }
 . . . . . .
-\end{lstlisting}+</code> 
 + 
 +---- 
 + 
 +(c) 2019-{{date>%Y}} Santiago Faci
  
apuntes/genericos.1615382177.txt.gz · Last modified: 2021/03/10 13:16 by Santiago Faci