泛型的理解

泛型

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

例如：

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>();

}
}