泛型

泛型用法

泛型的用法是在容器后面添加<Type>

ArrayList<APHero> heros = new ArrayList<APHero>();

//简写：
ArrayList<Hero> heros2 = new ArrayList<>();

Type可以是类，抽象类，接口；

泛型表示这种容器，只能存放APHero，ADHero就放不进去了。

创建支持泛型的类

设计一个支持泛型的栈 MyStack
设计这个类的时候，在类的声明上，加上一个，表示该类支持泛型。
T是type的缩写，也可以使用任何其他的合法的变量，比如A,B,X都可以，但是一般约定成俗使用T，代表类型。

package generic;
   
import java.util.HashMap;
import java.util.LinkedList;
 
import charactor.Hero;
import property.Item;
   
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());
    }
   
}

通配符

? extends

ArrayList heroList<? extends Hero> 表示这是一个Hero泛型或者其子类泛型（可以理解为这个heroList的元素类型是：Hero或其子类类型）：

heroList 的泛型可能是Hero
heroList 的泛型可能是APHero
heroList 的泛型可能是ADHero

所以可以确定的是，从heroList取出来的对象，一定是可以转型成Hero的

ArrayList<APHero> apHeroList = new ArrayList<APHero>();
apHeroList.add(new APHero());

ArrayList<? extends Hero> heroList = apHeroList;

//可以确凿的是，从heroList取出来的对象，一定是可以转型成Hero的
Hero h = heroList.get(0);

注：不能往里面放东西，因为：

放APHero就不满足<ADHero>

放ADHero又不满足<APHero>
1
heroList.add(new ADHero()); //编译错误，因为heroList的泛型有可能是APHero

? super

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

heroList的泛型可能是Hero
heroList的泛型可能是Object

可以往里面插入Hero以及Hero的子类：

放Hero没问题
放APHero、ADHero也没问题

但是取出来有风险，因为不确定取出来是Hero还是Object

1 2	ArrayList<? super Hero> heroList = new ArrayList<Object>(); //? super Hero 表示 heroList的泛型是Hero或者其父类泛型Object

//所以就可以插入Hero
heroList.add(new Hero());

//也可以插入Hero的子类
heroList.add(new APHero());
heroList.add(new ADHero());

1 2	//但是，不能从里面取数据出来,因为其泛型可能是Object,而Object是强转Hero会失败 Hero h= heroList.get(0);

泛型通配符【?】

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

取：只能以Object的形式取出来
放：不能往里面放对象，因为不知道到底是一个什么泛型的容器

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

总结

如果希望只取出，不插入，就使用? extends Hero

如果希望只插入，不取出，就使用? super Hero

如果希望，又能插入，又能取出，就不要用通配符？

泛型转型

对象转型

根据面向对象学习的知识，子类转父类是一定可以成功的

子类泛型转父类泛型

既然子类对象转父类对象是可以成功的，那么子类泛型转父类泛型能成功吗？（不能）
例如：

hs的泛型是父类Hero
adhs 的泛型是子类ADHero

那么把adhs转换为hs能成功吗？（不能）

父类转子类也不能