JAVA泛型-泛型的接口

1.泛型接口的语法

1.1 实现类是泛型类

1.实现类类的泛型类型要和接口的泛型类型一致
class GenericImpl <T> implements GenericInterface<T>

2.实现类的泛型类型要包含接口的泛型类型
class GenericImpl <T,E,...> implementsGenericInterface<T>

1.2 实现类是普通类

实现类必须要明确指定接口的泛型类型
class GenericImpl   implements GenericInterface<String>

2.实现一下泛型接口

2.1 定义一个普通类当作类型

/**
 * author : northcastle
 * createTime:2021/10/20
 * 自定义普通类，用来做泛型的实际参数
 */
public class Cat {
    private String name;

    public Cat() {
    }

    public Cat(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Cat{" +
                "name='" + name + '\'' +
                '}';
    }
}

2.2 定义一个泛型接口

/**
 * author : northcastle
 * createTime:2021/10/20
 * 泛型接口
 */
public interface SayHello<T> {
    //声明了一个带有泛型类型的方法
    T printT(T t);
}

2.3 定义一个泛型实现类

/**
 * author : northcastle
 * createTime:2021/10/20
 * 泛型接口的实现A - 泛型类型
 */
public class SayHelloImplA<T,E> implements SayHello<T>{

    private E e;

    @Override
    public T printT(T t) {
        System.out.println("This is SayHelloImplA "+t);
        return t;
    }
    //getter/setter方法
    public E getE() {
        return e;
    }

    public void setE(E e) {
        this.e = e;
    }

    //自定义普通的方法
    public void sayHelloE(){
        System.out.println("Hello E : "+e);
    }
}

2.4 定义一个普通实现类

/**
 * author : northcastle
 * createTime:2021/10/20
 * 泛型接口的实现类-普通类B
 */
public class CommonImplB implements SayHello<Cat> {

    @Override
    public Cat printT(Cat cat) {
        System.out.println("This is CommonImplB "+ cat);
        return cat;
    }
}

2.5 编写测试代码

/**
 * author : northcastle
 * createTime:2021/10/20
 * 测试类
 */
public class Application {
    public static void main(String[] args) {
        //1.创建一个 泛型实现类的 对象
        SayHelloImplA<String, Integer> implA = new SayHelloImplA<>();
        implA.printT("我是泛型类-实现类");
        implA.setE(100);
        implA.sayHelloE();
        System.out.println("==================");

        //2.创建一个 普通实现类的 对象
        CommonImplB commonImplB = new CommonImplB();
        Cat huahua = new Cat("huahua");
        commonImplB.printT(huahua);

    }
}

2.6 测试结果

This is SayHelloImplA 我是泛型类-实现类
Hello E : 100
==================
This is CommonImplB Cat{name='huahua'}

3.完成

Congratulations！
You are one step closer to success!