泛型实现类:
package generic;
/**
* 泛型父类:子类为“富二代”:子类的泛型要比父类多
* 1,保留父类的泛型-->子类为泛型类
* 2,不保留父类泛型-->子类按需实现
*
*
* 子类【重写方法】的参数类型 -->随父类而定
* 子类新增的方法,参数类型随子类而定
* 子类中使用父类的【属性】 -->随父类而定
* 子类使用自己的属性-->随子类而定
* @author Administrator
*
*/
public abstract class Father<T1,T2> {
T1 age ;
public abstract void test(T2 name);
}
//当继承Father类时,T1、T2的处理方式:
//保留 -->父类保留,子类必须保留,所以子类是泛型子类
//1) 全部保留
class C1<T2,T1,A> extends Father<T1,T2>{
@Override
public void test(T2 name) {//子类重写方法的参数类型 -->随父类而定:T2
System.out.println("name : "+name);
}
//子类自定义属性,类型随子类
A a ;
String str ;
/**
* 子类新增的方法,参数类型随子类而定
* @param a
*/
public void test2(A a){
System.out.println(a);
// this.a --> A类型,随子类
}
}
//2) 部分保留
class C2<T2> extends Father<Integer,T2>{
@Override
public void test(T2 name) {//子类重写方法的参数类型 -->随父类而定:T2
this.age = 23; //Integer类型,子类使用父类的【属性】,类型随父类而定
}
}
//不保留,把T1、T2替换成具体的类型
//---》按需实现:子类 可以扩展泛型
//1) 具体类型
class C3<A,B> extends Father<String,Integer>{
@Override
public void test(Integer name) {//子类重写方法的参数类型 -->随父类而定:Integer
this.age = "24";//String 类型,子类使用父类的【属性】,类型随父类而定
}
}
//2) 没有类型 擦除 --》Object
class C4<A,B> extends Father{
@Override
public void test(Object name) {//子类重写方法的参数类型 -->随父类而定:Object
this.age = new Object();//Object 类型,子类使用父类的【属性】,类型随父类而定
}
}
泛型接口:
package generic;
/**
* 泛型接口:与泛型类 同理
* @author Administrator
*
* @param <T>
*/
public interface Comparator2<T> {
//全局常量
public static final int MAX_VALUE =100;
//公共抽象方法
public abstract void test(T t);
}
//实现
class InterC1<A> implements Comparator2{
@Override
public void test(Object t) {//类型是父类的
System.out.println(this.MAX_VALUE); //父类的
}
}
class InterC2<Integer> implements Comparator2<Integer>{
@Override
public void test(Integer t) { //类型是父类的
}
}
class InterC3<T,A> implements Comparator2<T>{
@Override
public void test(T t) {//类型是父类的
}
}
泛型擦除:
package generic;
/**
* 泛型的擦除:使用时 实现|继承 没有指定具体的类型
* 类似于Object 不等同于Object
* @author Administrator
*
*/
public class MyStuApp {
public static void main(String[] args) {
//擦除:没有指定泛型的具体类型
//泛型擦除,但是存在警告
MyStudent student = new MyStudent();
student.setJavase(100); //int-->Object,以Object处理
Object javase = student.getJavase();
//2、消除警告 使用 Object
MyStudent<Object> student2 = new MyStudent<Object>();
//正确: 擦除,编译通过,不会类型检查
test(student);
//编译失败:MyStudent<Object> 不等同于Object
//错误 ,Object 编译检查
//test(student2);
}
public static void test(MyStudent<Integer> stu){
}
}
附MyStudent类:
package generic;
/**
* 自定义泛型类:
* 1,<> -->单个字母,尽可能见名知意
* 2,T Type
* K V Key Value
* E Element
* 3,注意泛型不能使用在静态属性上
*/
//T type ,类型
public class MyStudent<T> {
private T javase;
// private static T test;//静态编译错误
public MyStudent(){}
public MyStudent(T javase) {
super();
this.javase = javase;
}
public T getJavase() {
return javase;
}
public void setJavase(T javase) {
this.javase = javase;
}
}
总结:
- 继承|实现
a) 保留:泛型子类
b) 不保留:按需实现,可以泛型子类,也可以是非泛型子类。属性|方法 :随声明的位置而定。
2.擦除:使用 继承|实现 没有指定类型,类似于Object