Java: руководство для начинающих

Шилдт Герберт

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. Приведенную выше форму объявления экземпляра класса можно обобщить. Для выведения типов служит следующая общая синтаксическая форма объявления обобщенной ссылки и создания экземпляра объекта обобщенного типа:

class-namе<аргументытипа> имяпеременной = new class-name< >(аргументы_конструктора) ; Здесь список аргументов типа в операторе new указывается пустым. В операторах объявления выведение типов может, как правило, применяться и при передаче параметров. Так, если объявить в классе TwoGen следующий метод:

boolean isSame(TwoGen о) { if(obi == о.obi && ob2 == o.ob2) return true; else return false; } то приведенный ниже вызов окажется вполне допустимым в версии JDK 7.

if(tgOb.isSame(new TwoGen<>(42, "testing"))) System.out.println("Same"); В данном случае опускаются аргументы типа, которые должны передаваться методу isSame . Их типы могут быть выведены автоматически, а следовательно, указывать их еще раз не нужно. Ромбовидный оператор является новым языковым средством в версии JDK 7, но непригодным для компиляции кода, написанного в предыдущих версиях Java. Поэтому в примерах программ, приведенных далее в этой книге, будет использоваться прежний несокращенный синтаксис объявления экземпляров обобщенных классов, чтобы эти программы можно было скомпилировать любым компилятором Java, поддерживающим обобщения. Кроме того, несокращенный синтаксис объявления экземпляров обобщенных классов яснее дает понять, что именно создается, и благодаря этому представленные в книге примеры становятся более наглядными и полезными. Разумеется, в своих программах на Java вы вольны пользоваться синтаксисом выведения типов, чтобы упростить их объявления. ## Стирание Как правило, программирующему на Java совсем не обязательно знать во всех подробностях, каким образом компилятор преобразует исходный код программы в объект- ный. Но что касается обобщенных типов, то важно иметь хотя бы общее представление о процессе их преобразования. Это помогает лучше понять, почему обобщенные классы и методы действуют именно так, а не иначе, и почему их поведение порой ставит в тупик непосвященных. Поэтому

ниже поясняется вкратце, каким образом обобщенные типы реализуются в Java. При внедрении обобщенных типов в Java пришлось учитывать следующее важное условие, накладывавшее определенные ограничения на их реализацию: совместимость с предыдущими версиями Java. Иными словами, обобщенный код должен был быть совместим с предыдущими версиями кода, на момент написания которого обобщенные типы еще не были доступны. Таким образом, любые изменения в синтаксисе языка Java или механизме JVM не должны были оказывать влияние на уже существующий код. Поэтому для реализации обобщенных типов с учетом указанных ограничений был выбран механизм, получивший название стирание. Механизм стирания действует следующим образом. При компиляции кода, написанного на Java, все сведения об обобщенных типах удаляются, т.е. стираются. Это означает, что параметры типа заменяются верхними границами их типа, а если границы не указаны, то их функции выполняет класс Object. После этого производится приведение типов, определяемых аргументами типа. Подобная совместимость типов соблюдается компилятором. Благодаря такому подходу к реализации обобщений параметры типа при выполнении программы вообще отсутствуют, но действуют только на стадии компиляции исходного кода. ## Ошибки неоднозначности Появление обобщенных типов стало причиной возникновения новой разновидности ошибок, связанных с неоднозначностью. Ошибки неоднозначности возникают в тех случаях, когда в результате стирания два, на первый взгляд, отличающихся объявления обобщенных типов преобразуются в один тип, вызывая тем самым конфликтную ситуацию. Рассмотрим пример, в котором используется перегрузка методов.

// Неоднозначность, вызванная стиранием перегруженных методов, class MyGenClass { Т obi; V ob2; // ... // Два следующих метода конфликтуют друг с другом, // поэтому код не компилируется. // Эти методы существенно неоднозначны. void set(T о) { obi = о; } void set(V о) { ob2 = о; }

} В классе MyGenClass объявлены два обобщенных типа: Т и V. В этом классе предпринимается попытка перегрузить метод set . Перегружаемые методы отличаются параметрами типа т и V. Казалось бы, это не должно приводить к ошибке, поскольку типы Т и V отличаются. Но здесь возникают два затруднения в связи с неоднозначностью. Прежде всего, в классе MyGenClass не указано никаких требований, чтобы типы Т и V действительно отличались. В частности, не является принципиальной ошибкой создание объекта типа MyGenClass так, как показано ниже.

MyGenClass obj = new MyGenClass В данном случае типы Т и V заменяются типом String. В результате оба варианта метода set становятся совершенно одинаковыми, что, безусловно, считается ошибкой. Второе, более серьезное затруднение возникает в связи с тем, что при стирании обобщенных типов оба варианта метода set преобразуются в следующий вид:

void set(Object о) { // ... Таким образом, попытка перегрузить метод set в классе MyGenClass является существенно неоднозначной. В качестве выхода из этого затруднительного положения может стать отказ от перегрузки и использование двух разных имен методов. ## Ограничения, накладываемые на обобщения На обобщения накладывается ряд ограничений, которые следует учитывать при их употреблении в программах на Java. К числу подобных ограничений относится создание объектов, определяемых параметром типа, использование статических членов класса, генерирование исключений и обращение с массивами. Рассмотрим все эти ограничения более подробно. ### Невозможность получить экземпляры параметров типа Экземпляр параметра типа получить невозможно. Рассмотрим в качестве примера следующий класс:

// Экземпляр типа Т получить нельзя, class Gen { Т ob; Gen { ob = new T; // Недопустимо!!! } } В данном примере любая попытка получить экземпляр типа т приводит к ошибке. Ее причину понять нетрудно: компилятору ничего не известно о типе создаваемого объекта, поскольку тип Т является заполнителем, который стирается во время компиляции. ### Ограничения, накладываемые на статические члены класса В статических членах нельзя использовать параметры типа, объявленные в содержащем их классе. Так, все объявления статических членов в приведенном ниже классе недопустимы.

class Wrong { // Статическую переменную типа Т создать нельзя, static Т ob; // В статическом методе нельзя использовать тип Т. static Т getob { return ob; } // Статический метод не может обращаться к объекту типа Т. static void showob { System.out.println(ob); }

} Несмотря на наличие описанного выше ограничения, допускается все же объявлять обобщенные статические методы, в которых используются собственные параметры типа. Примеры таких объявлений приводились ранее в этой главе. ### Ограничения, накладываемые на обобщенные массивы На массивы обобщенного типа накладываются два существенных ограничения. Во- первых, нельзя получить экземпляр массива, тип элементов которого определяется параметром типа. И во-вторых, нельзя создать массив обобщенных ссылок на объекты конкретного типа. Оба эти ограничения демонстрируются в приведенном ниже кратком примере программы.