Что такое ковариатность массивов?

Ковариантность массивов (Array Covariance)

Ковариантность массивов — это свойство системы типов Java, при котором массив подтипа может присваиваться переменной типа массива супертипа. Это означает, что если класс B наследуется от класса A, то массив B[] можно присвоить переменной типа A[]. Это может привести к ошибкам типизации при выполнении программы.

Основной концепт

public class ArrayCovarianceExample {
    public static void main(String[] args) {
        // Ковариантность: Integer наследует Number
        Number[] numbers = new Integer[]{1, 2, 3}; // ✓ Компилируется
        
        // Это возможно благодаря ковариантности массивов
        // Integer[] является подтипом Number[]
    }
}

Почему ковариантность опасна?

Проблема: ArrayStoreException во время выполнения

public class ArrayStoreExceptionExample {
    public static void main(String[] args) {
        // Создаём массив Integer
        Integer[] integerArray = new Integer[]{1, 2, 3};
        
        // Присваиваем переменной типа Number[]
        Number[] numberArray = integerArray;
        
        // Компилятор позволяет, но...
        // Мы можем добавить Double в массив, якобы Number[]
        try {
            numberArray[0] = 3.14; // ArrayStoreException!
        } catch (ArrayStoreException e) {
            System.out.println("Ошибка: " + e.getMessage());
            // Исключение выбрасывается только во время выполнения
        }
    }
}

Почему это происходит?

public class WhyCovarianceIsProblematic {
    public static void main(String[] args) {
        // Шаг 1: Создаём Integer[]
        Integer[] intArray = new Integer[]{10, 20, 30};
        
        // Шаг 2: Присваиваем Number[] (благодаря ковариантности)
        Number[] numArray = intArray;
        
        // Шаг 3: Синтаксис позволяет добавить Double
        // numArray[0] = 3.14;
        
        // Шаг 4: Runtime проверяет, что это не Integer
        // и выбрасывает ArrayStoreException
        
        // Компилятор не видит проблему, потому что numArray объявлен как Number[]
        // Но реально это Integer[], и он НЕ может хранить Double
    }
}

Как это реализовано в Java

Array Store Check (runtime проверка)

public class ArrayStoreCheckExample {
    public static void main(String[] args) {
        // Java выполняет runtime проверку перед присваиванием
        Object[] objects = new String[]{"Hello", "World"};
        
        // Компилятор видит Object[]
        // Runtime знает, что это String[]
        
        try {
            objects[0] = 42; // ArrayStoreException
        } catch (ArrayStoreException e) {
            System.out.println("Не можешь присвоить Integer в String[]");
        }
        
        // Это дорого в плане производительности:
        // каждое присваивание требует runtime проверки типа
    }
}

Сравнение с Generics (инвариантность)

Generics НЕ ковариантные (инвариантные)

import java.util.ArrayList;
import java.util.List;

public class GenericsInvarianceExample {
    public static void main(String[] args) {
        // Генерики ИНВАРИАНТНЫ (противоположность ковариантности)
        
        List<Integer> intList = new ArrayList<>();
        intList.add(1);
        intList.add(2);
        
        // ❌ Это НЕ компилируется!
        // List<Number> numList = intList; // Compilation ERROR!
        
        // Генерики требуют точного типа, это БЕЗОПАСНЕЕ
        // Но менее гибко
    }
}

Почему генерики инвариантны?

public class WhyGenericsAreInvariant {
    public static void main(String[] args) {
        // Если бы генерики были ковариантны:
        List<Integer> intList = new ArrayList<>();
        List<Number> numList = intList; // Гипотетически
        
        // Этот код был бы опасен:
        numList.add(3.14); // Добавляем Double в List<Integer>
        Integer x = intList.get(0); // ClassCastException!
    }
}

Wildcard типы: Solve ковариантности

1. ? extends T (ковариантность читается)

import java.util.ArrayList;
import java.util.List;

public class WildcardExtendsExample {
    public static void main(String[] args) {
        List<Integer> intList = new ArrayList<>();
        intList.add(1);
        intList.add(2);
        intList.add(3);
        
        // ? extends Number позволяет читать как Number
        List<? extends Number> numList = intList;
        
        // Можно читать
        Number n = numList.get(0); // ✓ OK
        
        // НЕ можно писать (кроме null)
        // numList.add(3.14); // ❌ Compilation ERROR
        // numList.add(null);  // ✓ OK - null is safe
    }
}

2. ? super T (контравариантность для записи)

import java.util.ArrayList;
import java.util.List;

public class WildcardSuperExample {
    public static void main(String[] args) {
        List<Number> numList = new ArrayList<>();
        
        // ? super Integer позволяет писать Integer
        List<? super Integer> intList = numList;
        
        // Можно писать Integer
        intList.add(10);    // ✓ OK
        intList.add(20);    // ✓ OK
        intList.add(null);  // ✓ OK
        
        // НЕ можно читать как Integer
        // Integer x = intList.get(0); // ❌ Compilation ERROR
        // Но можно читать как Object
        Object obj = intList.get(0); // ✓ OK
    }
}

Практический пример: Правильно использовать ковариантность

import java.util.ArrayList;
import java.util.List;

public class CovariancePatternExample {
    // PECS принцип: Producer Extends, Consumer Super
    
    // Producer (читаем из него) -> ? extends T
    public static double sumNumbers(List<? extends Number> numbers) {
        double sum = 0;
        for (Number n : numbers) {
            sum += n.doubleValue();
        }
        return sum;
    }
    
    // Consumer (пишем в него) -> ? super T
    public static void fillNumbers(List<? super Integer> numbers) {
        for (int i = 1; i <= 5; i++) {
            numbers.add(i);
        }
    }
    
    public static void main(String[] args) {
        // Работает с Integer
        List<Integer> intList = new ArrayList<>();
        System.out.println("Sum: " + sumNumbers(intList));
        
        // Работает с Double
        List<Double> doubleList = new ArrayList<>();
        doubleList.add(1.5);
        doubleList.add(2.5);
        System.out.println("Sum: " + sumNumbers(doubleList));
        
        // Работает с Number и подтипами
        List<Number> numList = new ArrayList<>();
        fillNumbers(numList);
        System.out.println("Filled: " + numList);
    }
}

Массивы vs Generics - сравнение ковариантности

public class ArraysVsGenericsComparison {
    public static void main(String[] args) {
        // МАССИВЫ - ковариантны (опасно)
        Number[] numberArray = new Integer[3];
        numberArray[0] = 3.14; // ArrayStoreException во время выполнения
        
        // GENERICS - инвариантны (безопасно)
        // List<Number> numberList = new ArrayList<Integer>(); // ❌ Compilation ERROR
        
        // Но с wildcards можно достичь ковариантности безопасно
        List<? extends Number> numberList = new ArrayList<Integer>();
        // numberList.add(3.14); // ❌ Compilation ERROR - безопасно!
    }
}

Почему Java сделал массивы ковариантными?

// Исторический код (до появления generics)
public class LegacyCodeExample {
    public static void printArray(Object[] array) {
        for (Object obj : array) {
            System.out.println(obj);
        }
    }
    
    public static void main(String[] args) {
        // Это работало до generics
        String[] strings = {"Hello", "World"};
        printArray(strings); // ✓ OK благодаря ковариантности
        
        Integer[] integers = {1, 2, 3};
        printArray(integers); // ✓ OK благодаря ковариантности
    }
}

Лучшие практики

// ✅ ХОРОШО - используй generics вместо массивов
List<Integer> intList = new ArrayList<>();
List<? extends Number> numList = intList; // Безопасно

// ❌ ПЛОХО - избегай присваивания массивов
Integer[] intArray = {1, 2, 3};
Number[] numArray = intArray; // Опасно!

// ✅ ХОРОШО - используй PECS (Producer Extends, Consumer Super)
public <T> void process(List<? extends T> producer, 
                       List<? super T> consumer) {
    // producer - для чтения
    // consumer - для записи
}

// ❌ ПЛОХО - не смешивай типы в массивах
Object[] mixed = new String[10];
mixed[0] = 42; // ArrayStoreException

Ковариантность массивов — это историческое решение Java, которое создаёт потенциальные проблемы. Генерики предоставляют более безопасный способ работы с полиморфизмом типов, используя wildcards для контролируемой ковариантности и контравариантности.