Java 如何动态转换为泛型类型

我有以下两个类BaseObject：

public class BaseObject
{
    private String name;

    public String getName()
    {
       return name;
    }

    public static Predicate<? extends BaseObject> isNameEqualTo(String test) 
    {
         return p -> p.getName().equals(test);
    }
}

---

注释

@FilterableField

是指字段是否可过滤的指示符，以及字段本身元信息的容器。现在我的问题是，使用反射，我无法将

谓词

强制转换为

谓词。注意：1）由于类型擦除，没有名为
谓词
的类，只有
谓词
。2） 您没有使用
clz.cast（test）的返回值
这样，如果不能强制转换，调用除了抛出异常之外什么都不会做。
谓词动态强制转换是什么意思？你知道类名（在你的例子中是“谓词”）是在编译时还是仅在运行时？我只是尝试使用
Predicate
而不是
Predicate
来过滤我的测试列表，效果非常好。谢谢不知道为什么我没想过早点试试。。。
public class User extends BaseObject
{
     private String firstName;

     public static Predicate<? extends User> isFirstNameEqualTo(String test) 
     {
          return p -> p.getFirstName().equals(test);
     }
}

@FilterableField(name="firstName")
public static Predicate<? extends User> isFirstNameEqualTo(String test) 
{
    return p -> p.getFirstName().equals(test);
}

Set<Method> allMethods = ReflectionUtils.getAllMethods(User.class);
    Map<FilterableField, Method> annotatedMethods = new HashMap<>();
    for(Method m : allMethods)
    {
        FilterableField annotation = m.getAnnotation(FilterableField.class);
        if(annotation == null)
        {
            continue;
        }
    annotatedMethods.put(annotation, m);
}
annotatedMethods.forEach((k,v)->{
    System.out.println("Annotation : " + k.name() + " Method : " + v.getName());
if(k.name().equals("name"))
        {
            try
            {
                //Class clz = v.getDeclaringClass();
                Class clz = Class.forName("Predicate<User>");
                Predicate test = (Predicate<?>)v.invoke(null, "Hans");
                clz.cast(test);
                List<User> users = new ArrayList<User>();
                User user = new User();
                user.setName("Hans");
                users.add(user);
                user = new User();
                user.setName("Werner");
                users.add(user);
                List<User> dummy = users.stream().filter(test).collect(Collectors.toList());
                System.out.println("Main.reflectionPredicateTest - dummy: "+dummy);
            }
            catch (IllegalAccessException e)
            {
                e.printStackTrace();
            }
            catch (InvocationTargetException e)
            {
                e.printStackTrace();
            }
            catch (ClassNotFoundException e)
            {
                e.printStackTrace();
            }
        }
    });