Как правильно вернуть что-то, что расширяется от класса и реализует интерфейс?

Вы получаете ошибку, потому что тип, выводимый для параметра T во втором месте вызова, то есть Checkable c = get(), просто Checkable, как правильно сообщает сообщение об ошибке.

Если вы заставите вызов использовать совместимый тип View & Checkable, он скомпилируется. Для этого вы должны указать тип явно, например:

private <T extends View & Checkable> T get() {
   return (T) mView;
}

private <T extends View & Checkable> void useGeneric() {
    View v = this.get(); // no need for an explicit type
    Checkable c = this.<T>get(); // an explicit type needed
    T t = this.get(); // best way
}

private void useSpecific() {
    class Specific extends View implements Checkable {}
    Checkable c = this.<Specific>get(); // risk of ClassCastException
    Specific s = this.get(); // best way; risk of ClassCastException
}

Тот факт, что в случае присвоения классу он не требует явного типа, в то время как он требуется в случае интерфейса, выглядит для меня артефактом алгоритма вывода типа, асимметрией класса/интерфейса.

Прежде чем я углублюсь в дженерики... Почему бы вам просто не ввести CheckableView и не вернуть этот тип?

public class CheckableView extends View implements Checkable {
}


 private CheckableView getCheckableView() {
     return checkableView;
 }

Если бы View был интерфейсом, он работал бы:

interface View {}
interface Checkable {}
class CheckableView implements Checkable, View {}

public class Main {

    private static CheckableView checkableView;

    private static  <T extends View & Checkable> T get() {
        return (T) checkableView;
    }

    public static void main(String[] args) {
        View view = Main.get();
        Checkable checkable = Main.get();
    }
}

Я думаю, что проблема с пониманием дженериков заключается в том, что T extends View & Checkable в реальном случае не означает, что вы можете вернуть любой тип, который расширяет View и реализует Checkable.

Это означает, что клиент может привести возвращенный тип к любому типу, который расширяет View и реализует Checkable.

Клиент может сделать что-то вроде этого:

class CheckableView extends View implements Checkable {}
class OtherView extends View implements Checkable {}

private static  <T extends View & Checkable> T get() {
    return (T) checkableView;
}

OtherView otherView = Main.get();
CheckableView checkableView = Main.get();

но что вы хотите сделать сейчас с реализацией?

 private <T extends View & Checkable> T get() {
      return ...;
 }

Что должен возвращать этот метод? Если вы вернете CheckableView, компилятор скажет, что вы должны привести его к T, потому что клиент может привести его к любому типу T. Но это также означает, что вы получите предупреждение Unchecked cast from CheckableView to T, потому что, если клиент приведет его к любому другому типу, кроме CheckableView, например. OhterView, вы получите ClassCastException.

Поскольку разработчик метода get не может знать, к какому типу его когда-либо приведет клиент, он не может определить, какой объект следует вернуть.

И если разработчик возвращает определенный объект (например, CheckableView), то клиент может привести его только к этому типу. Так почему же разработчик не меняет сигнатуру метода, чтобы он возвращал именно этот тип? .... или ввести специальный тип или интерфейс для этого случая?

Возможно, это решение для вас

Создайте интерфейс, который будет возвращать метод get, например.

public interface CheckableView {
}

Измените метод get, чтобы он возвращал CheckableView

private CheckableView get() {
}

Напишите адаптер, который адаптирует ваши View, реализующие Checkable, к CheckableView.

public class CheckableViewAdapter<T extends View & Checkable> implements CheckableView {

    private T checkableView;

    public  CheckableViewAdapter(T checkableView) {
        this.checkableView = checkableView;
    }
}

Теперь вы можете создавать экземпляры CheckableView для каждого View, реализующего Checkable.

class SomeView extends View implements Checkable {}

SomeView someView = ...;
CheckableView checkableView = new CheckableViewAdapter<SomeView>(someView);

Добавьте методы, которые нужны клиенту метода get, в интерфейс CheckableView и реализуйте его в файле CheckableViewAdapter.

public interface CheckableView {
     public void bringToFront();
}

public class CheckableViewAdapter<T extends View & Checkable> implements CheckableView {

    private T checkableView;

    public  CheckableViewAdapter(T checkableView) {
        this.checkableView = checkableView;
    }

        public void bringToFront(){
            checkableView.bringToFront();
        }
}

или просто

public interface CheckableView {
     public View getView();
     public Checkable getCheckable();
}

Проблема в том, что у вас вместо амперсанда запятая! Это определение:

private <T extends Checkable, View> T get() {

Не является перекрестком! Скорее, он объявляет 2 универсальных типа, один с именем T, а другой с именем View, который не используется в вашем классе - это то же самое, что и кодирование:

private <T extends Checkable, V> T get() {

Итак, измените его на:

private <T extends View & Checkable> T get() {

Обратите внимание, что при общих пересечениях класс должен стоять перед интерфейсом.