(笔记)-泛型

集合中的泛型

一、不使用泛型和使用泛型

1.不使用泛型

不使用泛型带来的问题：
ADHero（物理攻击英雄） APHero（魔法攻击英雄）都是Hero的子类，ArrayList 默认接受Object类型的对象，所以所有对象都可以放进ArrayList中。所以get(0) 返回的类型是Object，因而需要进行强制转换才可以得到APHero类型或者ADHero类型。

    public static void main(String[] args) {
         
        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);
    }

2.使用泛型

使用泛型的作用：
泛型的用法是在容器后面添加
Type可以是类，抽象类，接口

public static void main(String[] args) {
		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还是放不进去 。

public static void main(String[] args) {

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

        //只有作为Hero的子类可以放进去      

        heros.add(new APHero());

        heros.add(new ADHero());

        //和Hero无关的类型Item还是放不进去

        //heros.add(new Item());

    }

支持泛型的类

支持与不支持泛型

不支持泛型的stack

当需要一个只能放Hero的栈的时候，就需要设计一个HeroStack

当需要一个只能放Item的栈的时候，就需要一个ItemStack

支持泛型的stack

设计一个支持泛型的栈MyStack。

设计这个类的时候，在类的声明上，加上一个 <T>，表示该类支持泛型。

T是type的缩写，也可以使用任何其他的合法的变量，比如A,B,X都可以，但是一般约定成俗使用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());
    }
  
}

通配符

一、 List<? extends T>

ArrayList heroList<? extends Hero> 表示
这是一个Hero泛型或者其子类泛型
heroList 的泛型可能是Hero
heroList 的泛型可能是APHero
heroList 的泛型可能是ADHero
所以，从heroList取出来的对象，一定是可以转型成Hero的

但不能往里面放东西，因为
放APHero就不满足
放ADHero又不满足

List<? extends T>
可以获取（get），不可以插入(add)

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
         
    }

二、 List<? super T>

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);
         
    }

三、泛型通配符 <?>

泛型通配符,代表任意泛型，即这个容器什么泛型都有可能，所以只能以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
 
    }

泛型转型

一、对象转型

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

public static void main(String[] args) {

        Hero h = new Hero();

        ADHero ad = new ADHero();

        //子类转父类（ADhero是Hero的子类）

        h = ad;

    }

二、子类泛型可以转父类泛型？

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

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());
	}

作为Hero泛型的hs,是可以向其中加入APHero的
但是hs这个引用，实际上是指向的一个ADHero泛型的容器
如果能加进去，就变成了ADHero泛型的容器里放进了APHero，这就矛盾了。

所以子类泛型不可以转换为父类泛型

三、父类泛型可以转子类泛型？

假如一个父类ArrayList<Hero> heros里面添加了两种泛型		
ArrayList<APHero>,ArrayList<ADHero>
那么当ArrayList<Hero>转为子类，ArrayList<APHero> apheros会报错
因为其中的ArrayList<ADHero>是不能转换成ArrayList<APHero>的

public static void main(String[] args) {
		ArrayList<Hero> hs =new ArrayList<>();
		ArrayList<ADHero> adhs =new ArrayList<>();

		//子类泛型转父类泛型
		hs = adhs;
	}

所以父类泛型也不可以转换为子类泛型

ps：学习内容源自How2j