Java参数化方法说明

Question

I would like to implement a Generic method inside a CommonInterface to implement it with different parameters and return Type.

Therefore I have:

public interface Common {
  public <T, N> T call(N n);
}

If I understand well Generics logic (maybe not..) the call method return a Type T and receive as parameter a Type N. Therefore:

public class Class implements Common {

  @Autowired private SomeService someService;
   
  @Override
  public <ClassDTO, Integer> ClassDTO call(Integer id) {
      String s = someService.doSome(id); // suppose doSome receive an Integer as param
  }
}

DoSome method is a simple method that receive as input parameter an Integer:

@Service
public class SomeService {

 // some @Autowired other service

   public String doSome(Integer id) {
     // some operation

   }
}

I receive an error on doSome(id) call who said me:

The method doSome(java.lang.Integer) in the type SomeService is not applicable for the arguments (Integer)

It's like if:

public <ClassDTO, Integer> ClassDTO call(Integer id) {
}

The Integer above is not recognized as java.lang.Integer . I try to put java.lang.Integer as follows:

public <ClassDTO, java.lang.Integer> ClassDTO call(Integer id) {
}

but obtains other errors..

What's wrong??

Answer 1

If you look closer to the override of call :

public <ClassDTO, Integer> ClassDTO call(Integer id) {
  String s = someService.doSome(id); // suppose doSome receive an Integer as param
}

you could see that ClassDTO and Integer are not real types, but type parameters (like T and N ), which are called that way. Not following the convention of naming type parameters can lead do the confusion you have.

The override is more clear when it's just like:

@Override
public <T, N> T call(N n) {
  ...
}

The types which replace the type parameters ClassDTO and Integer will be the ones, with which you call the call() method:

Class instance = new Class();
Integer integer = 5;
ClassDTO result = instance.<ClassDTO, Integer>call(integer);

This, however, will not resolve the compile-error when calling service.doSome(id) .

In order to make it compliling you can parametrize the Common interface with T and N and then your Class can implement the generic interface with specific types ( CommonDTO and Integer ):

public interface Common<T, N> {
  T call(N n);
}

The Class will then look like:

public class Class implements Common<CommonDTO, Integer> {

  private Service service;

  @Override
  public CommonDTO call(Integer n) {
    return service.doSome(n);
  }
}

which now compiles just fine.

Answer 2

You're simply missing the fact that Integer in the body of your call method override is not the same as java.lang.Integer .

This happens often with generics when the simple single-uppercase-letter type variable naming convention is skipped.

The parameter Integer id is not of the same type as the one taken by doSome , presumably java.lang.Integer .

---

Side note: you're hiding implicitly imported classes ( Class , Integer ), which is known to lead to bugs; and that's beside not following the naming convention for type variables. Conventions sometimes help prevent bugs!