Мне интересно, есть ли какая-либо разница во времени выполнения между универсальным контейнером, реализованным с использованием языковых функций для обобщений, представленных Java 1.5, по сравнению с выполнением этого с помощью только наследования и явных типов типов.И если есть, то это дало бы наивысшую производительность.
Если быть точным, допустим, у меня есть базовый класс и подкласс:
public class Base { }
public class Sub extends Base { }
И я определяю тип контейнера в терминахбазового класса.Тогда меня интересует то, что происходит, когда известно, что экземпляр контейнера содержит определенный подкласс.До версии 1.5 у меня не было иного выбора, кроме как реализовать контейнер, подобный этому (не говоря уже о том, что он слишком упрощен, чтобы иметь смысл):
public class OldstyleContainer {
private Base x;
public void set(Base x) { this.x = x; }
public Base get() { return x; }
}
И использование класса, в котором конкретный тип известногоИзвестно, что элемент может выглядеть следующим образом:
public Sub oldstylePut(OldstyleContainer c, Sub s) {
Sub t = (Sub) c.get();
c.set(s);
return t;
}
Теперь, имея языковые возможности для дженериков, я бы вместо этого определил контейнер следующим образом:
public class GenericsContainer<T extends Base> {
private T x;
public void set(T x) { this.x = x; }
public T get() { return x; }
}
И соответствующее использование будетнапример:
public Sub genericsPut(GenericsContainer<Sub> c, Sub s) {
Sub t = c.get();
c.set(s);
return t;
}
Общий код версии выглядит (очень) немного проще, потому что нет необходимости в явном приведении.Но мой вопрос: есть ли реальная разница во время выполнения , или это преобразование все еще существует в байт-коде?Есть ли другая разница?