泛型

泛型

把元素的类型设计成一个参数，这个类型参数就是泛型

集合容器类在设计阶段/声明阶段不能确定这个容器到底是存取的什么类型的对象，在jdk5.0之前只能把元素类型设置为Object，jdk5.0之后使用泛型的方式来解决这个问题。

泛型注意 ：

自定义泛型类、泛型接口、泛型方法

泛型类：

import com.sun.org.apache.xpath.internal.operations.Or;
import org.junit.Test;

public class TemplateTest {
    @Test
    public void test01(){
        //泛型类
        Order<Character> order=new Order<Character>(11,"geng",'c');
        System.out.println(order);
        order.setOrderE('1');
        System.out.println(order);
        MyOrder<Integer> myOrder=new MyOrder<>();
        myOrder.setDescription(12);
        myOrder.setOrderE("lala");
        System.out.println(myOrder);
    }
}
class Order<E>{
    int age;
    String name;
    E orderE;

    public Order() {
    }

    public Order(int age, String name, E orderE) {
        this.age = age;
        this.name = name;
        this.orderE = orderE;
    }

    public E getOrderE() {
        return orderE;
    }

    public void setOrderE(E orderE) {
        this.orderE = orderE;
    }

    @Override
    public String toString() {
        return "Order{" +
                "age=" + age +
                ", name='" + name + '\'' +
                ", orderE=" + orderE +
                '}';
    }
}
class MyOrder<T> extends Order<String>{
    T description;

    @Override
    public String toString() {
        return "MyOrder{" +
                "age=" + age +
                ", name='" + name + '\'' +
                ", orderE=" + orderE +
                ", description=" + description +
                '}';
    }

    public T getDescription() {
        return description;
    }

    public void setDescription(T description) {
        this.description = description;
    }
}

泛型方法：

并不是说只要方法中出现了泛型就是泛型方法

泛型方法中的泛型和泛型类中的泛型没有任何关系（所以说泛型方法所在的类不一定是泛型类）

import com.sun.org.apache.xpath.internal.operations.Or;
import org.junit.Test;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class TemplateTest {
    @Test
    public void test01(){
        Integer[] integers=new Integer[]{1,2,3,4,5,6};
        List<Integer> list= Order.toList(integers);
        Iterator<Integer> integerIterator=list.iterator();
        while(integerIterator.hasNext()){
            System.out.println(integerIterator.next());
        }
    }
}
class Order {
    public static <E> List<E> toList(E[] array){
        List<E> list=new ArrayList<>();
        for(E e:array){
            list.add(e);
        }
        return list;
    }
}

泛型在继承方面的体现

类A是类B的父类，

但是C 和C是没有关系的

但是A和A是子父类关系

通配符在泛型中的使用

类似于占位符的思想

public void test02(){
    List<String> list1=null;
    List<Integer> list2=null;
    List<?> list=list1;
    //对于list这个变量是不可以添加数据的   除了null之外
    //对于这个list变量是可以读取的，读取的数据为object类型
}

@Test
public void test02(){
    Integer[] integers=new Integer[]{1,2,3,4,5,6};
    List<Integer> list= Arrays.asList(integers);
    show(list);
}
private void show(List<?> list){
    for(Object temp:list){
        System.out.println(temp.toString());
    }
}

有限制条件的通配符泛型的使用、

extends和super

import com.sun.org.apache.xpath.internal.operations.Or;
import org.junit.Test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;

public class TemplateTest {
    @Test
    public void test01() {
        List<? extends MyPerson> list1=null;
        List<? super MyPerson> list2=null;
        
        List<MyPerson> personList=null;
        List<Object> objectList=null;
        List<MyDog> dogList=null;
        
        
        list1=personList;
        // list1=objectList;这个是不允许的因为Object不是MyPerson的子类
        list1=dogList;


        list2=personList;
        list2=objectList;
        //list2=dogList;这个是不允许的，因为MyDog不是MyPerson的父类
    }
}
class MyPerson {
   
}
class MyDog extends MyPerson {

}