Determine if Class B uses Class A ( Java Reflection)

Is my test holistic, that is, did I test for everything?

Currently, this is what you're testing for:

• Declared fields on the class with getDeclaredFields();
• A superclass with getSuperclass();
• The parameters of the declared constructors with getDeclaredConstructors();
• The parameters of the declared methods with getDeclaredMethods().

This is what you are not testing for:

• Inherited fields: they are not returned by the call to getDeclaredFields(), so fields inherited from superclasses are not considered;
• The method return type: you are just checking for the type of the parameters but not the return type with getGenericReturnType();
• Annotations on the method (getAnnotations()), on the method parameters (getParameterAnnotations()) or on the method return type (getAnnotatedReturnType());
• Annotations on the class itself with getAnnotations();
• Exceptions declared to be thrown by the methods with getGenericExceptionTypes(), in the same way, the exceptions declared to be thrown by the declared constructors are also not considered;
• All the hierarchy of the class: you are only testing for the potential superclass, but not for the potential implemented interfaces or the super-superclasses;
• If the given class is an array type, you are not testing its component type with getComponentType().
• For the generic types returned by getDeclaredFields() or getGenericReturnType() for example, you can access the actual type argument by casting the type to ParameterizedType and call getActualTypeArguments(). This will return an array of all the type argument of the parameterized type. For example, if a declared field is a Map<String, Integer>, it will return the array [class java.lang.String, class java.lang.Integer].

Are there any bugs in the code?

Yes, there is a potential bug: getSuperclass can return null:

If this Class represents either the Object class, an interface, a primitive type, or void, then null is returned

so you need to take care about handling that. Your current code is

if(b.getSuperclass().getName().equals(a.getName()))

which could throw a NullPointerException.

Other comments:

• Make sure to always use curly braces, even if it is not strictly needed here. It will make the code less error-prone for the future.
• This only uses the Reflection API. Determining whether a given class A truly uses a given class B or not would require going into the byte-code to see if there are any references through chained method calls, import statements or local variables.

First of all, your comments are completely superfluous. Consider this wisdom from Clean Code by Uncle Bob:

So when you find yourself in a position where you need to write a comment, think it through and see whether there isn’t some way to turn the tables and express yourself in code. Every time you express yourself in code, you should pat yourself on the back. Every time you write a comment, you should grimace and feel the failure of your ability of expression

In your case you can turn your code more expressive like this:

private boolean uses(Class<?> b, Class<?> a){
    if (testForDeclaredFields(b, a)) return true;
    if (testForInheritance(b, a)) return true;
    if (testForConstructors(b, a)) return true;
    if (testForMethods(b, a)) return true;
    return false;
}

Second, you should write proper unit tests for your code. That's a good way of verifying your code works.

Third, you are comparing the class name strings, when you could just compare the Class objects: instead of p.getName().equals(a.getName()) you can just say p.equals(a).

And as was already discussed in the comment section of your question, your code does not cover all the uses cases. It's missing at least local variables, inherited methods, and method return types.

So, if I have a simple class like this:

class NoName {
    public void thing() {
        BigDecimal bd = BigDecimal.ZERO;
        System.out.println(bd.toPlainString());
    }
}

Would your code be likely to discover that I'm using BigDecimal? How about System? Or, PrintStream?

Actually, you're checking if I'm using a given class in my interface, not in my implementation. I could be using the class you're searching for a thousand times and you'd still not know.

You're not only missing these local variables and uses, but you're also missing method return types, anything inherited, and generics on each class of object you've already considered including the class itself.

If you're looking for a has-a or a uses-a relationship you'll have to work a lot harder than this to get it right. You would probably have to decompile the bytecode or use the Java platform debugger architecture (JPDA).