Java中级/泛型


一般等号(=)这种表达式,大多数都是要从右边看向左边的,意思是右边赋值给左

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>,表示该类支持泛型。
Ttype的缩写,也可以使用任何其他的合法的变量,比如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的泛型是父类Heroadhs 的泛型是子类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());
©️2020 CSDN 皮肤主题: 黑客帝国 设计师:上身试试 返回首页