一.下面我们首先写出一个泛型类

package genericity;


public class Order<T> {

    String ordername;
    int orderID;

    //类内部就可以直接使用类的泛型
    T orderT;

    public Order(){

    }
    public Order(String ordername,int orderID,T orderT){

        this.orderID=orderID;
        this.ordername=ordername;
        this.orderT=orderT;
    }


}

• 这里我们声明了一个T类型的orderT,以后我们使用的时候就可以定义为想要的类型

二.接下来我们进行自定义泛型类的实例化

package genericity;
​
public class OrderTest {
​
    public static void main(String[] args) {
​
        Order order = new Order();
​
        Order<String> order1 = new Order<>("AA",100,"BB");
             order1.setOrderT("String");
    }
}

• 如果我们定义了泛型类,在实例化的时候未指明类的泛型,则默认为Object类型,但我们并不建议这样做,因为这样做就失去了使用泛型的意义.因此在进行自定义泛型类的实例化时必须要指明泛型类的类型

• 在上面的代码中我们指明了自定义的类型为String型,所以以后我们使用时都为String型的

三.自定义泛型类的继承

• 当子类继承父类时未指明泛型类型,则子类不是泛型类

  public class Son extends Father<Integer>{
       //此时Son不是泛型类
  }

• 当子类继承父类时指明了泛型类型,则子类也为泛型类,且实例化子类对象时,不需再指明

  public class Son<T> extends Father<Integer>{
       //此时Son是泛型类
  }

四. 使用自定义泛型类时的注意点

1.当子类继承父类时指明了泛型类,则实例化子类对象时,不需再次声明

2.泛型类可能有多个参数,此时应该将它们放在一起

• 如: <E1,E2,E3>

3.泛型类的构造参数无<>

正确示例:
 public Textclass(){
 
 } 
错误示例:
 public Textclass<E>(){
 
 }

4.实例化以后,操作原来泛型位置的结构必须与指定的泛型类型一致

5.泛型不同的引用不能互相赋值

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

• 经验:

     要使用泛型就一直使用,要不适用就一直不要使用

7.如果泛型类是一个接口或者一个抽象类,则不可创建泛型类的对象

8.泛型的指定中不能使用基本数据类型,如果需要使用,则使用基本数据类型的包装类替代

9.在类/接口上声明的泛型,在本类或者本接口中即代表某种类型,可以作为非静态属性的类型,非静态方法的参数类型,非静态方法的返回值类型.但在静态方法中不能使用类的泛型

10.异常类不能是泛型的

11.父类有泛型,子类可以选择保留泛型也可以选择自己指定泛型的类型

百度一下啥也没有，先看看这个吧 

java 根据泛型创建对象，实例化泛型对象_Sirius的博客-CSDN博客_泛型创建对象实例化泛型对象在你发布的代码中，不可能创建一个泛型T，因为你不知道它是什么类型：public class Abc<T>{ public T getInstanceOfT() { // There is no way to create an instance of T here // since we don...https://blog.csdn.net/qq_21460229/article/details/104351684

老实说我没看懂

换个思路，传入demo,或者class

    public static <T> void toIPageVo(IPage foIPage, IPageVo<T> iPageVo,T voDemo) throws InvocationTargetException, IllegalAccessException {
        List foList = foIPage.getRecords();
        List toList = new ArrayList<T>();
        for (Object foRecord : foList) {
            T vo=null;
            try {
               vo  = (T) voDemo.getClass().newInstance();
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
            BeanUtilImpl.copyToVo(vo,foRecord);
            toList.add(vo);
        }

        iPageVo.setRecords(toList);
        iPageVo.setCurrent(foIPage.getCurrent());
        iPageVo.setSize(foIPage.getSize());
        iPageVo.setTotal(foIPage.getTotal());
        iPageVo.setPages(foIPage.getPages());
    }

    public static <T> void toIPageVo(IPage foIPage, IPageVo<T> iPageVo,Class clazz) throws InvocationTargetException, IllegalAccessException {
        List foList = foIPage.getRecords();
        List toList = new ArrayList<T>();
        for (Object foRecord : foList) {
            T vo=null;
            try {
                vo  = (T) clazz.newInstance();
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
            BeanUtilImpl.copyToVo(vo,foRecord);
            toList.add(vo);
        }

        iPageVo.setRecords(toList);
        iPageVo.setCurrent(foIPage.getCurrent());
        iPageVo.setSize(foIPage.getSize());
        iPageVo.setTotal(foIPage.getTotal());
        iPageVo.setPages(foIPage.getPages());
    }

一、创建泛型类

/**
 * 测试类
 * @author LD
 *
 * @param <T>
 */
public class Student<T> {

	private T name;
	private T age;
	
	public Student(T name, T age){
		this.name = name;
		this.age = age;
	}
	
	public T getName() {
		return name;
	}

	public T getAge() {
		return age;
	}

	/**
	 * 根据性别返回不同的值
	 * @param sex
	 * @return
	 */
	public T getUserInfo(int sex){
		if(sex == 1){
			return name;
		}else{
			return age;
		}
	}
	
	public static void main(String[] args) {
		Student<String> student = new Student<>("peter", "18");
		
		System.out.println(student.getName()); //peter
		System.out.println(student.getAge());  //18
		
		System.out.println(student.getUserInfo(1)); //peter
		System.out.println(student.getUserInfo(2)); //18
	}
	
}

二、创建泛型方法

public class TestClass {

	public static void main(String[] args) {
		/** 不指定泛型的时候 */
		int i = TestClass.add(1, 2); // 这两个参数都是Integer，所以T替换为Integer类型
		Number f = TestClass.add(1, 1.2);// 这两个参数一个是Integer，另一个是Float，所以取同一父类的最小级，为Number
		Object o = TestClass.add(1, "asd");// 这两个参数一个是Integer，另一个是String，所以取同一父类的最小级，为Object

		/** 指定泛型的时候 */
		int a = TestClass.<Integer>add(1, 2);// 指定了Integer，所以只能为Integer类型或者其子类
		int b = TestClass.<Integer>add(1, 2.2);// 编译错误，指定了Integer，不能为Float
		Number c = TestClass.<Number>add(1, 2.2); // 指定为Number，所以可以为Integer和Float
	}

	// 这是一个简单的泛型方法
	public static <T> T add(T x, T y) {
		return y;
	}
}