欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

泛型的理解

程序员文章站 2024-03-22 10:33:04
...

泛型

泛型在前面的练习中我已经运用上了,接下来让我们看看泛型的作用

例如:

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:类转换异常因为在我们的集合中分别有StringInteger两种类型的元素,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>();

}
}