泛型
先看个思维导图呗
- 集合中的泛型
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());
//获取的时候也不需要进行转型，因为取出来一定是APHero
APHero 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的时候，使用泛型<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());*/
}
}
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<? extends Hero> 表示这是一个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<? super Hero> 表示这是一个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
//所以就可以插入Hero
heroList.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()); //编译错误 因为?代表任意泛型，很有可能不是Item
generalList.add(new Hero()); //编译错误 因为?代表任意泛型，很有可能不是Hero
generalList.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);
}
}
注：通过普通泛型插入数据；使用<? extends Hero>取出。
二叉树
把练习-支持泛型的二叉树改造成 支持泛型 ，并在比较的时候使用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);
}
@Override
public int compareTo(Hero anotherHero) {
if (hp > anotherHero.hp)
return 1;
else
return -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.练习-父类泛型能否转换为子类泛型？
上面使用反证法分析了，子类泛型不能转换为父类泛型。
那么父类泛型又能否转换成子类泛型？ 为什么？（不可以）
扫一扫
423
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
