Можно ли использовать универсальный тип универсального метода Java для принудительного применения типа аргументов?

Если я правильно понял, один из способов сделать это - явно укажите тип T вместо того, чтобы позволить компилятору вывести свой тип как самый прямой суперкласс в случае передачи двух объектов разных типов в качестве аргументов. Взять что-то вроде этого, например:

public class Test {
    public static void main(String[] args) {
        Test.x(5.0, 5);          // This works since type is inferred to be Number
        Test.<Integer>x(5, 5);   // This works since type is stated to be Integer
        Test.<Integer>x(5.0, 5); // This doesn't; type is stated to be Integer and Double is passed in
    }

    public static <T> void x(T a, T b) {
    }
}

почему это должно быть проблемой в первую очередь, для меня туманно. Я подозреваю, что вы вместо этого неправильно поняли что-то о том, как система типов полезна.

что мы можем сделать с <T> void x(T a, T b)? Ну, не совсем много. Внутри тела x,T это то же самое, что Object, так что мы могли только сделать что-то вроде вызова toString on a и b печатать их.

там действительно нет практической причинаa и b должен иметь тот же тип. Просто у них есть какой-то общий тип, и этот тип Object или его подтип. На самом деле, нет никакой ясной причины, почему <T> void x(T a, T b) на самом деле должен быть общим вообще.

• тело метода не заботится о том, что фактические типы a и b потому что он не мог использовать их в любом случае.
• сайт вызова не заботится о том, какие фактические типы a и b, потому что x это void способ это черная дыра.

это более типично для метода, чтобы иметь результат, как <T> List<T> Arrays.asList(T...):

// This will cause a compile error because
// the type inferred must be compatible
// with the return assignment.
List<Integer> r = Arrays.asList(1, 1.0);

или связанный:

// We don't care what the actual types of
// a and b are, just that we can call bar()
// on them.
// Note: this method does not need to be generic.
<T extends Foo> void x(T a, T b) {
    a.bar();
    a.bar();
}

или граница, которая утверждает какое-то отношение:

// We don't care what the actual types of
// a and b are, just that we can compare
// them to each other.
<T extends Comparable<T>> T max(T a, T b) {
    return (a.compareTo(b) < 0) ? b : a;
}

при вызове метода можно явно указать параметр type. Например:

 <String>x("hello", "world");

однако, если вы не укажите тип-параметр явно и полагайтесь только на функцию вывода типа Java, тогда я не думаю, что вы можете, не только в дженериках, но и в целом.

тип параметра метода не является конкретным типом, но это скорее то, что обозначает набор применимых типов (даже этот set может состоять только из одного типа, в случае final классы, например).

например, такой способ:

public void x(Something a) { }

обозначает метод, параметр которого должен иметь тип из набор типов, которые совместимы с Something (т. е. Something и все его подтипы).

то же самое относится и к дженерикам.

предположительно, вы не вызываете свой общий метод в общем виде, поэтому он рассматривается как вызов x(Object a, Object b). В этом примере:

public class Test {

  static <T> void x(T a, T b) {
  }

  public static void main(String[] args) {
    x(1, 2); // compiles
    Test.<String>x(1, 2); // does not compile
    Test.<String>x("a", "b"); // compiles
  }
}

первый вызов x не выполняется в общем виде, поэтому он компилируется. Второй вызов приравнивает T до String, Так что это не удается, потому что 1 и 2 не Strings. Третий вызов компилируется, потому что он правильно проходит в Strings.

Это сработало для меня

public static <T> void x(T a, T b, Class<T> cls) {
}

Теперь это компилирует

public static void main(String[] args) throws Exception {
    x(1, 2, Integer.class);
}

и это не

public static void main(String[] args) throws Exception {
    x(1, "", Integer.class);
}