泛型
泛型在前面的练习中我已经运用上了,接下来让我们看看泛型的作用
例如:
package com.TestDome; import java.util.ArrayList; import java.util.Iterator; /** * @author 杰哥 *泛型的作用 */ public class SelectDome { public static void main(String[] args) { //创建ArrayList集合对象 ArrayList list=new ArrayList(); //添加元素 list.add("hello"); list.add("world"); list.add("javaSE"); list.add(new Integer(100)); //创建迭代器 Iterator it= list.iterator(); //遍历 while(it.hasNext()) { String s=(String)it.next(); System.out.println(s); } } } 运行结果: hello world Exception in thread "main" javaSE java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String at com.TestDome.SelectDome.main(SelectDome.java:24)
由上例可以看出运行时出现了错误,//java.lang.ClassCastException:类转换异常,因为在我们的集合中分别有String和Integer两种类型的元素,String s=(String)it.next();在这里进行强制转换时就出现了上面的类转换异常的问题,在集合中我们应该怎么去避免这种问题呢?这时我们的泛型就起作用了
例如:
package com.TestDome; import java.util.ArrayList; import java.util.Iterator; /** * @author 杰哥 *泛型的应用 */ public class SelectDome { public static void main(String[] args) { //创建ArrayList集合对象 ArrayList<String> list=new ArrayList<String>(); //添加元素 list.add("hello"); list.add("world"); list.add("javaSE"); //创建迭代器 Iterator<String> it= list.iterator(); //遍历 while(it.hasNext()) { String s=it.next(); System.out.println(s); } } } 运行结果: hello world javaSE
上例中我们看到了泛型的运用
泛型:
格式: <数据类型>
泛型:将明确的集合类型的工作推迟到了创建对象或者调用方法的时候,属于一种参数化类型,可以作为参数传递.
泛型的好处:
1)将运行时期异常提前到了编译时期
2)优化了设计,解决了黄色警告线问题
3)避免了强制类型转换
当泛型运用于自定义类中的用法,在上面的的遍历ArrayList自定义类中已经运用到了,所以这里就不再写了
泛型可以用于类 接口 方法上,API上有<E>这个标志,都是代表着泛型
当泛型用于类上时:
例如:
package com.Object; //在类上定义一个<T>,它代表的是Object,在测试类中你可以换成你想要的数据类型 public class ObjectTool<T> { private T obj; public void set(T obj) { this.obj=obj; } public T get() { return obj; } } package com.Object; public class ObjectToolDome { public static void main(String[] args) { //创建类对象,泛型定为String时,就不能用其他类型了否则就会报错 ObjectTool<String> obj=new ObjectTool<String>(); //调用set方法,实质就是创建String obj=new String("迪丽热巴最美") obj.set(new String("迪丽热巴最美")); String s=obj.get(); System.out.println(s); System.out.println("------------------"); //当我们想输出Integer类型时,需要再创建一个类对象进行调用方法 ObjectTool<Integer> obj2=new ObjectTool<Integer>(); //实质上就是创建Integer obj2=new Integer(73); obj2.set(new Integer(73)); Integer in=obj2.get(); System.out.println(in); } } 运行结果: 迪丽热巴最美 ------------------ 73
当我们把泛型定义在方法上时:
例如:
package com.Object; class ObjectText{ //将泛型定义在方法上,在测试类中就可以接受任何类型的数据 public<T> void show(T t) { System.out.println(t); } } public class ObjectDome { public static void main(String[] args) { //创建类对象 ObjectText ot=new ObjectText(); ot.show("迪丽热巴"); ot.show(27); ot.show(true); } } 运行结果: 迪丽热巴 27 True
当我们把泛型放在接口上时,有两种方式:
例如:
package com.TextDome; interface Person<T>{ public abstract void show(); } //创建一个子实现类去实现这个接口 //方式1:直接确定数据类型 /*class Studentimpl implements Person<String>{ //重写接口中的show()方法 @Override public void show() { System.out.println("hello"); } }*/ //方式2:没有确定数据类型 class Studentimpl<T> implements Person<T>{ @Override public void show() { System.out.println("hello"); } } public class TextDome { public static void main(String[] args) { //创建子实现类对象 //这里可以定义类型为String,因为子实现类没有确定数据类型 Studentimpl<String> si=new Studentimpl<String>(); si.show(); //这里也可以定义类型为Integer,编译时系统不会报错 Studentimpl<Integer> si2=new Studentimpl<Integer>(); si2.show(); } } 运行结果: hello Hello
上面我们学习了泛型的用法,这里有一些的泛型的高级符,叫做通配符
泛型高级(通配符)
<?> :代表任意类型Object类型,或者任意的Java类
<? extends E>:向下限定,E的子类或者E这个类型
<? super E>:向上限定,E及其他的父类
例如:
package com.TextDome; import java.util.ArrayList; import java.util.Collection; class Animal{ } class Dog extends Animal{ } class Cat extends Animal{ } public class TextDome2 { public static void main(String[] args) { //创建集合对象,运用泛型时前后类型必须一致 Collection<Object> c=new ArrayList<Object>(); //当类型不一致时,系统就会报错 //Collection<Object> c1=new ArrayList<Animal>(); //<?>代表任意的Object类型或者任意的自定义java类 Collection<?>c2=new ArrayList<Animal>(); Collection<?>c3=new ArrayList<Dog>(); Collection<?>c4=new ArrayList<Cat>(); //<? extends E>代表的是向下限定,可以是E的子类或者E类本身 Collection<? extends Animal> c5=new ArrayList<Dog>(); Collection<? extends Animal> c6=new ArrayList<Animal>(); //当取到比E还高的类时,比如他的父类,就会报错 //Collection<? extends Animal> c7=new ArrayList<Object>(); //<? super E>代表的是向上限定,可以是E本身或者它的父类 Collection<? super Animal> c7=new ArrayList<Object>(); Collection<? super Animal> c8=new ArrayList<Animal>(); //当取到E类的子类时就会报错 //Collection<? super Animal> c9=new ArrayList<Dog>(); } }