Ковариантность возвращаемых типов в Javа, я правильно понял суть?

Question

[zaorduu]

Читаю книгу "Философия java" Брюса Эккеля и дошел до небольшого раздела о ковариантности возращаемых типов в Java. Никак не могу понять, правильно ли я понял в чём идея? Пример кода :

package com.company;

public class Main {
    public static void main(String[] args) {
        Shape s;
        s = new BuildCircle().build();
        System.out.println(s);
        s.methodShape(); 
    }
}

class Shape {
    public String toString() {
        return "Shape";
    }
    public void drawShape(){
        System.out.println("draw Shape");
    }
}

class Circle extends Shape {
    public String toString() {
        return "Circle";
    }
    public void drawShape(){
        System.out.println("draw Circle");
    }
}

class BuildShape {
    Shape build() {
        return new Shape();
    }
    public void BuildingShape(){
        System.out.println("Building Shape");
    }
}

class BuildCircle {
    Circle build() {
        return new Circle();
    }
    public void BuildingCircle(){
        System.out.println("Builiding Circle");
    }
}

output:

Circle
draw Circle

Я так понимаю, на выходе мы получаем объект shape преобразованый к circle (более "специализированый" объект).
В результате чего все его методы переопределились, на те, который находятся в классе Circle, но, объект не получил новых методов, лишь переопределил свои собственные на те, что находятся в производном классе
Какое-то недонаследование в обратную сторону выходит.
Правильно ли я понял в чём заключается суть ковариантности? Если нет подскажите ресурс (можно и на английском) где можно почитать об этом более подробно. Заранее спасибо

Comments

[Elmo Sputterspark]

Дай угадаю, ты Блоха выбрал в качестве первого учебника? А ничего, что он не для начинающих?

Answer 1

[Mercury13]

Ковариантность начинается, когда мы делаем class BuildCircle extends BuildShape.
(Лучше BuildShape оформить как интерфейс, а не как класс, но шут с ним.)

Ковариантность связана с принципом подстановки Лисков: чтобы потомок вписывался в контракт, установленный предком, он может ужесточать требования к себе (скажем, выдавать более узкий тип) и ослаблять требования к другим (скажем, принимать поток реального времени вроде консоли/сокета — а не только файл, который знает себе длину и позволяет перемотку).

Вот это «выдавать более узкий тип, чем полагает предок» — и есть ковариантность.

Обратное — принимать поток реального времени, а не только файл — называется контравариантность. Насколько мне известно, в Java на уровне языка её нет, но какие-то части ухитряются делать через шаблоны.

Comments

[zaorduu]

спасибо за объяснение!

[Alex K.]

Ковариантность - сохранение иерархии наследования исходных типов в производных типах.
Контравариантность - обращение иерархии наследования исходных типов на противоположную в производных типах.
Инвариантность - отсутствие наследования между производными типами.

Массивы в Java ковариантны с самой первой версии: в переменную типа Object[] можно положить значение типа String[].

Тип возвращаемого значения метода ковариантен начиная с Java 5.

interface A {
    Number someMethod();
}

class B implements A {
    @Override
    Integer someMethod() { return 42; } // OK
}

В той же версии Java были реализованы обобщения (дженерики). Они инвариантны, но позволяют получить ковариантность и контравариантность с помощью шаблонов. Контравариантность нельзя получить (потому что не имеет смысла) для тип-параметра возвращаемого значения метода, как упоминал выше, а также для тип-параметра класса.

ArrayList<Number> list = new ArrayList<Integer>(); // Ошибка компиляции. Инвариантность.
ArrayList<? extends Number> list = new ArrayList<Integer>(); // OK. Ковариантность.
ArrayList<? super Integer> list = new ArrayList<Number>(); // OK. Контравариантность.

P.S.:

Насколько мне известно, в Java на уровне языка её нет, но какие-то части ухитряются делать через шаблоны.

Если посредством шаблонов (generics) не считается — тогда, насколько мне известно, ни в одном популярном языке её нет. :)

[zaorduu]

Alex, спасибо за подробное объяснение, действительно стало гораздо понятнее