} У этой программы имеется ряд интересных особенностей. Прежде всего, базовый тип обобщенного класса Gen создается в следующем объявлении:

Gen raw = new Gen(new Double(98.6)); В данном случае аргументы типа не указываются. В итоге создается объект класса Gen, тип Т которого замещается типом Object. Базовые типы не обеспечивают типовую безопасность. Переменной базового типа может быть присвоена ссылка на любой тип объекта класса Gen. Справедливо и обратное: переменной конкретного типа из класса Gen может быть присвоена ссылка на объект класса Gen базового типа. Обе операции потенциально опасны, поскольку они действуют в обход механизма проверки типов, обязательной для обобщений. Недостаточный уровень типовой безопасности демонстрируют примеры в закомментированных строках кода в конце данной программы. Рассмотрим их по отдельности. Сначала проанализируем следующую строку кода:

// int i = (Integer) raw.getobO; В этом операторе присваивания в объекте raw определяется значение переменной ob, которое приводится к типу Integer. Но дело в том, что в объекте raw содержится не целое число, а значение типа Double. На стадии компиляции этот факт выявить невозможно, поскольку тип объекта raw неизвестен. Следовательно, ошибка возникнет на стадии выполнения программы. В следующих строках кода ссылка на объект класса Gen базового типа присваивается переменной strOb (ссылки на объект типа Gen<String>).

strOb = raw; // Допустимо, но потенциально ошибочно. // String str = strOb.getob; // Ошибка при выполнении программы. Само по себе присваивание синтаксически правильно, но логически сомнительно. Переменная strOb ссылается на объект типа Gen<String>, а следовательно, она должна содержать ссылку на объект, содержащий значение типа String, но после присваивания объект, на который ссылается переменная strOb, содержит значение типа Double. Поэтому при выполнении программы, когда предпринимается попытка присвоить переменной str содержимое объекта, на который ссылается переменная strOb, возникает ошибка. А причина ее заключается в том, что переменная strOb ссылается в этот момент на объект, содержащий значение типа Double. Таким образом, присваивание ссылки на объект базового типа переменной ссылки на объект обобщенного типа делается в обход механизма типовой безопасности. В следующих строках кода демонстрируется ситуация, обратная предыдущей:

raw = iOb; // Допустимо, но потенциально ошибочно. // d = (Double) raw.getobO; // Ошибка при выполнении программы. В данном случае ссылка на объект обобщенного типа присваивается переменной базового типа. И это присваивание синтаксически правильно, но приводит к ошибке, возникающей во второй строке кода. В частности, переменная raw указывает на объект, содержащий значение типа Integer, но при приведении типов предполагается, что он содержит значение типа Double. И эту ошибку также нельзя выявить на стадии компиляции, а проявляется она при выполнении программы. В связи с тем что использование базовых типов сопряжено с потенциальными ошибками, проявляющимися при выполнении программы, компилятор javac выводит в подобных случаях сообщения, предупреждающие об отсутствии проверки типов, когда базовый тип используется в обход механизма типовой безопасности. Такие сообщения будут получены и при компиляции рассматриваемой здесь программы. Причиной их появления станут следующие строки кода:

Gen raw = new Gen(new Double(98.6));

strOb = raw; // Допустимо, но потенциально ошибочно. В первой из этих строк кода содержится обращение к конструктору класса Gen без указания аргумента типа, что приводит к выдаче компилятором соответствующего предупреждения. А при компиляции второй строки предупреждающее сообщение возникнет из-за попытки присвоить переменной, ссылающейся на объект обобщенного типа, ссылки на объект базового типа. На первый взгляд может показаться, что предупреждение об отсутствии проверки типов может вызвать и приведенная ниже строка кода, но этого не произойдет,

raw = iOb; // Допустимо, но потенциально ошибочно. В этом случае компилятор не предупреждает пользователя, потому что такое присваивание не приводит к еще большей потере типовой безопасности по сравнению с той, которая произошла при создании переменной raw базового типа. Из всего изложенного выше можно сделать следующий вывод: пользоваться базовыми типами следует весьма ограниченно и только в тех случаях, когда устаревший код требуется объединить с новым, обобщенным кодом. Базовые типы — лишь средство для обеспечения совместимости с устаревшим кодом. Они не должны присутствовать во вновь разрабатываемом коде. ## Выводимость типов с помощью ромбовидного оператора Начиная с версии JDK 7 появилась возможность сократить синтаксис, применяемый для создания экземпляра обобщенного типа. В качестве примера обратимся к классу TwoGen, представленному в начале этой главы. Ниже для удобства приведена часть его объявления. Обратите внимание на то, что в нем определяются два обобщенных типа данных.

class TwoGencT, V> { Т obi; V ob2; // передать конструктору ссылку на объект типа Т. TwoGen(Т о1, V о2) { obi = ol; оb2 = о2; } // ... } До появления версии JDK 7 для создания экземпляра класса TwoGen приходилось прибегать к оператору присваивания, аналогичному приведенному ниже.

TwoGen tgOb = new TwoGencinteger, String>(42, "testing"); Здесь аргументы типа (в данном случае — Integer и String) указываются дважды: сначала при объявлении переменной tgOb, а затем при создании экземпляра класса TwoGen с помощью оператора new. Начиная с версии JDK 5, в которой были внедрены обобщения, подобная форма создания объектов обобщенного типа требовалась при написании всех программ на Java, вплоть до появления версии JDK 7. И хотя в этой форме, по существу, нет ничего ошибочного, все же она выглядит несколько многословной. Ведь в операторе new типы аргументов могут быть выведены без особого, труда, и поэтому нет никаких оснований указывать их еще раз. И для этой цели в версии JDK 7 внедрен специальный синтаксический элемент. В версии JDK 7 приведенное выше объявление может быть переписано следующим образом:

TwoGen tgOb = new TwoGen<>(42, "testing"); Как видите, в той части, где создается экземпляр объекта обобщенного типа, просто указываются угловые скобки (< >), обозначающие пустой список аргументов типа. Это так называемый ромбовидный оператор, предписывающий компилятору вывести типы аргументов, требующиеся конструктору в операторе new. Главное преимущество такого синтаксиса выведения типов состоит в том, что он позволяет сделать более краткими те операторы объявления, которые порой выглядят слишком длинными и громоздкими. Это оказывается особенно удобным для объявления обобщенных типов, определяющих границы наследования в иерархии классов Java. Приведенную выше форму объявления экземпляра класса можно обобщить. Для выведения типов служит следующая общая синтаксическая форма объявления обобщенной ссылки и создания экземпляра объекта обобщенного типа: