You should implement Comparable <Person>. Assuming all fields will not be null (for simplicity sake), that age is an int, and compare ranking is first, last, age, the compareTo method is quite simple:

public int compareTo(Person other) {
    int i = firstName.compareTo(other.firstName);
    if (i != 0) return i;

    i = lastName.compareTo(other.lastName);
    if (i != 0) return i;

    return Integer.compare(age, other.age);
}

This is an enhancement of Dumbo's difference method, using recursion to check all nested complex fields.

    private static void difference(Object s1, Object s2, List<String> changedProperties, String parent) throws IllegalAccessException {
        for (Field field : s1.getClass().getDeclaredFields()) {
            if (parent == null) {
                parent = s1.getClass().getSimpleName();
            }
            field.setAccessible(true);
            Object value1 = field.get(s1);
            Object value2 = field.get(s2);
            if (value1 == null && value2 == null) {
                continue;
            }
            if (value1 == null || value2 == null) {
                changedProperties.add(parent + "." + field.getName());
            } else {
                if (isBaseType(value1.getClass())) {
                    if (!Objects.equals(value1, value2)) {
                        changedProperties.add(parent + "." + field.getName());
                    }
                } else {
                    difference(value1, value2, changedProperties, parent + "." + field.getName());
                }
            }
        }
    }

    private static final Set<Class> BASE_TYPES = new HashSet(Arrays.asList(
            String.class, Boolean.class, Character.class, Byte.class, Short.class, Integer.class, Long.class, Float.class, Double.class, Void.class));
    public static boolean isBaseType(Class clazz) {
        return BASE_TYPES.contains(clazz);
    }

Sample usage (assumes the referenced model objects have getters/setters):

    public static void main(String[] args) throws IllegalAccessException {
        Student s1 = new Student();
        s1.setName("Krishna");
        s1.setAge(30);
        Address address = new Address();
        s1.setAddress(address);
        s1.getAddress().setHno("2-2-22");
        s1.getAddress().setStreet("somewhere");
        s1.getAddress().setPin(123);

        Student s2 = new Student();
        s2.setName("Krishna");
        s2.setAge(20);
        address = new Address();
        s2.setAddress(address);
        s2.getAddress().setHno("1-1-11");
        s2.getAddress().setStreet("nowhere");
        s2.getAddress().setPin(123);
        List<String> changedProperties = new ArrayList<>();

        difference(s1, s2, changedProperties, null);
        System.out.println("changedProperties = " + changedProperties);
        // expected result
        // Student.age
        // Student.address.hno
        // Student.address.street
    }

Result:

changedProperties = [Student.address.hno, Student.address.street, Student.age]

Primitive adapting checking adapted from https://stackoverflow.com/a/711226/1527469

You may use javers library for this.

  <groupId>org.javers</groupId>
  <artifactId>javers-core</artifactId>

POJO:

    public class Person {
    private Integer id;
    private String name;

    // standard getters/constructors
}

Usage:

    @Test
public void givenPersonObject_whenApplyModificationOnIt_thenShouldDetectChange() {
    // given
    Javers javers = JaversBuilder.javers().build();

    Person person = new Person(1, "Michael Program");
    Person personAfterModification = new Person(1, "Michael Java");

    // when
    Diff diff = javers.compare(person, personAfterModification);

    // then
    ValueChange change = diff.getChangesByType(ValueChange.class).get(0);

    assertThat(diff.getChanges()).hasSize(1);
    assertThat(change.getPropertyName()).isEqualTo("name");
    assertThat(change.getLeft()).isEqualTo("Michael Program");
    assertThat(change.getRight()).isEqualTo("Michael Java");
}

Plus other use cases are supported as well.

Comparing objects with different fields sounds like bad polymorphic design, whether it's Java or any other OOP language:

• If your comparator needs to know the precise subtype of an object to do the comparison, you mess-up with the the open-closed principle, since for every new subclassing, you'd potentially need to modify the comparator to select the relevant fields.
• If your comparator needs uses reflexion to find on its own the relevant fields to compare, you indirectly mess up with the principle of encapsulation, since you create a hidden requirement that information to be compared must be in some predetermined field.

If you want to sort People properly in a clean polymorphic design:

• you need to rely either on a field, available for any kind of People, including Student, or
• you may call some function/transformation that provides a unique value (e.g. a string) that allows to sort any People. People and Student may then just use a different transformation that will be passed to the comparator; Or
• you only sort among homogeneous subtypes.