1:为什么要使用Java泛型
看看下面程序例子(不使用泛型):
public static void main(String[] args) {
List list = new ArrayList();
list.add("zhangsan");
list.add("lisi");
list.add(102);//没有使用泛型,代码出现黄色警告
for(int i= 0; i < list.size();i++){
//list装载默认是Object类型,由于第三项装载Integer类型,所以在取对象时强制转换报错。
String name = (String) list.get(i);
System.out.println(name);
}
}
出现如下错误:
Exception in thread "main" java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
at com.java.test.genericity.GenericityMain.main(GenericityMain.java:40)由于list没有使用泛型,代码出现黄色警告,list装载默认是Object类型,由于第三项装载Integer类型,所以在取对象时强制转换报错。
List使用泛型带有String形参:
public static void main(String[] args) {
List<String> list = new ArrayList<String>();
list.add("zhangsan");
list.add("lisi");
// list.add(102); 类型已经限定编译直接报错通不过,默认是String类型
for(int i= 0; i < list.size();i++){
String name = list.get(i);
System.out.println(name);
}
}
此时list添加第三项数据直接编译报错,类型已经限定编译直接报错通不过,默认是String类型
2:Java泛型的作用
1:通过结合代码继承封装,减少Java代码重复冗余,使得代码的结构和架构更合理。
2:消除了强制类型转换 使得代码可读性好,减少了很多出错的机会。
3:Java语言引入泛型的好处是安全简单。泛型的好处是在编译的时候检查类型安全,并且所有的强制转换都是自动和隐式的,这样编译器就可以在一个高的程度上验证这个类型。
3:泛型几种使用类型和继承关系
- 自定义泛型类
- 自定义泛型接口
- 自定义泛型方法
- 了解泛型参数继承关系
- 自定义泛型类
/*** * @ClassName Car * @Description 定义泛型类 * * ***/ public class Car<M> { private M m; public void openCar(M m){ System.out.println("开车"); }; public M endCar(){ System.out.println("关车"); return m; } }
这里的M表示泛型形参,由于接收来自外部使用时候传入的类型实参。那么对于不同传入的类型实参,生成的相应对象实例的类型是不是一样的呢?看如下例子:
Car<Person> pCar = new Car<Person>();
Car<Animal> aCar = new Car<Animal>();
System.out.println(pCar.getClass());//class com.java.test.genericity.Car
System.out.println(aCar.getClass());//class com.java.test.genericity.Car
System.out.println(aCar.getClass()== pCar.getClass());//true
看了以上例子,我们可以发现,在使用泛型类时,虽然传入了不同的泛型实参,但并没有真正意义上生成不同的类型,传入不同泛型实参的泛型类在内存上只有一个,即还是原来的最基本的类型(本实例中为Car),当然,在逻辑上我们可以理解成多个不同的泛型类型,在于Java中的泛型这一概念提出的目的,导致其只是作用于代码编译阶段,在编译过程中,对于正确检验泛型结果后,会将泛型的相关信息擦出,也就是说,成功编译过后的class文件中是不包含任何泛型信息的。泛型信息不会进入到运行时阶段。
2:泛型接口,泛型接口和泛型类的使用差不多,其中T表示泛型参数:
public interface Map<T> {
public void load(T t);
}
实现泛型接口类的写法,传参形式如下:(在实现类实现泛型接口时,如已将泛型类型传入实参类型,则所有使用泛型的地方都要替换成传入的实参类型)
public class BaiduMap implements Map<String>{
@Override
public void load(String t) {
// TODO Auto-generated method stub
}
}
实现泛型接口类,不传形参写法如下:(不传形参,与泛型类的定义相同,在声明类的同时,需要将泛型的形参也一起加进去)
public class BaiduMap<T> implements Map<T>{
@Override
public void load(T t) {
// TODO Auto-generated method stub
}
}
3:泛型方法使用:(如果当前方法所在的Java类中没有定义T泛型参数,则在方法的前面声明泛型形参<T>)
public class BaiduMap implements Map<String>{
@Override
public void load(String t) {
}
//如果当前方法所在的Java类中没有定义T泛型参数,则在方法的前面声明泛型形参<T>
public <T> T getMethod(Class<T> czz) throws InstantiationException, IllegalAccessException{
T t = czz.newInstance();
return t;
}
}
区别泛型方法和泛型类方法:
//我们在当前类中已经定义了T类型,下面load含有泛型参数,所以泛型T不是泛型方法
@Override
public void load(T t) {
}
//我们在当前方法中getMethod已经定义了M类型,下面getMethod含有泛型参数,所有getMethod是泛型方法
public <M> M getMethod(Class<M> czz) throws InstantiationException, IllegalAccessException{
M m = czz.newInstance();
return m;
}
4:了解泛型的继承关系以及泛型参数的上下行边界:
//当前定义了一个类Car 约定了M形参继承Person类。
public class Car<M extends Person> {
private M m;
public void openCar(M m){
System.out.println("开车");
};
public M endCar(){
System.out.println("关车");
return m;
}
}
public class Person {
private String name;
private String age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getAge() {
return age;
}
public void setAge(String age) {
this.age = age;
}
}
public class Man extends Person{
}
public class Sedan extends Car<Man>{
@Override
public void openCar(Man m) {
// TODO Auto-generated method stub
super.openCar(m);
}
@Override
public Man endCar() {
// TODO Auto-generated method stub
return super.endCar();
}
}
我定义了一个Car类,约束当前的形参M继承Person,此时我定义一个Man的类作为形参,继承了Person,Sedan类继承Car在Sedan类中我传递形参Man,正因为形参Man,重写方法openCar,endCar的参数才会显示Man参数,这样就约定了泛型的边界,使得子类传递的参数必须是泛型约定的参数。