Genéricos

Genéricos: etiqueta
inserte la descripción de la imagen aquí

Tanto la interfaz de la colección como la clase de la colección se modifican a una estructura genérica después de jdk5.0
Al crear una instancia de una clase de colección, puede especificar un tipo genérico específico
Después de especificar, siempre que se defina una clase o interfaz en una clase de colección o interfaz de colección, la estructura interna que usa genéricos se designará como el tipo genérico en el momento de la creación de instancias.
El tipo genérico debe ser una clase, no un tipo de datos básico, y el tipo de datos básico debe usarse y reemplazarse con una clase contenedora.
Si la ubicación del tipo genérico no se especifica al crear una instancia, es el tipo de objeto

package Collection;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

import org.junit.Test;

public class ArrayListTest {
	// 使用泛型
	@Test
	public void test(){
		ArrayList<Integer> list = new ArrayList<Integer>();
		list.add(12);
		list.add(25);
		list.add(33);
		//list.add("AA");//报错，不让你进来了，保证数据的安全
		// 方式一
//		for(Integer scores : list){
//			int stuScore = scores;//不用强转了
//			System.out.println(stuScore);
//		}
	
		// 方式二
		Iterator<Integer> iterator = list.iterator();
		while(iterator.hasNext()){
			int scores = iterator.next();
			System.out.println(scores);
		}
		
	}
	
	//在集合中使用泛型
	@Test
	public void test2(){
		Map<String,Integer> map = new HashMap<String,Integer>();
		
		map.put("tom", 123);
		map.put("am", 52);
		map.put("sd", 13);
		map.put("twd", 173);
		
		// 泛型的嵌套
		Set<Map.Entry<String,Integer>> entry = map.entrySet();
		System.out.println(entry);
		Iterator<Map.Entry<String, Integer>> iterator = entry.iterator();
		while(iterator.hasNext()){
			Map.Entry<String, Integer> e = iterator.next();
			String key = e.getKey();
			Integer value = e.getValue();
			System.out.println(key + "----------" + value);
		}
		
		
	}

}

Estructura genérica personalizada: clase genérica, interfaz genérica, método genérico

Una clase de pedido personalizada

package File;

// 自定义泛型类
public class Order<T> {
	
	String orderName;
	int orderId;
	
	// 类的内部结构就可以使用类的泛型
	T orderT;
	public Order(){}
	
	public Order(String orderName,int orderId,T orderT){
		this.orderName = orderName;
		this.orderId = orderId;
		this.orderT = orderT;
	}
	
	public T getOrderT(){
		return orderT;
	}
	
	public void setOrderT(T orderT){
		this.orderT = orderT;
	}

	@Override
	public String toString() {
		return "Order [orderName=" + orderName + ", orderId=" + orderId + ", orderT=" + orderT + "]";
	}
	
	
}

Prueba bajo el mismo paquete.

package File;

import org.junit.Test;

public class GenericTest1 {
	
	@Test
	public void test1(){
		//Order order = new Order();  //没有指明类的泛型，则此泛型类型为Object
		// 建议写上,这样第三个参数就是String类型
		Order<String> order1 = new Order<String>("OrderAA",123,"string");
		
		
		
	}

}

Cuando una subclase hereda una clase principal con genéricos, especifica el tipo genérico. Al crear una instancia de un objeto, ya no necesita especificar el tipo genérico.

Puntos a tener en cuenta

inserte la descripción de la imagen aquí

Un método genérico es una estructura genérica que aparece en el método y los parámetros genéricos no tienen nada que ver con los parámetros genéricos de la clase. Es decir, no importa si la clase a la que pertenece el método genérico es una clase genérica.

Los métodos genéricos se pueden declarar estáticos porque los parámetros genéricos se determinan cuando se llama al método, no cuando se crea una instancia.

La encarnación de los genéricos en las relaciones de herencia.

La clase A es la clase padre de la clase B. G "A" y G "B" no tienen una relación de clase padre-hijo, sino que están en una relación paralela.

List<Object> list1 = null;
List<String> list2 = null;
list1 = list2;//报错

Pero A《G》 es la clase padre de B《G》

Uso de comodines

Comodín:?
¿La clase principal común de G《A》 y G《B》 es G《? 》

@Test
public void test2(){
	List<Object> list1 = null;
	List<String> list2 = null;
	
	List<?> list3 = null;
	
	list3 = list1;
	list3 = list2;
	
	print(list1);//
	print(list2); //都可以调用了
}

public void print(List<?> list){
	Iterator<?> iterator = list.iterator();
	while(iterator.hasNext()){
		Object obj = iterator.next();
		System.out.println(obj);
	}
	
	}

Para list<?>, no puede agregar datos a la lista. La única forma de agregar Null es permitir la lectura de datos. El tipo de lectura es objeto.

Uso restringido de comodines

? extiende Persona (<=Persona)
? super Persona (>=Persona)

Para el segundo, puedes agregar (Persona y subclases de Persona)

Java genérico