| 泛型类 | 泛型接口 | 泛型方法 |
| 放在类名后面 | 放在接口名后面 | 放在返回类型前面 |
| 用于 属性的类型 和 方法的参数&返回值 的类型 | 用于 方法的参数&返回值 的类型 | 用于 方法的参数&返回值的类型 |
下面在举例泛型接口时,由于使用时不能直接使用接口,故先定义了泛型接口的实现类,实现时保留泛型。(参见《继承&实现》)
basic
| 泛型类 | 泛型接口 | 泛型方法 |
定义 | publicclass GenericClass<T> {
private Tjavase;
public GenericClass() { }
public GenericClass(Tjavase) { this.javase = javase; }
publicvoid setJavase(Tjavase) { this.javase = javase; }
public T getJavase() { returnthis.javase; } } | public interface GenericInterface<T>{
publicvoid compare(Tt); }
| publicclass GenericMethod<T> {
publicstatic <TT>void test(TTt) {
} }
|
传递 | publicclass Test {
publicstaticvoid main(String[]args) { GenericClass<String> student =new GenericClass<String>(); student.setJavase("abc");//声明的时候限定了String String javase =student.getJavase();//获取出来直接是String类型
}
}
|
publicclass Test {
publicstaticvoid main(String[]args) {
GenericInterfaceImpl<String, Integer> test=new GenericInterfaceImpl<String, Integer>(); test.compare("abc");//声明的时候限定了String
}
}
//实现了泛型接口的实现类//保留泛型 class GenericInterfaceImpl<T, A> implements GenericInterface<T> {
publicvoid compare(Tt) { }
} | publicclass Test {
publicstaticvoid main(String[]args) {
GenericMethod.test("123");
}
}
|
extends
还可以给<>中的T增加限制
注意哈,在定义泛型类型的时候,只能使用extends,不能使用super,这里跟“声明类型时使用泛型通配符”中不一样。
class
使用时传递子类(以继承List为例,传递ArrayList)
| 泛型类 | 泛型接口 | 泛型方法 |
定义 | import java.util.List;
/** * extend类 //以extend List为例 */ publicclass GenericClass<TextendsList> {
private Tjavase;
public GenericClass(){ }
publicvoid setJavase(Tjavase){ this.javase=javase; System.out.println(javase.size());//这里可以直接调用List的方法 }
public T getJavase(){ returnthis.javase; } }
| import java.util.List;
/** * extend类 //以extend List为例 */ publicinterface GenericInterface<TextendsList> {
publicvoid compare(Tt); }
| import java.util.List;
/** * extend类 //以extend List为例 */ publicclass GenericMethod<T> {
publicstatic <TTextendsList>void test(TTt) {
} }
|
传递 | import java.util.ArrayList;
publicclass Test {
publicstaticvoid main(String[]args) { GenericClass<ArrayList> student =new GenericClass<ArrayList>(); ArrayList list =newArrayList(); list.add("abc"); student.setJavase(list);声明的时候限定了ArrayList
ArrayList javase =student.getJavase();//获取出来直接是ArrayList类型
} }
| import java.util.ArrayList; import java.util.List;
publicclass Test { publicstaticvoid main(String[]args) {
GenericInterfaceImpl<ArrayList, Integer>test =new GenericInterfaceImpl<ArrayList, Integer>();
ArrayList list =newArrayList(); list.add("abc");
test.compare(list);//声明的时候限定了ArrayList//这里直接传递ArrayList
} }
//保留泛型 class GenericInterfaceImpl<T extendsList, A> implements GenericInterface<T>{//这里要这样写,不能写成implementsComparat<T extends List>
publicvoid compare(Tt) {
}
}
| import java.util.ArrayList;
publicclass Test {
publicstaticvoid main(String[]args) {
ArrayList list =newArrayList();// list.add("123");
GenericMethod.test(list);
}
}
|
interface
当T继承的是接口时(以Runnable为例),使用时既可以传递接口实现类(传递Thread),也可以传递子接口(传递ChildRunnable).
| 泛型类 | 泛型接口 | 泛型方法 | |||
定义 | /** * extend接口//以Runnable为例 */ publicclass GenericClass<Textends Runnable> {
private Tjavase;
public GenericClass() { }
publicvoid setJavase(Tjavase) { this.javase = javase; // javase.run();//这里可以直接调用接口的方法 }
public T getJavase() { returnthis.javase; } } | /** * extend接口//以Runnable为例 */ publicinterface GenericInterface<Textends Runnable> {
publicvoid compare(Tt); }
| /** * extend接口//以Runnable为例 */ publicclass GenericMethod<T> {
publicstatic <TTextends Runnable>void test(TTt){
} }
| |||
传递 | //可以使用接口的实现类 publicclass Test1 {
publicstaticvoid main(String[]args) { // GenericClass<Thread>student =new GenericClass<Thread>(); Thread thread =new Thread(); student.setJavase(thread);
Thread javase =student.getJavase(); }
} | //也可以是有那个接口的子接口//实际上是子接口的实现类 publicclass Test2 {
publicstaticvoid main(String[]args) { GenericClass<ChildRunnable>student2 =new GenericClass<ChildRunnable>(); ChildRunnableImpl c =new ChildRunnableImpl();//上面限定了ChildRunnable//但是实际这里传递了一个ChildRunnableImpl student2.setJavase(c);
ChildRunnable javase =student2.getJavase();//获取到接口ChildRunnable,但是实际上指向了对象ChildRunnableImpl javase.abc();//实际调用到ChildRunnableImpl的abc方法
}
}
interface ChildRunnable extends Runnable { void abc(); }
class ChildRunnableImpl implements ChildRunnable {
publicvoid run() {
}
publicvoid abc() {
}
} | //传递接口的实现类 publicclass Test1 {
publicstaticvoid main(String[]args) {
GenericInterfaceImpl<Thread, Integer>test =new GenericInterfaceImpl<Thread, Integer>();
Thread t =new Thread();
test.compare(t);
} }
//测试用保留泛型 class GenericInterfaceImpl<T extends Runnable, A> implements GenericInterface<T>{//不能这样写implementsComparat<T extends List>
publicvoid compare(Tt) {
}
} | publicclass Test2 {
publicstaticvoid main(String[]args) {
GenericInterfaceImpl<ChildRunnable, Integer>test=new GenericInterfaceImpl<ChildRunnable, Integer>();
ChildRunnableImpl c =new ChildRunnableImpl();//上面限定了ChildRunnable//但是实际这里传递了一个ChildRunnableImpl
test.compare(c);
} }
interface ChildRunnable extends Runnable { void abc(); }
class ChildRunnableImpl implements ChildRunnable {
publicvoid run() {
}
publicvoid abc() {
}
}
| publicclass Test1 {
publicstaticvoid main(String[]args) {
Thread t =new Thread(); GenericMethod.test(t);
}
}
| publicclass Test2 {
publicstaticvoid main(String[]args) {
ChildRunnable t =new ChildRunnableImpl(); GenericMethod.test(t);
}
}
interface ChildRunnable extends Runnable { void abc(); }
class ChildRunnableImpl implements ChildRunnable {
publicvoid run() {
}
publicvoid abc() {
}
}
|