1泛型应用
早期的时候，我们使用Object来代表任意的类型。
向上转型是没有任何问题的，但是在向下转型的时候其实隐含了类型转换的问题。
也就是说这样的程序其实并不是安全的。所以Java在JDK5后引入了泛型，提高程序的安全性。
package cn.itcast_03;
public class ObjectTool {
private Object obj;
public Object getObj() {
return obj;
}
public void setObj(Object obj) { // Object obj = new Integer(30);
this.obj = obj;
}
}
package cn.itcast_03;
public class ObjectToolDemo {
public static void main(String[] args) {
ObjectTool ot = new ObjectTool();
// 正常使用
ot.setObj(new Integer(27));
Integer i = (Integer) ot.getObj();
System.out.println("年龄是：" + i);
ot.setObj(new String("林青霞"));
String s = (String) ot.getObj();
System.out.println("姓名是：" + s);
System.out.println("---------");
ot.setObj(new Integer(30));
// ClassCastException
String ss = (String) ot.getObj();
System.out.println("姓名是：" + ss);
}
}
1.泛型类
泛型类：把泛型定义在类上
类名后面加泛型<T>
创建对象的时候确定类型
定义一个泛型类：
package cn.itcast_04;
public class ObjectTool<T> { //<T>可以放任意的字母，其实就相当于是个参数，需要什么放什么
private T obj; //其实就是一个可以应用的时候自己去定义的可变类型，在定义类的时候先在类名后面加一个<T>符号，然后这个类里面就可以不去给变量、返回值、参数等去定义类型了，如果哪些变量、返回值、参数等是统一的类型就可以都定义成<T>符号
public T getObj() {
return obj;
}
public void setObj(T obj) {
this.obj = obj;
}
}
泛型类的测试
package cn.itcast_04;
public class ObjectToolDemo {
public static void main(String[] args) {
// ObjectTool ot = new ObjectTool();
// ot.setObj(new String("林青霞")); //如果不定义泛型，需要的是一个Object类的对象我可以传一个子类String类型的对象
// // ClassCastException
// Integer ii = (Integer) ot.getObj(); //但是接收的时候如果不小心用别的类型去接 收了，但是它在编译的时候并不会报错，因为这个对象实际是String类的对象但是表现得是Object类型的， 那么将Object类型强转为别的其他非String类型的类型也是符合语法判断的，所以编译不报错，那么等到执行报错就比较麻烦了，所以引进了泛型。
// System.out.println("姓名是：" + ii);
System.out.println("-------------");
ObjectTool<String> ot = new ObjectTool<String>();
// ot.setObj(new Integer(27)); //这个时候编译期间就过不去
ot.setObj(new String("林青霞"));
String s = ot.getObj();
System.out.println("姓名是：" + s);
ObjectTool<Integer> ot2 = new ObjectTool<Integer>();
// ot2.setObj(new String("风清扬"));//这个时候编译期间就过不去
ot2.setObj(new Integer(27));
Integer i = ot2.getObj();
System.out.println("年龄是：" + i);
}
}
2.泛型方法
泛型方法：把泛型定义在方法上
调用方法的时候确定类型
在返回值前加泛型<T>
定义一个泛型方法：
public class ObjectTool {
public <T> void show(T t) {
System.out.println(t);
}
}
泛型方法的测试：
package cn.itcast_05;
public class ObjectToolDemo {
public static void main(String[] args) {
// 定义泛型方法后
ObjectTool ot = new ObjectTool();
ot.show("hello");
ot.show(100);
ot.show(true);
}
}
3.泛型接口
泛型接口：把泛型定义在接口上（其实又回到了泛型类）
在接口名后面加泛型<T>
定义一个泛型类：
package cn.itcast_06;
public interface Inter<T> {
public abstract void show(T t);
}
//实现类（即接口的子类）在实现接口：
//第一种情况：已经知道该是什么类型的了
//public class InterImpl implements Inter<String> {
// @Override
// public void show(String t) {
// System.out.println(t);
// }
// }
//第二种情况：还不知道是什么类型的
public class InterImpl<T> implements Inter<T> {
@Override
public void show(T t) {
System.out.println(t);
}
}
泛型接口测试：
package cn.itcast_06;
public class InterDemo {
public static void main(String[] args) {
// 第一种情况的测试
// Inter<String> i = new InterImpl();
// i.show("hello");
// // 第二种情况的测试
Inter<String> i = new InterImpl<String>();
i.show("hello");
Inter<Integer> ii = new InterImpl<Integer>();
ii.show(100);
}
}
2.泛型高级(通配符)
泛型如果明确的写的时候，前后必须一致
泛型高级(通配符)
?:任意类型，如果没有明确，那么就是Object以及任意的Java类了
? extends E:向下限定，E及其子类
? super E:向上限定，E极其父类
package cn.itcast_07;
import java.util.ArrayList;
import java.util.Collection;
public class GenericDemo {
public static void main(String[] args) {
// 泛型如果明确的写的时候，前后必须一致
Collection<Object> c1 = new ArrayList<Object>();
// Collection<Object> c2 = new ArrayList<Animal>();
// Collection<Object> c3 = new ArrayList<Dog>();
// Collection<Object> c4 = new ArrayList<Cat>();
// ?表示任意的类型都是可以的
Collection<?> c5 = new ArrayList<Object>();
Collection<?> c6 = new ArrayList<Animal>();
Collection<?> c7 = new ArrayList<Dog>();
Collection<?> c8 = new ArrayList<Cat>();
// ? extends E:向下限定，E及其子类
// Collection<? extends Animal> c9 = new ArrayList<Object>(); //报错
Collection<? extends Animal> c10 = new ArrayList<Animal>();
Collection<? extends Animal> c11 = new ArrayList<Dog>();
Collection<? extends Animal> c12 = new ArrayList<Cat>();
// ? super E:向上限定，E极其父类
Collection<? super Animal> c13 = new ArrayList<Object>();
Collection<? super Animal> c14 = new ArrayList<Animal>();
// Collection<? super Animal> c15 = new ArrayList<Dog>(); //报错
// Collection<? super Animal> c16 = new ArrayList<Cat>(); //报错
}
}
class Animal {
}
class Dog extends Animal {
}
class Cat extends Animal {
} |
|
收藏
淘帖
踩
