欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

JAVA泛型-泛型的接口

程序员文章站 2022-07-15 21:00:44
...

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!