一般等号(=)这种表达式,大多数都是要从右边看向左边的,意思是右边赋值给左
Hero h = new Hero();
ADHero ad = new ADHero();
//子类转父类
h = ad;
子类赋值给父类,则ad转换成了父类,相当与h = (h) ad
集合中的泛型
不使用泛型带来的问题:
ADHero(物理攻击英雄) APHero(魔法攻击英雄)都是Hero的子类
ArrayList
默认接受Object
类型的对象,所以所有对象都可以放进ArrayList
中,所以get(0)
返回的类型是Object
接着,需要进行强制转换才可以得到APHero类型或者ADHero类型。
如果软件开发人员记忆比较好,能记得哪个是哪个,还是可以的。 但是开发人员会犯错误,比如第20行,会记错,把第0个对象转换为ADHero,这样就会出现类型转换异常
ArrayList heros = new ArrayList();
heros.add(new APHero());
heros.add(new ADHero());
APHero apHero = (APHero) heros.get(0);
ADHero adHero = (ADHero) heros.get(1);
ADHero adHero2 = (ADHero) heros.get(0);
使用泛型:
使用泛型的好处:
泛型的用法是在容器后面添加<Type>
。Type
可以是类,抽象类,接口
泛型表示这种容器,只能存放APHero,ADHero就放不进去了。
ArrayList<APHero> heros = new ArrayList<APHero>();
//只有APHero可以放进去
heros.add(new APHero());
//ADHero甚至放不进去
//heros.add(new ADHero());
//获取的时候也不需要进行转型,因为取出来一定是APHero
APHero apHero = heros.get(0);
子类对象:
假设容器的泛型是Hero,那么Hero的子类APHero,ADHero都可以放进去.和Hero无关的类型Item还是放不进去
ArrayList<Hero> heros = new ArrayList<Hero>();
//只有作为Hero的子类可以放进去
heros.add(new APHero());
heros.add(new ADHero());
//和Hero无关的类型Item还是放不进去
//heros.add(new Item());
泛型的简写:
ArrayList<Hero> heros2 = new ArrayList<>();
支持泛型的类
不支持泛型的Stack :
以Stack栈为例子,如果不使用泛型
当需要一个只能放Hero的栈的时候,就需要设计一个HeroStack
当需要一个只能放Item的栈的时候,就需要一个ItemStack
package generic;
import java.util.LinkedList;
import charactor.Hero;
public class HeroStack {
LinkedList<Hero> heros = new LinkedList<Hero>();
public void push(Hero h) {
heros.addLast(h);
}
public Hero pull() {
return heros.removeLast();
}
public Hero peek() {
return heros.getLast();
}
public static void main(String[] args) {
HeroStack heroStack = new HeroStack();
for (int i = 0; i < 5; i++) {
Hero h = new Hero("hero name " + i);
System.out.println("压入 hero:" + h);
heroStack.push(h);
}
for (int i = 0; i < 5; i++) {
Hero h =heroStack.pull();
System.out.println("弹出 hero" + h);
}
}
}
支持泛型的stack:
设计一个支持泛型的栈MyStack
设计这个类的时候,在类的声明上,加上一个<T>
,表示该类支持泛型。
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());
}
}
练习:做支持泛型的二叉树
package j2se;
import java.util.ArrayList;
import java.util.List;
public class Node<T> {
public Node<T> leftNode;
public Node<T> rightNode;
public T hr;
public void adds(T t){
if (null == hr){
hr = t;
}else {
if(t instanceof Number || t instanceof Character || t instanceof Boolean || t instanceof String){
if (String.valueOf(t).compareTo(String.valueOf(hr)) <= 0) {
if (null == leftNode)
leftNode = new Node<T>();
leftNode.adds(t);
}
else {
if (null == rightNode)
rightNode = new Node<T>();
rightNode.adds(t);
}
}else if(t instanceof Hero){//不属于基本类型和字符串类型时,需要指定类型
if(((Hero)t).hp <= ((Hero)hr).hp) {
if (null == leftNode)
leftNode = new Node<T>();
leftNode.adds(t);
}
else{
if (null == rightNode)
rightNode = new Node<T>();
rightNode.adds(t);
}
}
}
}
public List<T> values(){
ArrayList<T> ls = new ArrayList<>();
if(null!=rightNode){
ls.addAll(rightNode.values());
}
ls.add(this.hr);
if(null!=leftNode){
ls.addAll(leftNode.values());
}
return ls;
}
public static void main(String[] args){
Node<Hero> HeroRoots = new Node<>();
for (int i = 0;i<10;i++){
Hero h = new Hero("hero"+i);
h.hp = (float)(Math.random()*1000);
System.out.println(h);
HeroRoots.adds(h);
//System.out.println(HeroRoots.values());
}
ArrayList<Hero> ln = (ArrayList<Hero>) HeroRoots.values();
for(Hero l:ln){
System.out.println("英雄名:"+l.name+"血量值为: "+l.hp);
}
}
}
通配符
? extends
ArrayList heroList<? extends Hero>
表示这是一个Hero
泛型或者其子类泛型
heroList 的泛型可能是Hero
heroList 的泛型可能是APHero
heroList 的泛型可能是ADHero
所以 可以确凿的是,从heroList取出来的对象,一定是可以转型成Hero的
但是,不能往里面放东西,因为
放APHero就不满足 < ADHero>
放ADHero又不满足 < APHero>
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
? super
ArrayList heroList<? super Hero>
表示这是一个Hero泛型或者其父类泛型
heroList的泛型可能是Hero
heroList的泛型可能是Object
可以往里面插入Hero以及Hero的子类
但是取出来有风险,因为不确定取出来是Hero还是Object
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);
泛型通配符?
泛型通配符?
代表任意泛型
既然?
代表任意泛型,那么换句话说,这个容器什么泛型都有可能
所以只能以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
如果希望,又能插入,又能取出,就不要用通配符?
泛型转型
对象转型:
子类转父类 是一定可以成功的
Hero h = new Hero();
ADHero ad = new ADHero();
//子类转父类
h = ad;
子类泛型转父类泛型
既然 子类对象 转 父类对象是可以成功的,那么子类泛型转父类泛型能成功吗?
如代码 hs
的泛型是父类Hero
;adhs
的泛型是子类ADHero
那么 把adhs
转换为hs
能成功吗?
ArrayList<Hero> hs =new ArrayList<>();
ArrayList<ADHero> adhs =new ArrayList<>();
//子类泛型转父类泛型
hs = adhs;
假设可以转型成功
引用hs
指向了ADHero
泛型的容器
作为Hero
泛型的引用hs
, 看上去是可以往里面加一个APHero
的。
但是hs
这个引用,实际上是指向的一个ADHero
泛型的容器
如果能加进去,就变成了ADHero
泛型的容器里放进了APHero,这就矛盾了
所以子类泛型不可以转换为父类泛型
public static void main(String[] args) {
ArrayList<Hero> hs =new ArrayList<>();
ArrayList<ADHero> adhs =new ArrayList<>();
//假设能转换成功
hs = adhs;
//作为Hero泛型的hs,是可以向其中加入APHero的
//但是hs这个引用,实际上是指向的一个ADHero泛型的容器
//如果能加进去,就变成了ADHero泛型的容器里放进了APHero,这就矛盾了
hs.add(new APHero());