泛型类:
public class GenericDemo4 {
public static void main(String[] args) {
// Tool tool = new Tool();
// tool.setObj(new Work("张三",24));
// Student stu = (Student)tool.getObj();
// System.out.println(stu);
Util<Student> util = new Util<Student>();
util.setObj(new Student());//如果类型不匹配,直接报错
Student stu = util.getObj();//避免了向下转型。
System.out.println(stu);
}
}
/*
* 创建一个用于操作Student对象的工具类,对对象进行设置和获取。
* 太有局限性了,可不可以定义一个可以操作所有对象的工具呢?
* 类型向上抽取,当要操作的对象的类型不确定的时候,为了扩展。
* 可以使用Object类型来完成。
*
* 但是这种方式有一些小弊端,会出现转型,向下转型容易在运行时期发生ClassCastException
*
* Jdk1.5以后,新的解决方案。
* 类型不确定时,可以对外提供参数,有使用者通过参数的形式完成类型的确定。
*/
//在类定义时就明确参数,由使用该类的调用者,来传递具体的类型。
class Util<W>{//泛型类
private W obj;
public W getObj() {
return obj;
}
public void setObj(W obj) {
this.obj = obj;
}
}
/*Jdk1.4版本
class Tool{
private Object obj;
public Object getObj() {
return obj;
}
public void setObj(Object obj) {
this.obj = obj;
}
@Override
public String toString() {
return "Tool [obj=" + obj + "]";
}
}*/
泛型方法:
public class GenericDemo5 {
public static void main(String[] args) {
Demo<String> d = new Demo<String>();
d.show("lala");
// d.myPrint(6); 编译报错
Demo<Integer> d1 = new Demo<Integer>();
d1.myPrint(6);
// d1.show("df"); 编译报错
Demo<String> d2 = new Demo<String>();
d2.show("halou!!");
// d.myPrint(4); 编译报错
}
}
class Demo<W>{
public void show(W w){
System.out.println("show:->"+w);
}
//如果静态方法上想要定义泛型,泛型只能定义在方法上。
//静态方法无法访问类上定义的泛型
public static <M> void staticShow(M m){};
public void myPrint(W w){
System.out.println("print:->"+w);
}
}
泛型接口:
public class GenericDemo6 {
public static void main(String[] args) {
SubDemo sd = new SubDemo();
sd.show("sdfsfs");
}
}
interface Inter<T>{//泛型接口
public void show(T t);
}
class InterImple<W> implements Inter<W>{
@Override
public void show(W t) {
System.out.println("show:"+t);
}
}
class SubDemo extends InterImple<String>{
}
/*class InterImpl implements Inter<String>{
@Override
public void show(String t) {
}
}*/
关注我的微信公众号(曲健磊的个人随笔),观看更多精彩内容: