java中的泛型方法可以限制可接受的类型吗？

Question

I have a similar requirement to this question . I would like to generify a method but restrict the types the acceptable by the generic parameter. Currently what I do is attempt to cast to the acceptable types in the method but seems cumbersome if dealing with more than 2 or 3 types.

EDIT :
The types may not be of the same base class. Apologies for not mentioning this earlier.

Answer 1

For this, You must have a base class so that you can do this.

public class Person {
  String name;
  List<Profession> professions;
  int age;
}

public class Doctor {
  String university;
  Boolean doctorate;
  public void work() {
       // do work
  }
}

public class Teacher {
  List<Grade> grades;
  float salary;
  public void work() {
       // do work
  }
}

public class Animal<T> {
    T type;
}

So, now if you want to write a method which is generic and applies to all, You can do something like this,

public void doSomething(Animal<T extends Person> human) {
  human.work();
}

If the class is not of type Person , it will show a compilation error.

UPD1:
In the case, all the classes do not have a common base class. There is some functionality that makes them unique. By this, we can consider them to have a common function, which we can and should add using an interface .

Let's look at some code,

public class Human implements Growable {
  public void grow() {
    // human grow code
  }
}

public class Plant implements Growable {
  public void grow() {
    // plant grow code
  }
}

public class Table {
  // does not grows
}

public class GrowService {
  public static void grow(Growable growable) {
     growable.grow();
  }
}

interface Growable {
  public void grow();
}

And by calling the below method, we can achieve this

// Works fine
GrowingService.grow(new Plant());
// throws compilation error
GrowingService.grow(new Table());

Answer 2

Java Generics allow basic wildcards such as <T> but also more specifics like

<T extends Number> which means any type T that is Number or a subclass of it or

<T super Number> which means T can be Number or any superclass of Number all the way up to Object.