¿Qué significan esas letras en los genéricos de Java? (E,T,K,V,S)
¡Explicación detallada de clases genéricas, interfaces genéricas y métodos genéricos!
Al definir una clase, interfaz o método, puede utilizar parámetros de tipo (parámetros de tipo) para representar tipos desconocidos, lo que hace que su código sea más general y flexible. A continuación se proporcionan ejemplos de clases, interfaces y métodos:
1. Utilice parámetros de tipo en la clase:
public class Box<T> {
private T value;
public Box(T value) {
this.value = value;
}
public T getValue() {
return value;
}
public void setValue(T value) {
this.value = value;
}
}
En este ejemplo, Boxla clase utiliza un parámetro de tipo Tpara representar el tipo desconocido y el tipo concreto se puede especificar cuando se crea el objeto. Por ejemplo, Boxse puede crear un objeto para almacenar valores de tipo entero:
Box<Integer> integerBox = new Box<>(10);
Integer value = integerBox.getValue(); // 获取整数值
También es posible crear un Boxobjeto para almacenar valores de tipo cadena:
Box<String> stringBox = new Box<>("Hello");
String value = stringBox.getValue(); // 获取字符串值
2. Utilice parámetros de tipo en la interfaz:
public interface List<T> {
void add(T element);
T get(int index);
}
En este ejemplo, Listla interfaz utiliza parámetros de tipo Tpara representar tipos desconocidos y se pueden especificar tipos concretos al implementar la interfaz. Por ejemplo, se puede implementar una lista de números enteros:
public class IntegerList implements List<Integer> {
private List<Integer> elements = new ArrayList<>();
@Override
public void add(Integer element) {
elements.add(element);
}
@Override
public Integer get(int index) {
return elements.get(index);
}
}
También se puede implementar una lista de cadenas:
public class StringList implements List<String> {
private List<String> elements = new ArrayList<>();
@Override
public void add(String element) {
elements.add(element);
}
@Override
public String get(int index) {
return elements.get(index);
}
}
3. Utilice el parámetro de tipo en el método:
public <T> T findMax(T[] array) {
if (array == null || array.length == 0) {
return null;
}
T max = array[0];
for (int i = 1; i < array.length; i++) {
if (array[i].compareTo(max) > 0) {
max = array[i];
}
}
return max;
}
En este ejemplo, findMaxel método utiliza parámetros de tipo Tpara representar tipos desconocidos y se pueden pasar parámetros de tipo específicos al llamar al método. Por ejemplo, se puede llamar a este método para encontrar el valor más grande en una matriz de números enteros:
Integer[] numbers = {
1, 5, 3, 9, 2};
Integer max = findMax(numbers); // 获取整数数组中的最大值
También se puede llamar a este método para encontrar el valor más grande en una matriz de cadenas:
String[] strings = {
"apple", "banana", "cherry", "date"};
String max = findMax(strings); // 获取字符串数组中的最大值
Al utilizar parámetros de tipo, las clases, interfaces y métodos pueden representar tipos desconocidos en el momento de la definición, lo que hace que el código sea más general y flexible para adaptarse a diferentes tipos de datos. Esto se usa ampliamente en el marco. Aquí hay algunos ejemplos prácticos:
ejemplo práctico
1. Genéricos en el marco de la colección Java:
Muchas interfaces y clases en el marco de la colección Java utilizan genéricos para representar los tipos de elementos de la colección, por ejemplo, ArrayList, LinkedListetc. HashMapAl utilizar genéricos, estas clases de colección pueden admitir diferentes tipos de elementos en tiempo de ejecución y proporcionar comprobaciones de seguridad de tipos en tiempo de compilación, evitando así la posibilidad de errores de conversión de tipos en tiempo de ejecución.
ArrayList<Integer> numbers = new ArrayList<Integer>(); // 创建一个整数列表
numbers.add(1);
numbers.add(2);
numbers.add(3);
int firstNumber = numbers.get(0); // 获取列表中的第一个整数
ArrayList<String> names = new ArrayList<String>(); // 创建一个字符串列表
names.add("Alice");
names.add("Bob");
names.add("Charlie");
String firstName = names.get(0); // 获取列表中的第一个字符串
2. Genéricos en Spring Framework:
Spring Framework es un potente marco para crear aplicaciones Java en las que se utilizan ampliamente genéricos para lograr una funcionalidad flexible y extensible. Por ejemplo, en Spring, los genéricos se pueden usar en escenarios como inyección de dependencia, acceso a datos y gestión de transacciones.
public interface CrudRepository<T, ID extends Serializable> {
T save(T entity); // 保存实体
T findById(ID id); // 根据ID查询实体
void delete(T entity); // 删除实体
// ...
}
En este ejemplo, CrudRepositoryla interfaz utiliza dos parámetros genéricos Ty ID, que representan el tipo de entidad y el tipo de ID, respectivamente. Al utilizar genéricos, CrudRepositoryse pueden especificar tipos de entidades y tipos de ID específicos al implementar la interfaz, logrando así soporte para diferentes tipos de entidades y de ID.
public class UserRepositoryImpl implements CrudRepository<User, Long> {
// 实现User实体的数据访问操作
// ...
}
En este ejemplo, UserRepositoryImplla clase implementa CrudRepositoryla interfaz y especifica el tipo de entidad como Usery el tipo de ID como Long, realizando así Userla operación de acceso a datos en la entidad.
Mediante el uso de genéricos, se pueden implementar funciones generales, flexibles y extensibles en el marco, mejorando así la reutilización y la capacidad de mantenimiento del código.
3. Genéricos en el marco personalizado:
En un marco o biblioteca personalizado, los genéricos también se pueden utilizar para lograr funciones generales y flexibles. Por ejemplo, supongamos que estamos creando un marco de capa de acceso a datos general que puede admitir operaciones de acceso a datos de diferentes tipos de entidades a través de genéricos.
public interface CrudRepository<T, ID> {
T save(T entity); // 保存实体
T findById(ID id); // 根据ID查询实体
void delete(T entity); // 删除实体
// ...
}
En este ejemplo, definimos una CrudRepositoryinterfaz genérica, donde el parámetro genérico Trepresenta el tipo de entidad y IDrepresenta el tipo de ID. Al usar genéricos, podemos CrudRepositoryespecificar tipos de entidades y tipos de ID específicos al implementar la interfaz, realizando así operaciones de acceso a datos en diferentes entidades y tipos de ID.
public class UserRepositoryImpl implements CrudRepository<User, Long> {
// 实现User实体的数据访问操作
// ...
}
En este ejemplo, UserRepositoryImplla clase implementa CrudRepositoryla interfaz y especifica el tipo de entidad como Usery el tipo de ID como Long, realizando así Userla operación de acceso a datos en la entidad.
Al utilizar genéricos en el marco personalizado, se pueden realizar funciones comunes y los usuarios pueden especificar de manera flexible diferentes tipos de parámetros al usar el marco, para satisfacer diferentes necesidades comerciales. Un diseño de este tipo puede mejorar la reutilización y flexibilidad del marco, al tiempo que evita la posibilidad de errores de conversión de tipos y excepciones de tiempo de ejecución.
4. Genéricos en métodos:
El uso de genéricos en un método puede hacer que el método sea más general y pueda manejar múltiples tipos de parámetros de entrada y valores de retorno. Por ejemplo, muchos métodos en el marco de colecciones de Java utilizan genéricos.
public class CollectionUtils {
public static <T> T getFirstElement(List<T> list) {
if (list != null && !list.isEmpty()) {
return list.get(0);
}
return null;
}
}
En este ejemplo, definimos un método estático getFirstElementque toma un parámetro genérico de tipo List<T>y devuelve el tipo de T. Esto significa que este método puede manejar cualquier tipo List, como List<Integer>, List<String>etc.
Un método que utiliza genéricos puede realizar inferencia de tipos basándose en el tipo de parámetro real al llamar, evitando así errores de conversión de tipos y puede proporcionar una mejor seguridad de tipos y reutilización de código.
En el marco de Spring, los genéricos también se usan ampliamente para lograr funciones comunes. Por ejemplo, en la clase JdbcTemplate de Spring, los genéricos se usan para admitir diferentes tipos de operaciones de bases de datos, reduciendo así el código repetitivo y mejorando la flexibilidad.
public class JdbcTemplate {
public <T> T queryForObject(String sql, RowMapper<T> rowMapper) {
// 执行SQL查询，并将结果映射到实体对象
// ...
}
// ...
}
En este ejemplo, queryForObjectel método utiliza un parámetro genérico Tpara indicar el tipo de entidad de la asignación de resultados de la consulta y recibe un RowMapper<T>parámetro para la asignación de resultados. De esta manera, se pueden realizar operaciones de consulta en diferentes RowMappertipos de entidades pasando diferentes clases de implementación, proporcionando así mayor flexibilidad y versatilidad.
Resumir:
En Java, los genéricos son una característica poderosa que se puede usar en clases, interfaces, métodos, etc. para lograr funciones generales, flexibles y de tipo seguro. También se usa ampliamente en marcos, que pueden proporcionar funciones comunes, reducir la duplicación de código, mejorar la flexibilidad y la seguridad de tipos, mejorando así la calidad del código y la eficiencia del desarrollo.