泛型

一.泛型的概念

泛型的用法是在容器后面添加<Type>
Type可以是类，抽象类，接口
泛型表示这种容器只能存放Type类型
ArrayList<Hero> heros = new ArrayList<Hero>();
ArrayList<Hero> heros2 = new ArraList<>();

二.支持泛型的类

不支持泛型的类

   如果不使用泛型，就需要为每一种类型创建一个类

支持泛型的类

   在类的声明上加一个<T>
  public class MyStack<T> {

      LinkedList<T> values = new LinkedList<T>();
       public void push(T t) {
             values.addLast(t);
       }
     public T pull() {
             return values.removeLast();
       }

public T peek() {
    return values.getLast();
}
 public static void main(String[] args) {
    //在声明这个Stack的时候，使用泛型<Hero>就表示该Stack只能放Hero
    MyStack<Hero> heroStack = new MyStack<>();
    heroStack.push(new Hero());
    //不能放Item
    heroStack.push(new Item());
     
    //在声明这个Stack的时候，使用泛型<Item>就表示该Stack只能放Item
    MyStack<Item> itemStack = new MyStack<>();
    itemStack.push(new Item());
    //不能放Hero
    itemStack.push(new Hero());
}
}

三.通配符

1.? extends

 ArrayList heroList<? extends Hero> 表示这是一个Hero泛型或者其子类泛型
heroList的泛型可能是Hero/APHero/ADHero
所以从heroList取出来的对象一定是可以转型成Hero的，但是不能往里面放东西
因为放APHero就不满足<ADHero>
放ADHero又不满足<APHero>

   public static void main(String[] args) {
      
    ArrayList<APHero> apHeroList = new ArrayList<APHero>();
    apHeroList.add(new APHero());
     
    ArrayList<? extends Hero> heroList = apHeroList;
      
    //? extends Hero 表示这是一个Hero泛型的子类泛型
      
    //heroList 的泛型可以是Hero
    //heroList 的泛型可以使APHero
    //heroList 的泛型可以使ADHero
      
    //可以确凿的是，从heroList取出来的对象，一定是可以转型成Hero的
      
    Hero h= heroList.get(0);
      
    //但是，不能往里面放东西
    heroList.add(new ADHero()); //编译错误，因为heroList的泛型 有可能是APHero
      
}

2.? super

   ArrayList heroList<? super Hero> 表示这是一个Hero泛型或者其父类泛型
   heroList的泛型可能是Hero
   heroList的泛型可能是Object

   可以往里面插入Hero以及Hero的子类
   但是取出来有风险，因为不确定取出来是Hero还是Object
    public static void main(String[] args) {

    ArrayList<? super Hero> heroList = new ArrayList<Object>();
      
    //? super Hero 表示 heroList的泛型是Hero或者其父类泛型
      
    //heroList 的泛型可以是Hero
    //heroList 的泛型可以是Object
      
    //所以就可以插入Hero
    heroList.add(new Hero());
    //也可以插入Hero的子类
    heroList.add(new APHero());
    heroList.add(new ADHero());
      
    //但是，不能从里面取数据出来,因为其泛型可能是Object,而Object是强转Hero会失败
    Hero h= heroList.get(0);
   }

3.泛型通配符?

    泛型通配符? 代表任意泛型
    既然?代表任意泛型，那么换句话说，这个容器什么泛型都有可能

   所以只能以Object的形式取出来
   并且不能往里面放对象，因为不知道到底是一个什么泛型的容器
    public static void main(String[] args) {

    ArrayList<APHero> apHeroList = new ArrayList<APHero>();
     
    //?泛型通配符，表示任意泛型
    ArrayList<?> generalList = apHeroList;

    //?的缺陷1： 既然?代表任意泛型，那么换句话说，你就不知道这个容器里面是什么类型
    //所以只能以Object的形式取出来
    Object o = generalList.get(0);

    //?的缺陷2： 既然?代表任意泛型，那么既有可能是Hero,也有可能是Item
    //所以，放哪种对象进去，都有风险，结果就什么什么类型的对象，都不能放进去
    generalList.add(new Item()); //编译错误 因为?代表任意泛型，很有可能不是Item
    generalList.add(new Hero()); //编译错误 因为?代表任意泛型，很有可能不是Hero
    generalList.add(new APHero()); //编译错误  因为?代表任意泛型，很有可能不是APHero 
   }

4.总结

   如果希望只取出，不插入，就使用? extends Hero
   如果希望只插入，不取出，就使用? super Hero
   如果希望，又能插入，又能取出，就不要用通配符？

四.泛型转型

  子类泛型不可以转换为父类泛型,父类泛型不能转型为子类泛型