Java - почему никакой возврат основанная на типе перегрузка метода?

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

String doSomething(String s) { ... }
String doSomething(Integer s) { ... }
...
String out=doSomething(null);

В этом случае компилятор просто жалуется, что вызов неоднозначен, и вы должны разрешить его, приведя значение null, например:

String out=doSomething((String)null);

Вы можете сделать то же самое с перегрузкой по типу возвращаемого значения:

String getSomething() { ... }
Integer getSomething() { ... }
...
Integer n=getSomething();

предположительно вызовет вторую функцию.

getSomething();

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

(String) getSomething();

Более реалистично, возможно:

if ((String) getSomething()==null) ...

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

String getSomething() { ... };
Integer getSomething() { ... };
String getOtherthing() { ... };
...
if (getSomething().equals(getOtherthing())) ...

Компилятор должен выяснить, что и String, и Integer имеют функции равенства, поэтому в этой точке допустима любая из них. Тогда он должен был бы заметить, что getOtherthing - это String, а Integer.equals (String) маловероятен, поэтому, вероятно, автор хотел String.equals (String). Выполнимо, но в этот момент я начинаю понимать, что в общем случае это может быть зверь.

А затем предположим, что мы добавляем:

Integer getOtherthing() { ... };

Что делает компилятор с этим оператором IF? Он может использовать строковые версии обеих функций или целое число, но не строку одной и целое число другой. В этот момент, я полагаю, ему пришлось бы настоять на том, чтобы кто-то сказал, какой именно. Но сложность действительно выходит из-под контроля.

И если компилятору сложно понять, что вы на самом деле имеете в виду, представьте, что это будет для другого программиста, который не сможет найти все сигнатуры функций так быстро, как компилятор.

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

Это потому, что вы можете игнорировать возвращаемое значение.

Хотя это теоретически возможно, оно не использовалось в Java по той же причине, что и в C ++; а именно, было обнаружено, что перегрузки, основанные на типах возврата, как правило, более сбивают с толку разработчиков, выгода незначительна по сравнению с затратами на его реализацию, и это было бы неоднозначным в случае, когда тип возврата не назначается объекту ценить. По этим причинам перегрузка на основе возвращаемого типа не поддерживается.

Поскольку Java может привести значение возвращаемого типа к целевой переменной, поэтому она не знает, в какой тип переменной вы сохраняете возвращаемое значение функции.