Java未检查强制转换警告：必需的ArrayList<；T>；，找到ArrayList<；合同>；

我正在用Java向分页类添加泛型。我在修复代码以避免在方法

public ArrayList getNextPage（）上出现这些“unchecked cast”警告时遇到问题。

警告：java:uncheckedcast
必需：java.util.ArrayList
找到：java.util.ArrayList
关于：

return（ArrayList）getPaginatedContracts（startRow，pageSize）

警告：java:uncheckedcast

必需：java.util.ArrayList

找到：java.util.ArrayList

关于：

return（ArrayList）getPaginatedJobs（startRow，pageSize）

目前，
T
可以是
合同
或
工作

是否有其他方法可以返回正确使用泛型且没有任何警告的
ArrayList

public class PaginationWrapper<T> {

    private Class<T> clazz;
    private int currentPage;
    private int pageSize;

    public PaginationWrapper(Class<T> clazz) {
        this.clazz = clazz;
        this.currentPage = -1;
        this.pageSize = 100;
    }

    private static ArrayList<Contract> getPaginatedContracts(int startRow, int pageSize) {
        ArrayList<Contract> list = new ArrayList<>(pageSize);
        // Get info from database
        return list;
    }

    private static ArrayList<Job> getPaginatedJobs(int startRow, int pageSize) {
        ArrayList<Job> list = new ArrayList<>(pageSize);
        // Get info from database
        return list;
    }

    public ArrayList<T> getNextPage() {
        currentPage++;
        int startRow = currentPage * pageSize;
        if (clazz.isAssignableFrom(Contract.class)) {
            // Warning: java: unchecked cast
            // required: java.util.ArrayList<T>
            // found: java.util.ArrayList<Contract>
            return (ArrayList<T>) getPaginatedContracts(startRow, pageSize);
        } else if (clazz.isAssignableFrom(Job.class)) {
            // Warning: java: unchecked cast
            // required: java.util.ArrayList<T>
            // found: java.util.ArrayList<Job>
            return (ArrayList<T>) getPaginatedJobs(startRow, pageSize);
        }
        return null;
    }


    static class Contract {
    }

    static class Job {
    }

    public static void main(String[] args) {
        PaginationWrapper<Contract> contractWrapper = new PaginationWrapper<>(Contract.class);
        ArrayList<Contract> paginatedList = contractWrapper.getNextPage();
    }
}

或者由于我的构造函数接受一个
类
并执行一些类型检查：例如
如果（clazz.isAssignableFrom（Contract.Class））{…}

我可以在
getNextPage（）
上使用
@SuppressWarnings（“unchecked”）

public class PaginationWrapper<T> {

    private Class<T> clazz;
    private int currentPage;
    private int pageSize;

    public PaginationWrapper(Class<T> clazz) {
        this.clazz = clazz;
        this.currentPage = -1;
        this.pageSize = 100;
    }

    private static ArrayList<Contract> getPaginatedContracts(int startRow, int pageSize) {
        ArrayList<Contract> list = new ArrayList<>(pageSize);
        // Get info from database
        return list;
    }

    private static ArrayList<Job> getPaginatedJobs(int startRow, int pageSize) {
        ArrayList<Job> list = new ArrayList<>(pageSize);
        // Get info from database
        return list;
    }

    public ArrayList<T> getNextPage() {
        currentPage++;
        int startRow = currentPage * pageSize;
        if (clazz.isAssignableFrom(Contract.class)) {
            // Warning: java: unchecked cast
            // required: java.util.ArrayList<T>
            // found: java.util.ArrayList<Contract>
            return (ArrayList<T>) getPaginatedContracts(startRow, pageSize);
        } else if (clazz.isAssignableFrom(Job.class)) {
            // Warning: java: unchecked cast
            // required: java.util.ArrayList<T>
            // found: java.util.ArrayList<Job>
            return (ArrayList<T>) getPaginatedJobs(startRow, pageSize);
        }
        return null;
    }


    static class Contract {
    }

    static class Job {
    }

    public static void main(String[] args) {
        PaginationWrapper<Contract> contractWrapper = new PaginationWrapper<>(Contract.class);
        ArrayList<Contract> paginatedList = contractWrapper.getNextPage();
    }
}

公共类分页包装器{
私人课堂；
私人网页；
私有int页面大小；
公共分页包装器（类clazz）{
this.clazz=clazz；
this.currentPage=-1；
这个.pageSize=100；
}
私有静态数组列表getPaginatedContracts（int startRow，int pageSize）{
ArrayList list=新的ArrayList（页面大小）；
//从数据库获取信息
退货清单；
}
私有静态数组列表getPaginatedJobs（int startRow，int pageSize）{
ArrayList list=新的ArrayList（页面大小）；
//从数据库获取信息
退货清单；
}
公共阵列列表getNextPage（）{
currentPage++；
int startRow=当前页面*页面大小；
if（类别可从（合同类别））{
//警告：java:uncheckedcast
//必需：java.util.ArrayList
//找到：java.util.ArrayList
return（ArrayList）getPaginatedContracts（startRow，pageSize）；
}else if（clazz.isAssignableFrom（Job.class））{
//警告：java:uncheckedcast
//必需：java.util.ArrayList
//找到：java.util.ArrayList
return（ArrayList）getPaginatedJobs（startRow，pageSize）；
}
返回null；
}
静态类合同{
}
静态课堂作业{
}
公共静态void main（字符串[]args）{
PaginationWrapper contractWrapper=新的PaginationWrapper（Contract.class）；
ArrayList paginatedList=contractWrapper.getNextPage（）；
}
}
您可以将该类抽象，然后子类必须实现实际的数据库调用：

public abstract class PaginationWrapper<T> {
    private int currentPage = 1;
    private int pageSize = 100;

    public ArrayList<T> getNextPage() {
        currentPage++;
        int startRow = currentPage * pageSize;

        // here we delegate to the implementation
        return getNextPage(startRow, pageSize);
    } 

    protected abstract ArrayList<T> getNextPage(int startRow, int pageSize);
}

公共抽象类分页包装器{
private int currentPage=1；
私有int pageSize=100；
公共阵列列表getNextPage（）{
currentPage++；
int startRow=当前页面*页面大小；
//在这里，我们授权实现
返回getNextPage（startRow，pageSize）；
} 
受保护的抽象数组列表getNextPage（int startRow，int pageSize）；
}

然后创建2个子类

public class JobPagination extends PaginationWrapper<Job> {
    protected ArrayList<Job> getNextPage(int startRow, int pageSize) {
         return /* list from database */
    }
}

public class ContractPagination extends PaginationWrapper<Contract> {
    protected ArrayList<Contract> getNextPage(int startRow, int pageSize) {
         return /* list from database */
    }
}

公共类作业分页扩展了分页包装器{
受保护的ArrayList getNextPage（int startRow，int pageSize）{
从数据库返回/*列表*/
}
}
公共类ContractPagination扩展了PaginationWrapper{
受保护的ArrayList getNextPage（int startRow，int pageSize）{
从数据库返回/*列表*/
}
}

现在，常规逻辑被打包到
分页包装器中
，但实际的数据库逻辑现在驻留在特定的子类中。
如果您正在执行非平凡的转换，那么它将被标记。这样的强制转换本质上是不安全的。为什么首先要使用泛型？在我看来没有什么意义。你可以直接调用特定的方法，这和我得出的结论完全一样。已尝试该代码，但效果良好。：-）