泛型[1]定义&传递

 

 

泛型类

泛型接口

泛型方法

 

放在类名后面

放在接口名后面

放在返回类型前面

 

用于 属性的类型 和 方法的参数&返回值 的类型

用于 方法的参数&返回值 的类型

用于 方法的参数&返回值的类型

 

下面在举例泛型接口时，由于使用时不能直接使用接口，故先定义了泛型接口的实现类，实现时保留泛型。（参见《继承&实现》）

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

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

             ArrayListlist =newArrayList();

             list.add("abc");

             student.setJavase(list);////声明的时候限定了ArrayList

 

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

 

             ArrayListlist =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) {

 

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

             Threadthread =new Thread();

            student.setJavase(thread);

             

             Threadjavase =student.getJavase();

      }

 

}

//也可以是有那个接口的子接口//实际上是子接口的实现类

publicclass Test2 {

 

      publicstaticvoid main(String[]args) {

            GenericClass<ChildRunnable>student2 =new GenericClass<ChildRunnable>();

             ChildRunnableImplc =new ChildRunnableImpl();//上面限定了ChildRunnable//但是实际这里传递了一个ChildRunnableImpl

             student2.setJavase(c);

 

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

 

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

             

             

             ChildRunnableImplc =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) {

 

             Threadt =new Thread();

            GenericMethod.test(t);

 

      }

 

}

 

publicclass Test2 {

 

      publicstaticvoid main(String[]args) {

             

             ChildRunnablet =new ChildRunnableImpl();

            GenericMethod.test(t);

            

      }

 

}

 

interface ChildRunnable extends Runnable {

      void abc();

}

 

 

class ChildRunnableImpl implements ChildRunnable {

 

      publicvoid run() {

 

      }

 

      publicvoid abc() {

 

      }

 

}