- 不使用泛型
不使用泛型带来的问题
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); } }
- 使用泛型
使用泛型的好处:
泛型的用法是在容器后面添加<Type>
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); } }
- 子类对象
假设容器的泛型是Hero,那么Hero的子类APHero,ADHero都可以放进去
和Hero无关的类型Item还是放不进去
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()); } }
- 泛型的简写
为了不使编译器出现警告,需要前后都使用泛型,像这样:
ArrayList<Hero> heros = new ArrayList<Hero>();
不过JDK7提供了一个可以略微减少代码量的泛型简写方式
ArrayList<Hero> heros2 = new ArrayList<>();
后面的泛型可以用<>来代替,聊胜于无吧
package generic; import java.util.ArrayList; import charactor.Hero; public class TestGeneric { public static void main(String[] args) { ArrayList<Hero> heros = new ArrayList<Hero>(); //后面可以只用<> ArrayList<Hero> heros2 = new ArrayList<>(); } }
- JAVA 如何设计支持泛型的类
不支持泛型的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 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); } } }
- 支持泛型的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()); } }
泛型
最新推荐文章于 2021-12-10 15:45:40 发布