Hola a todos. Hoy quiero hablar sobre el principio PECS. Entiendo que ahora los gurús de la programación y las personas mayores experimentadas se han vuelto a presionar las manos en la cara, porque "Java Generics apareció en JDK 1.5, que fue lanzado el 30 de septiembre de 2004 ...". Pero si hay aquellos para quienes el principio PECS sigue siendo vago e incomprensible, y la búsqueda persistente en Google solo espesa la "niebla", bienvenido al gato, lo solucionaremos juntos hasta la iluminación espiritual completa. Quiero advertirle de inmediato que este artículo no cubre qué son los genéricos y qué es un comodín. Si no está familiarizado con estos conceptos, debe comprenderlos antes de leer.
A primera vista, el principio PECS parece bastante simple. Todos los que lo han conocido saben que este es un acrónimo de Producer Extends Consumer Super. Como se explica en numerosos artículos, si tenemos una colección escrita por un comodín con un límite superior ( extiende ), entonces este es el "productor". "Sólo 'produce', proporciona el elemento del contenedor y no recibe nada por sí mismo". Si tenemos una colección escrita con un comodín en el límite inferior ( super ), entonces este es un "consumidor" que "solo acepta, pero no puede proporcionar nada".
Bueno, eso es todo. Ahora dominamos la "magia oscura" de PECS y podemos ir con seguridad a una entrevista en Google para impresionar a los entrevistadores con nuestra sabiduría y experiencia. Solo queda una pequeña formalidad, lanzar su IDE favorito y asegurarse de que todo sea válido para mostrar: los contenedores delimitados por el borde superior solo pueden proporcionar objetos, y los contenedores limitados por el borde inferior son solo consumidores.
Para mayor claridad, digamos que tenemos una jerarquía de clases que comienza con Class0, que es el ancestro de Class1, que a su vez es el ancestro de Class2, y así sucesivamente. Y hay un método que toma una colección de tipo comodín con un límite superior como argumento.
someMethod (List<? extends Class3> list)
Según el principio PECS, no podemos poner nada en esta hoja, solo será el proveedor de datos.
List<? extends Class3> list
?
: , list, Class3, , list Class4, Class5, Class6 .. , – « »! :
public static void someMethod (List<? extends Class3> list) {
Class4 class4 = list.get(0);
}
:
public static void someMethod (List<? extends Class3> list) {
Class2 class2 = list.get(0);
}
: .
? ? - , , -. , . , . , Class3.
Class4 class4 = list.get(0);
- , -, Java . , , , , .
Class4 class4 = (Class4) list.get(0);
. ? ?
List<? extends Class3> list
(Class0, Class1, Class2), , : - -. List<Integer> list
, Number,
. , List<? extends Class3> list
Class4 Class5? ! JVM , List<? extends Class3>
. List<Class4>
, List<Class100500>
. List<Class100500>
, , Class3 Class4, , Number
List<Integer>
. , , List<? extends Class3>
Class3, - Class3, , , Class3.
PECS – «consumer super» («wildcard super — consumer, , »).
: wildcard super , wildcard extend – ? . List<? extends Class3>
- «» , List<? super Class3>
, «» Class3. ,
public static void someMethod (List<? super Class3> list) {
list.add(new Class4());
}
, :
public static void someMethod (List<? super Class3> list) {
list.add(new Class2());
}
, :
public static void someMethod (List<Integer> list) {
list.add(new Number());
}
, , «wildcard super — consumer » - . , , , «consumer super…»
public static void someMethod (List<? super Class3> list) {
list.get(0);
}
, -…
IDE, : , super, consumer! , , list.get(0)
. ? , Class3? ! , Class2 ( - super). ! Class4? . get()
, - ? «» Java - Object.
, PECS: , wildecard , Object?
, , , , , . , wildcard , , -, -.
«» ( Class2 Class3)
public static void someMethod (List<? super Class3> list) {
Class2 obj = list.get(0);
}
: List<Class1>
List<Object>
( <? super Class3>
) - (Class2 obj) (list.get(0)
). – , , Java, Object.
Eso es todo lo que me gustaría decirles sobre el principio PECS. Espero que mi explicación haya salido clara y ayude a quienes sufren la verdad a comprender este tema.