1、Java中，子类可以继承父类的泛型和泛型接口，语法：

class FatherClss<T>{}
class ChildClass<T> extends FatherClass<T>{}
interface TestInterface<E>{}
class ChildClass<E> implements TestInterface<E>{}

简单的实现：

class Father<T>{
	T t;
	public Father(T t){
		this.t = t;
	}
	interface TestInterface<T>{

	}
	class Child<T1,T2> extends Father<T1> implements TestInterface<T2>{
		public Child(T1 t){
			super(t);
		}
	}
}

2、泛型被继承的四种情况：

父类：abstract class Father<T1,T2>{}

1）全部继承：class Child<T1,T2,T3> extends Father<T1,T2>{}

子类继承父类时，父类将两个泛型都写出来，子类定义了同样的泛型，而且子类泛型的数量可以比父类多，上面代码中的T1和T2就是从父类继承过来的。

public class Demo {
	public static void main(String[] args) {
		Father<Integer,String> f = new Child<>(1,"2");
		Child<Integer,String,Boolean> c = new Child<>(1,"2"); 
	}
}
class Father<T1,T2>{
	T1 t1;
	T2 t2;
	public Father(T1 t1, T2 t2) {
		this.t1 = t1;
		this.t2 = t2;
		System.out.println("t1的类型："+this.t1.getClass());
		System.out.println("t2的类型："+this.t2.getClass());
	}
}
class Child<T1,T2,T3> extends Father<T1,T2>{
	public Child(T1 t1, T2 t2) {
		super(t1, t2);
	}
}

输出结果：

t1的类型：class java.lang.Integer
t2的类型：class java.lang.String
t1的类型：class java.lang.Integer
t2的类型：class java.lang.String

其中在子类中继承父类时，extends Father<T1,T3>该泛型是可以修改的，不需要和其Father<T1,T2>原有的泛型名称相同，只要保证其子类Child<T1,T2,T3>的泛型性相同即可，看下面修改后的代码：

public class Demo {
	public static void main(String[] args) {
		Father<Integer,String> f = new Child<>(1,"2");
		Child<Integer,String,Boolean> c = new Child<>(1,false); 
	}
}
class Father<T1,T2>{
	T1 t1;
	T2 t2;
	public Father(T1 t1, T2 t2) {
		this.t1 = t1;
		this.t2 = t2;
		System.out.println("t1的类型："+this.t1.getClass());
		System.out.println("t2的类型："+this.t2.getClass());
	}
}
class Child<T1,T2,T3> extends Father<T1,T3>{
	public Child(T1 t1, T3 t3) {
		super(t1, t3);
	}
}

输出结果：我们上面子类中的继承Father的泛型和Father类本身的泛型名称不同，实际上是不影响的，只需要和实例化时的泛型相同即可，当我们创建子类对象时，虽然Father类的第二个是T3，我们创建Child类时其泛型是String，第三个是Boolean，可以看出当我们创建向上造型创建Child类时，其泛型看名称是否相同，并不是看位置。

t1的类型：class java.lang.Integer
t2的类型：class java.lang.String
t1的类型：class java.lang.Integer
t2的类型：class java.lang.Boolean

2）部分继承：class Child<T1,A,B> extends Father<T1,String>{}

子类继承父类的时候，子类给父类实现了一个泛型，然后子类只实现了一个泛型。

public class Demo {
	public static void main(String[] args) {
		Child<Integer,String,Boolean> c = new Child<>(1,"1"); 
	}
}
class Father<T1,T2>{
	T1 t1;
	T2 t2;
	public Father(T1 t1, T2 t2) {
		this.t1 = t1;
		this.t2 = t2;
		System.out.println("t1的类型："+this.t1.getClass());
		System.out.println("t2的类型："+this.t2.getClass());
	}
}
class Child<T1,T2,T3> extends Father<T1,String>{
	public Child(T1 t1,String t2) {
		super(t1, t2);
	}
}

上面代码中我们继承Father类时，我们为Father类实现了一个泛型String，当我们创建Child实例的时候，我们第二个参数必须是String类型，只需要实现第一个泛型即可。

t1的类型：class java.lang.Integer
t2的类型：class java.lang.String

3）实现父类泛型：class Child<A,B> extends Father<Integer,String>{}

子类在继承父类时，将父类所有的泛型都实现，这样的话，子类就不会继承父类的任何泛型，即使创建泛型那也是子类独有的。

public class Demo {
	public static void main(String[] args) {
		Child<Integer,String,Boolean> c = new Child<>(1,"1"); 	
	}
}
class Father<T1,T2>{
	T1 t1;
	T2 t2;
	public Father(T1 t1, T2 t2) {
		this.t1 = t1;
		this.t2 = t2;
		System.out.println("t1的类型："+this.t1.getClass());
		System.out.println("t2的类型："+this.t2.getClass());
	}
}
class Child<T1,T2,T3> extends Father<Integer,String>{
	public Child(Integer t1,String t2) {
		super(t1, t2);
	}
}
t1的类型：class java.lang.Integer
t2的类型：class java.lang.String

4）不实现父类泛型：class Child extends Father{}

我们把父类的泛型忽略掉，既不实现也不继承，这样不会报错，但是这样的话父类所有的泛型都是Object泛型。

public class Demo {
	public static void main(String[] args) {
		Child<Integer,String,Boolean> c = new Child<>("1","1"); 	
	}
}
class Father<T1,T2>{
	T1 t1;
	T2 t2;
	public Father(T1 t1, T2 t2) {
		this.t1 = t1;
		this.t2 = t2;
		System.out.println("t1的类型："+this.t1.getClass());
		System.out.println("t2的类型："+this.t2.getClass());
	}
}
class Child<T1,T2,T3> extends Father{
	public Child(Object t1, Object t2) {
		super(t1, t2);
	}
}

当我们不实现父类的泛型时，默认是Object类型，那么我们可以在实例化子类的时候，定义任何类型。

t1的类型：class java.lang.String
t2的类型：class java.lang.String