Java自学笔记——自定义泛型

Java自学笔记——自定义泛型

特点

定义以下的Tiger类，省略部分get set 方法

class Tiger<T, R, M>{
    String name;
    R r;
    T t;
    M m;

    //泛型数组不能初始化
    //数组在 new 时无法确定T的类型，无法确定开辟多少空间，因此只能定义
    //T[] ts = new T[8];
    T[] ts;

    //静态和类相关，在类加载时，对象还没创建，如果使用泛型，JVM就无法完成初始化
    //static R r2;

    //构造器使用泛型
    public Tiger(String name, R r, T t, M m) {
        this.name = name;
        this.r = r;
        this.t = t;
        this.m = m;
    }

    //方法使用泛型
    public R getR() {
        //返回类型返回泛型
        return r;
    }
}

1. Tiger 后有泛型，所以把 Tiger 称为自定义泛型类
2. T, R, M 泛型标识符 一般为单个大写字母
3. 标识符可以有多个
4. 普通成员可以用泛型（属性、方法）使
5. 用泛型的数组不能初始化
6. 静态属性、静态方法不能使用泛型

泛型接口

• 静态成员不能使用泛型
• 接口的类型在继承或实现接口时确定

//实现接口时，直接指定泛型接类型  U为Integer  R为Float
//实现IUsb方法时，U替换为Integer  R替换为Float
class BB implements IUsb<Integer, Float>{
    @Override
    public Float get(Integer integer) {
        return null;
    }

    @Override
    public void hi(Float aFloat) {

    }

    @Override
    public void run(Float r1, Float r2, Integer u1, Integer u2) {

    }
}

//没有指定，用Object替换
//最好写成 class CC implements IUsb<Object, Object>{}
class CC implements IUsb{
    @Override
    public Object get(Object o) {
        return null;
    }

    @Override
    public void hi(Object o) {

    }

    @Override
    public void run(Object r1, Object r2, Object u1, Object u2) {

    }
}

interface IA extends IUsb<String, Double>{

}

//当我们实现IA接口时，因为IA在继承IUsb接口时，指定T为String R为Double
//在实现IUsb接口时，使用String替换U Double替换R
class AA implements IA{
    @Override
    public Double get(String s) {
        return null;
    }

    @Override
    public void hi(Double aDouble) {

    }

    @Override
    public void run(Double r1, Double r2, String u1, String u2) {

    }
}
interface IUsb<U, R>{
    //普通方法中，可以使用接口泛型
    R get(U u);

    void hi(R r);

    void run(R r1, R r2, U u1, U u2);

    //jdk8中，可以在接口中使用默认方法，可以使用泛型
    default R method(U u){
        return null;
    }

}

泛型方法

• 泛型方法，可以定义在普通类中，也能定义在泛型类中
• 注意区分泛型方法和使用泛型的方法

/**
 * @author Lspero
 * @version 1.0
 */
public class CustomMethodGenertic {
    public static void main(String[] args) {
        Car car = new Car();
        //调用方法时，传入参数，编译器会自动确认
        car.fly("宝马", 100);
    }
}

//泛型方法，可以定义在普通类中，也能定义在泛型类中
//普通类
class Car{
    public void run(){

    }

    //<T, R>是泛型 提供给fly使用
    public<T, R> void fly(T t, R r){
        System.out.println(t.getClass());
        System.out.println(r.getClass());
    }
}

//泛型类
class Fish<T, R>{
    public void run(){

    }

    //泛型方法
    public<U, M> void eat(U u, M m){

    }

    //不是泛型方法，而是hi()方法使用了类申明的泛型
    public void hi(T t){

    }
    //泛型方法可以使用自己申明的泛型，也可以用类申明的泛型
    public<K> void hello(R r, K k){
        System.out.println(r.getClass());
        System.out.println(k.getClass());
    }
}

通配符

public class GenerticExtends {
    public static void main(String[] args) {
        Object o = new String("xx");
        //泛型没有继承性
        //List<Object> list = new ArrayList<String>();

        /*
        通配符
        <?> 任意类型
        <? extends A> A及其子类，表示上限
        <? super A>   A及其父类，表示下限
         */
    }
}

JUnit

JUnit是Java的一种测试框架，测试时不需要在main方法里调用即可运行，方法前加@Test

/**
 * @author Lspero
 * @version 1.0
 */
public class Junit_ {
    public static void main(String[] args) {
        //传统方式
        //new Junit_().m1();
        //new Junit_().m2();
    }

    @Test
    public void m1(){
        System.out.println("m1 方法");
    }

    public void m2(){
        System.out.println("m2 方法");
    }

}