Java 自定义泛型结构（泛型类、泛型接口和泛型方法）说明和使用举例

自定义泛型结构

package www.bh.c.genetest;
//自定义泛型类
public class Test2<E> {  
        String testName;
        int testAge;
    //类的内部结构就可以使用类的泛型
        E testT;
    public Test2() {
    }

    public Test2(String testName, int testAge, E testT) {
        this.testName = testName;
        this.testAge = testAge;
        this.testT = testT;
    }

    public E getTestT() {
        return testT;
    }

    public void setTestT(E testT) {
        this.testT = testT;
    }

    @Override
    public String toString() {
        return "Test2{" +
                "testName='" + testName + '\'' +
                ", testAge=" + testAge +
                ", testT=" + testT +
                '}';
    }
}

package www.bh.c.genetest;

public class Test3 {
    public static void main(String[] args) {
        //定义了泛型类，实例化没有指明类的类型，则默认此泛型类型为Object类型
        Test2 test = new Test2();
        test.setTestT(123);
        test.setTestT("测试");
        //建议：如果定义了类是带泛型的，建议在实例化时指明类的泛型
        Test2<String> test2 = new Test2<>("测试",1,"指明类的泛型类型");
        test2.setTestT("指明类的泛型");
        System.out.println(test2);
    }
}

• 总结：

• 泛型类可能有多个参数，此时应将多个参数一起放在尖括号中，如：<E1,E2,E3>

• 泛型类的构造器如下：

public GenericClass(){}

​ 而非：

public GenericClass<E>(){}

• 实例化后，操作原来泛型位置的结构必须与指定泛型类型一致

• 泛型的不同引用不能赋值

• 泛型如果不指定，将被擦除，泛型对应的类型均按Object处理，但不等价于Object

  • 如果泛型结构是一个接口或抽象类，则不可创建泛型类的对象

  • 泛型的指定中不能使用基本数据类型，可以使用包装类替换

  • 在静态方法中不能使用类的泛型

  • 不能使用new E[]。可以：E[] elements = (E[]) new Objent[capacity]

   T[] arr =new T[10];//编译不通过
   T[] arr1 =(T[]) new Object[10];//编译通过
  

  • 父类有泛型，子类可以选择保留泛型也可以选择指定泛型类型

  class Father<T1,T2>{}
  

  //子类不保留父类的泛型
  //1.没有类型  擦除
  class Son1 extends Father{}//等价于class Son extends Father<Object,Object>{}
  class Son2<A,B> extends Father{}//等价于class Son2<A,B> extends Father<Object,Object>{}
  
  //2.具体类型
  class Son3 extends Father<String,Integer>{}
  class Son4<A,B> extends Father<String,Integer>{}
  

  //子类保留父类的泛型
  //1.全部保留
  class Son5<T1,T2> extends Father<T1,T2>{}
  class Son6<T1,T2,A,B> extends Father<T1,T2>{}
  //2.部分保留
  class Son7<T2> extends Father<String,T2>{}
  class Son8<T2,A,B> extends Father<String,T2>{}
  

• 泛型方法：在方法中出现了泛型的结构，泛型参数与类的泛型参数没有任何关系

package www.bh.c.genetest;
import java.util.ArrayList;
import java.util.List;

public class Test4<T> {
    //泛型方法所属的类是不是泛型类都没有关系
   // public <E> List<E> listTest(E[] arr){}
  //泛型方法，可以声明为静态的，因为泛型参数是在调用方法时确定的，并非在实例化类时确定
   public static <E> List<E> listTest(E[] arr){ 
       ArrayList<E> list = new ArrayList<>();
       for (E e:arr){
           list.add(e);
       }
       return list;
   }
}

package www.bh.c.genetest;
import java.util.List;

public class Test5 {
    public static void main(String[] args) {
        Test4<String> test = new Test4<>();
        Integer[] arr=new Integer[]{1,2,3,4,5};
        //泛型方法在调用时，指明泛型参数的类型
        List<Integer> list = test.listTest(arr);
        System.out.println(list);
    }
}

• 泛型类和泛型方法的使用情景

package www.bh.c.genetest;
import java.util.List;

//DAO:date(base) access object
//声明一个操作全部数据的类，并增加增删改查的方法
public class DAO<T> {//可以操作全部表的DAO
    //增加一条记录
    public void add(T t){

    }
    //删除一条记录
    public boolean delete(T t){
        return false;
    }
    //修改一条记录
    public void update(int index,T t){

    }
    //查询一条记录
    public T getIndex(int index){
        return null;
    }
    //查询多条记录
    public List<T> getList(int index){
        return null;
    }
}

package www.bh.c.genetest;
//声明一个类学生类
public class Student {
}

package www.bh.c.genetest;

public class StudentDAO extends DAO<Student>{//只能操作一个表的DAO

}

package www.bh.c.genetest;
import java.util.List;
//测试
public class DAOTest {
    public static void main(String[] args) {
        StudentDAO stu= new StudentDAO();
        stu.add(new Student());
         Student index = stu.getIndex(2);
        List<Student> list = stu.getList(5);
    }
}