java-泛型

泛型

先看个思维导图呗

• 集合中的泛型

1.不使用泛型

不使用泛型带来的问题
ADHero（物理攻击英雄） APHero（魔法攻击英雄）都是Hero的子类
ArrayList 默认接受Object类型的对象，所以所有对象都可以放进ArrayList中
所以get(0) 返回的类型是Object
接着，需要进行强制转换才可以得到APHero类型或者ADHero类型。
如果软件开发人员记忆比较好，能记得哪个是哪个，还是可以的。 但是开发人员会犯错误，比如第20行，会记错，把第0个对象转换为ADHero,这样就会出现类型转换异常

package generic;import java.util.ArrayList;import charactor.ADHero;
import charactor.APHero;public class TestGeneric {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可以是类，抽象类，接口
泛型表示这种容器，只能存放APHero，ADHero就放不进去了。

package generic;
import java.util.ArrayList;
import charactor.APHero;
public class TestGeneric {public static void main(String[] args) {ArrayList<APHero> heros = new ArrayList<APHero>();//只有APHero可以放进去    heros.add(new APHero());//ADHero甚至放不进去//heros.add(new ADHero());//获取的时候也不需要进行转型，因为取出来一定是APHeroAPHero apHero =  heros.get(0);      }
}

3.子类对象

package generic;
import java.util.ArrayList;
import property.Item;
import charactor.ADHero;
import charactor.APHero;
import charactor.Hero;
public class TestGeneric {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());   }
}

4.泛型的简写

//后面可以只用<>
ArrayList heros2 = new ArrayList<>();

5.练习-泛型

根据数字类的知识，设计一个集合，这个集合里即可以放整数，也可以放浮点数，但是不能放字符串。

ArrayList number = new ArrayList<>();
或 List number = new ArrayList<>();

package Generics;
import java.util.ArrayList;
public class Test1_shuzi {public static void main(String[] args) {// TODO 自动生成的方法存根ArrayList<Number> num=new ArrayList<>();num.add(123);num.add(123f);num.add(123d);//num.add("sfdsf");for (Number item  : num ) {System.out.println(item);}}
}

或

package generic;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class Test1_shuzi {public static void main(String[] args) {Collection<Number> coll = new ArrayList<>();coll.add(101);coll.add(8.8);coll.add(5.66F);coll.add(107777773L);Iterator<Number> it = coll.iterator();while(it.hasNext()) {Object obj =  it.next();System.out.println(obj);}    }                                                                    		 		
}

注：集合泛型为 < Number > 下面使用迭代器取出的时候只能定义为Object父类类型去接收从集合里取出的元素。

• 支持泛型的类

1.不支持泛型的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);}} 
}

package property;
public class Item {String name;int price;public Item(){}public Item(String name){this.name = name;}public String toString() {return name;}
}

package generic;
import java.util.LinkedList;
import property.Item;
public class ItemStack {LinkedList<Item> Items = new LinkedList<Item>();public void push(Item h) {Items.addLast(h);}public Item pull() {return Items.removeLast();}public Item peek() {return Items.getLast();}public static void main(String[] args) {ItemStack ItemStack = new ItemStack();for (int i = 0; i < 5; i++) {Item item = new Item("Item name " + i);System.out.println("压入 Item:" + item);ItemStack.push(item);}for (int i = 0; i < 5; i++) {Item item =ItemStack.pull();System.out.println("弹出 Item" + item);}}  
}

2.支持泛型的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的时候，使用泛型就表示该Stack只能放HeroMyStack<Hero> heroStack = new MyStack<>();heroStack.push(new Hero());/** //不能放ItemheroStack.push(new Item());*///在声明这个Stack的时候，使用泛型就表示该Stack只能放ItemMyStack<Item> itemStack = new MyStack<>();itemStack.push(new Item());/** //不能放HeroitemStack.push(new Hero());*/} 
}

3.练习-支持泛型的二叉树

把二叉树中的Node类，改造成支持泛型。

package generic;
import java.util.ArrayList;
import java.util.List;public class Node<T> {// 左子节点public Node<T> leftNode;// 右子节点public Node<T> rightNode;// 值public T value;// 插入 数据public void add(T t) {// 如果当前节点没有值，就把数据放在当前节点上if (null == value)value = t;// 如果当前节点有值，就进行判断，新增的值与当前值的大小关系else {// 新增的值，比当前值小或者相同if ((Integer) t -((Integer)value) <= 0) {if (null == leftNode)leftNode = new Node<T>();leftNode.add(t);}// 新增的值，比当前值大else {if (null == rightNode)rightNode = new Node<T>();rightNode.add(t);}}}// 中序遍历所有的节点public List<T> values() {List<T> values = new ArrayList<>();// 左节点的遍历结果if (null != leftNode)values.addAll(leftNode.values());// 当前节点values.add(value);// 右节点的遍历结果if (null != rightNode)values.addAll(rightNode.values());return values;}public static void main(String[] args) {int randoms[] = new int[] { 67, 7, 30, 73, 10, 0, 78, 81, 10, 74 };Node<Integer> roots = new Node<>();for (int number : randoms) {roots.add(number);}System.out.println(roots.values());}
}

• 通配符

1.? extends

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

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

package generic;
import java.util.ArrayList;
import charactor.APHero;
import charactor.ADHero;
import charactor.Hero;
public class TestGeneric {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 表示这是一个Hero泛型或者其父类泛型
heroList的泛型可能是Hero
heroList的泛型可能是Object

可以往里面插入Hero以及Hero的子类
但是取出来有风险，因为不确定取出来是Hero还是Object

package generic; 
import java.util.ArrayList;
import charactor.ADHero;
import charactor.APHero;
import charactor.Hero;
public class TestGeneric {public static void main(String[] args) {ArrayList<? super Hero> heroList = new ArrayList<Object>();//? super Hero 表示 heroList的泛型是Hero或者其父类泛型//heroList 的泛型可以是Hero//heroList 的泛型可以是Object//所以就可以插入HeroheroList.add(new Hero());//也可以插入Hero的子类heroList.add(new APHero());heroList.add(new ADHero());/*//但是，不能从里面取数据出来,因为其泛型可能是Object,而Object是强转Hero会失败Hero h= heroList.get(0);*/  } 
}

3.泛型通配符?

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

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

package generic;
import java.util.ArrayList;
import property.Item;
import charactor.APHero;
import charactor.Hero;
public class TestGeneric {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()); //编译错误 因为?代表任意泛型，很有可能不是ItemgeneralList.add(new Hero()); //编译错误 因为?代表任意泛型，很有可能不是HerogeneralList.add(new APHero()); //编译错误  因为?代表任意泛型，很有可能不是APHero}
}

4.总结

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

5.练习

extends

如代码所示，为了遍历不同泛型的3种集合，需要设计3个方法
借助? extends， 把代码减肥到只是用一种方法

package generic;
import java.util.ArrayList;
import charactor.ADHero;
import charactor.APHero;
import charactor.Hero;
public class TestGeneric {public static void iterate(ArrayList<Hero> list) {for (Hero hero : list) {System.out.println(hero.name);}}public static void iterateAP(ArrayList<APHero> list) {for (Hero hero : list) {System.out.println(hero.name);}}public static void iterateAD(ArrayList<ADHero> list) {for (Hero hero : list) {System.out.println(hero.name);}}public static void main(String[] args) {ArrayList<Hero> hs = new ArrayList<>();ArrayList<APHero> aphs = new ArrayList<>();ArrayList<ADHero> adhs = new ArrayList<>();iterate(hs);iterateAP(aphs);iterateAD(adhs);}
}

代码减肥

package generic;
import charactor.Hero;
import charactor.ADHero;
import charactor.APHero;
import java.util.ArrayList;
public class IterateList {public static void iterate(ArrayList<? extends Hero> list) {for (Hero hero : list) {System.out.println(hero.name);}}public static void main(String[] args) {ArrayList<Hero> hs = new ArrayList<>();ArrayList<APHero> aphs = new ArrayList<>();ArrayList<ADHero> adhs = new ArrayList<>();hs.add(new Hero("Gareen"));aphs.add(new APHero("Ryze"));adhs.add(new ADHero("Ashe"));iterate(hs);iterate(aphs);iterate(adhs);}
}

注：通过普通泛型插入数据；使用取出。

二叉树

把练习-支持泛型的二叉树改造成 支持泛型 ，并在比较的时候使用compare方法

//实现了Comparable接口的Hero类
public class Hero implements Comparable<Hero> {public String name;public float hp;public float armor;public int moveSpeed;public Hero() {}public Hero(String heroName) {this.name = heroName;}public Hero(String heroName, float heroHP) {name = heroName;hp = heroHP;}public Hero(String heroName, float heroHP, float heroArmor, int heroMoveSpeed) {this(heroName, heroHP);armor = heroArmor;moveSpeed = heroMoveSpeed;System.out.println("名字\t血量\t护甲\t移动速度");System.out.println(name + "\t" + hp + "\t" + armor + "\t" + moveSpeed);}@Overridepublic int compareTo(Hero anotherHero) {if (hp > anotherHero.hp)return 1;elsereturn -1;}public void kill(Mortal m) {System.out.print(name + "击杀了");m.die();}public String toString() {return "名称：" + name + "\tHp：" + hp;}

//泛型为T extends Comparable的二叉树
package generic;
import java.util.ArrayList;
import java.util.List;
import character.Hero;
public class MyNode2<T extends Comparable<T>> {public T t;public MyNode2<T> leftNode;public MyNode2<T> rightNode;public void add(T t) {if (this.t == null)this.t = t;else {if (t.compareTo(this.t) <= 0) {if (null == leftNode)leftNode = new MyNode2<T>();leftNode.add(t);} else {if (null == rightNode)rightNode = new MyNode2<T>();rightNode.add(t);}}}public List<T> inOrder() {List<T> values = new ArrayList<>();if (null != leftNode)values.addAll(leftNode.inOrder());values.add(t);if (null != rightNode)values.addAll(rightNode.inOrder());return values;}public static void main(String[] args) {// Character类泛型MyNode2<Character> c = new MyNode2<>();for (int i = 0; i < 10; i++)c.add((char) (Math.random() * 94 + 33));System.out.println(c.inOrder());// Hero类（已实现Comparable接口）泛型MyNode2<Hero> heroes = new MyNode2<>();for (int i = 0; i < 10; i++)heroes.add(new Hero("英雄" + (i + 1), (int) (Math.random() * 901) + 100));for (Hero h : heroes.inOrder())System.out.println(h);}
}

• 泛型转型

1.对象转型

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

package generic;
import charactor.ADHero;
import charactor.Hero;
public class TestGeneric {public static void main(String[] args) {Hero h = new Hero();ADHero ad = new ADHero();//子类转父类h = ad;}
}

2.子类泛型转父类泛型

既然 子类对象 转 父类对象是可以成功的，那么子类泛型转父类泛型能成功吗？
如代码
hs的泛型是父类Hero
adhs 的泛型是子类ADHero

那么 把adhs转换为hs能成功吗？(不可以)



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

3.练习-父类泛型能否转换为子类泛型？
上面使用反证法分析了，子类泛型不能转换为父类泛型。

那么父类泛型又能否转换成子类泛型？ 为什么？（不可以）

本文来自互联网用户投稿，文章观点仅代表作者本人，不代表本站立场，不承担相关法律责任。如若转载，请注明出处。 如若内容造成侵权/违法违规/事实不符，请点击【内容举报】进行投诉反馈！