Статический импорт в Java
// Java-программа для иллюстрации
// вызов предопределенных методов
// без статического импорта
public static void main(String[] args)
// Java-программа для иллюстрации
// вызов предопределенных методов
// со статическим импортом
import static java.lang.Math.*;
public static void main(String[] args)
// Java для иллюстрации вызова статического члена
// Системный класс без имени класса
import static java.lang.Math.*;
import static java.lang.System.*;
public static void main(String[] args)
// Мы вызываем статический член класса System
// напрямую без имени класса System
ПРИМЕЧАНИЕ. System — это класс, представленный в пакете java.lang, а out — статическая переменная, присутствующая в классе System. С помощью статического импорта мы вызываем его без имени класса.
Неоднозначность в статическом импорте
Если два статических члена с одним и тем же именем импортируются из нескольких разных классов, компилятор выдаст ошибку, так как он не сможет определить, какой член использовать при отсутствии квалификации имени класса.
// Java-программа для иллюстрации
// двусмысленность в случае
// статический импорт
import static java.lang.Integer.*;
import static java.lang.Byte.*;
public static void main(String[] args)
ПРИМЕЧАНИЕ: два пакета содержат два класса / интерфейса с одинаковыми именами очень редко. Поэтому очень редко мы получаем какую-либо двусмысленность при импорте обычным способом, то есть при обычном импорте. Но возможно, что два класса содержат одну и ту же переменную, поэтому при статическом импорте очень часто можно получить ошибку, говоря, что ссылка неоднозначна. Вот почему его не рекомендуется использовать, если такого требования нет.
Разница между импортом и статическим импортом
Блог только про Java
Учимся программировать на Java с нуля
Статический импорт в языке Java
В Java имеется языковое средство, расширяющее возможности ключевого слова import и называемое статическим импортом.
Оператор import, предваряемый ключевым словом static, можно применять для импорта статических членовькласса или интерфейса. Благодаря статическому импорту появляется возможность ссылаться на статические члены непосредственно по именам, не угочняя ихименем класса.
Это упрощает и сокращает синтаксис, требующийся для работы со статическими членами.
Чтобы стала понятнее польза от статического импорта, начнем с примера, в котором он не используется. В приведенной ниже программе вычисляется гипотенуза прямоугольного треугольника. С этой целью вызываются два статических метода из встроенного в java класса Math, входящего в пакет java.lang.
Как показывает данный простой пример, очень неудобно указывать каждый раз имя класса при вызове методов pow() и sqrt() или любых других встроенныхв Java методов, выполняющих математические операции наподобие sin(), cos() и tan().
У популярного хостинга Eurobyte.ru есть свой API для Java где предоставляется класс, которого можно импортировать с помощью статического импорта. Подробнее сможете узнать на www.eurobyte.ru/services/license/bitrix_expert/, доступна детальная документация.
Подобных неудобств можно избежать, если воспользоваться статическим импортом, как показано в приведенной ниже версии программы из предыдущего примера
В этой версии программы имена методов sqrt() и pow() становятся видимыми благодаря оператору статического импорта, как показано ниже.
После этих операторов больше нет нужды уточнять имена методов pow() и sqrt() именем их класса. Таким образом, вычисление гипотенузы может быть выражено более удобным способом, как показано ниже.
Как видите, эта форма нетолько упрощает код, но и делает его более удобочитаемым:
Имеются две основные формы оператора import static. Первая форма, употреблявшаяся в предыдущем примере программы, делает видимым единственное имя. В общем виде эта форма статического импорта такова:
Вторая форма статического импорта позволяет импортировать все статические члены данного класса или интерфейса. В общем виде эта форма выглядит следующим образом:
Если предполагается применять много статических методов или полей, определенных в классе, то эта форма позволяет сделать их доступными, не указывая каждый из них в отдельности.
Так, в предыдущем примере программы с помощью единственного оператора import можно сделать доступными методы pow() и sqrt(), а также все осталъные статические члены класса Math, как показано ниже.
На данный момент в сегменте информационных технологии, почти каждый сервис предоставляет свой API через которого можно взаимодействовать с сервисом на прикладном уровне.
Разумеется, статический импорт не ограничивается только классом Math или его методами. Например, в следующей строке становится доступным статическое поле System.out.
После этого оператора данные можно выводить на консоль, не уточняя стандартный поток вывода out именем его класса System, как показано ниже.
Тем не менее приведенный выше способ импорта стандартного потока вывода System.оut столь же удобен, сколь и полемичен.
Несмотря на то что такой способ сокращает исходный текст программы, тем, кто его читает, не вполне очевидно, что out обозначает System.out.
Следует также иметь в виду, что, помимо импорта статических членов классов и интерфейсов, определенных в прикладном программном интерфейсе Jаva API, импортировать статическим способом можно так-же статические члены своих собственных классов и интерфейсов.
Каким бы удобным ни был статический импорт, очень важно не злоупотреблять им. Не следует забывать, что библиотечные классы Java объединяются в пакеты для того, чтобы избежать конфликтов пространств имен и непреднамеренного сокрытия прочих имен.
Если статический член используется в прикладной программе только один или два раза, то его лучше не импортировать. К тому-же некоторые статические имена, как, например, System.out, настолько привычны и узнаваемы, что их вряд ли стоит вообще импортировать.
Статический импорт следует оставить на тот случай, если статические члены применяются многократно, как, например, при выполнении целого ряда математических вычислений.
В сущности, этим языковым средством стоит пользоваться, но только не злоупотреблять им.
Интересное видео по теме:
stokito on software
Эта статья была размещена на сайте sun.ru, но позже она стала недоступной. Я её вытащил из кеша поисковика и сохранил на всякий случай здесь.
Аккуратное и правильное использование import static улучшит читаемость вашего кода.
Статический импорт
Для того чтобы получить доступ к статическим членам классов, требуются указать ссылку на класс. К примеру, необходимо указать имя класса Math:
Чтобы обойти это, иногда добавляют статические методы в интерфейс и наследуются от этого интерфейса. Это плохая идея. Фактически это настолько плохая идея, что для нее есть свое название: Constant Interface Antipattern (см. Effective Java, 17 статья). Дело в том, что использование статических членов класса другим классом всего лишь деталь реализации. Когда же класс реализует интерфейс, его члены становится частью публичного АРI этого класса. Детали реализации не должны становиться публичным программным интерфейсом.
Конструкция статического импорта позволяет получить прямой доступ к статическим членам без необходимости наследования от того типа, который содержит эти статические члены. Вместо этого, программа импортирует члены индивидуально:
Однажды импортированный статический член может быть использован без указания имени класса:
Объявление статического импорта аналогично объявлению обычного импорта. При объявлении обычного импорта классы импортируются из пакетов, что позволяет их использовать без указания имени пакета перед именем класса. При объявлении статического импорта статические члены импортируются из классов, что позволяет им быть использованными без указания имени содержащего их класса.
Так когда же следует использовать статический импорт? Только в некоторых случаях! Используйте его только, если иначе вы вынуждены объявлять локальные копии констант или при неправильном использовании наследования (Constant Interface Antipattern).
Другими словами, использование его оправданно, когда требуется постоянное использование статических членов одного класса из одного или двух других классов.
Чрезмерное использование статического импорта может сделать вашу программу нечитаемой и тяжелой в поддержке ввиду того, что пространство имен увеличится из-за всех статических членов из вашего импорта. Тот, кто будет читать ваш код (включая вас, спустя несколько месяцев после написания кода) не будут знать какому из статически импортированных классов принадлежит тот или иной член. Импортирование всех статических методов из класса может быть частично вредно для читабельности; если вы нуждаетесь только в одном или двух методах, импортируйте их по-отдельности. Использованный умело, статический импорт может сделать вашу программу более наглядной, исключая из программного кода ненужные повторения имен классов.
Перевод Комарова Е., Дмитриев А., 24.12.2007 г.
Читайте также моё объяснение для начинающих программистов Константы, перечисления (enum), и static import’ы в Java.
Не поленитесь, и почитайте ещё несколько очень важных моих статей для начинающих программистов, студентов и джуниоров.
Также не забудьте вступить в группу IT Juniors куда я пытаюсь собирать ссылки на другие полезные статьи для вас и анонсы курсов и интернатуры в компаниях. 
Статический импорт
В J2SE 5 появилось новое средство Java — статический импорт, что расширяет возможности ключевого слова import, import с предшествующим ключевым словом static может применяться для импорта статических членов класса или интерфейса. При использовании статического импорта появляется возможность ссылаться на статические члены непосредственно по именам, без необходимости квалифицировать их именем класса. Это упрощает и сокращает синтаксис, необходимый для работы со статическими членами.
Чтобы понять удобство статического импорта, давайте начнем с примера, который не использует его. Следующая программа вычисляет гипотенузу прямоугольного треугольника. Она использует два статических метода из встроенного Java-класса Math, входящего в пакет java.lang. Первый из них — Math.pow() — возвращает значение, возведенное в указанную степень. Второй — Math.sqrt () — возвращает квадратный корень аргумента.
Поскольку pow () и sqrt () — статические методы, они должны быть вызваны с указанием имени их класса — Math. Это приводит к следующему громоздкому вычислению гипотенузы:
hypot = Math.sqrt(Math.pow(sidel, 2) + Math.pow(side2, 2));
Как иллюстрирует этот простой пример, необходимость каждый раз специфицировать имя класса при вызовах pow () и sqrt () (или любых других математических методов Java вроде sin (), cos () и tan ()) довольно утомительно.
Вы можете избежать утомительного повторения имени пакета благодаря применению статического импорта, как показано в следующей версии предыдущей программы:
// Применение статического импорта, делающего sqrt() и pow () видимыми.
import static Java.lang.Math.sqrt;
import static Java.lang.Math.pow;
// Вычисление гипотенузы прямоугольного треугольника.
class Hypot <
public static void main(String args[]) <
double sidel, side2;
double hypot;
sidel = 3.0;
side2 = 4.0;
// Здесь sqrt() npow() можно вызывать
// непосредственно, без их имени класса.
hypot = sqrt(pow(sidel, 2) + pow(side2, 2));
System.out.println(«Даны длины сторон » + sidel + » и » + side2 + » гипотенуза равна » + hypot) ;
>
>
В этой версии имена sqrt и pow становятся видимыми благодаря оператору статического импорта:
import static java.lang.Math.sqrt;
import static java.lang.Math.pow;
После этих операторов больше нет необходимости квалифицировать pow () и sqrt () именем их класса. Таким образом, вычисление гипотенузы может быть выражено более удобно:
hypot = sqrt(pow(sidel, 2) + pow(side2, 2));
Как видите, эта форма и более читабельна.
Существуют две основных формы оператора import static. Первая, которая использовалась в предыдущем примере, делает видимым единственное имя. Его общая форма такова:
import static pkg.type-name.static-member-name;
Здесь type-name — имя класса или интерфейса, который содержит требуемый статический член. Полное имя его пакета указано в ркд, а имя члена — в static-member-name.
Вторая форма статического импорта позволяет импортировать все статические члены данного класса или интерфейса. Его общая форма показана ниже.
import static pkg.type-name.*;
Если вы будете использовать много статических методов или полей, определенных в классе, то эта форма позволит вам сделать их видимыми без необходимости специфицировать каждый отдельно. Таким образом, в предыдущей программе с помощью единственного оператора import можно ввести в область видимости pow () и sqrt () (а также все другие статические члены Math):
import static java.lang.Math.*;
Конечно же, статический импорт не ограничивается только классом Math или его методами. Например, следующая строка вводит в область видимости статическое поле System.out:
import static java.lang.System.out;
После этого оператора вы можете выводить информацию на консоль потоком out, не квалифицируя его System, как показано здесь:
out.println(«Импортировав System.out, вы можете использовать его непосредственно.»);
Однако импортировать System, out, как показано выше — это не только хорошая идея, но и предмет обсуждения. Несмотря на то что это сокращает текст программы, все же теперь не будет очевидно тем, кто читает программу, что out ссылается на System.out.
Еще один момент: в дополнение к импорту статических членов классов и интерфейсов, определенных в Java API, вы можете также использовать статический импорт для импортирования статических членов ваших собственных классов и интерфейсов.
Каким бы удобным ни показался статический импорт, важно не злоупотреблять им. Помните, что причина того, что библиотечные классы Java объединены в пакеты, состоит в том, чтобы избежать конфликтов пространств имен и для непреднамеренного сокрытия прочих имен. Если вы используете в своей программе статический член однажды или дважды, лучше его не импортировать. К тому же некоторые статические имена, как, например System.out, настолько привычны и узнаваемы, что, вероятно, вы вообще не захотите импортировать их.
Статический импорт предназначен для тех ситуаций, когда вы применяете статические члены многократно, как, например, при выполнении серии математических вычислений. То есть, в сущности, вам стоит использовать это средство, но не злоупотреблять им.
Ключевые слова static и final
Это занятие начнем с рассмотрения довольно значимой конструкции ООП – статических полей и методов класса. Возможно, вы уже обращали внимание, на ключевое слово static перед функцией main:
Сейчас мы разберемся, что оно означает. В любом классе при объявлении переменных можно перед их типами прописывать это ключевое слово, например, так:
Спрашивается: в чем отличие между полями x, y и статическим полем cnt? Лучше всего это продемонстрировать на следующем рисунке.
Когда создаются объекты класса Point:
то в каждый из них будут помещены копии полей x, y, но поле cnt скопировано не будет, оно останется на уровне класса Point и станет общим для всех экземпляров этого класса. То есть, при обращении к статической переменной cnt из любого экземпляра класса, например, вот так:
Мы при создании нового объекта в конструкторе будем увеличивать общую для всех экземпляров переменную cnt на единицу. И, так как эта переменная общая, то при создании двух объектов этот счетчик будет равен двум. В этом можно убедиться, если вывести его значение в консоль:
Обратите внимание, мы обращаемся к статическому полю cnt напрямую через класс Point, т.к. оно хранится непосредственно в нем. То же самое будет, если обратиться к этой переменной через ссылку pt1:
Мы здесь обращаемся к той же самой статической переменной cnt. Думаю, этот момент с общим полем понятен, давайте теперь выполним его начальную инициализацию. Для обычных переменных мы использовали инициализатор в виде фигурных скобок. Статические тоже можно помещать в этот блок, но тогда они будут инициализироваться заново каждый раз при создании нового объекта:
Если выполнить программу, то в консоли вместо двух увидим 1, так как наш счетчик cnt обнуляется каждый раз при создании нового объекта. Вместе с тем, логика статических полей подразумевает их одноразовую инициализацию. Это можно сделать двумя способами. В первом, самом простом, мы присваиваем начальное значение сразу в момент объявления статической переменной:
Второй способ подразумевает использование статического инициализатора:
Такой инициализатор срабатывает только один раз в момент создания класса Point в памяти устройства и используется исключительно для статических полей и методов класса.
Вот так ведут себя статические переменные. Чтобы лучше понять логику их функционирования, отмечу, что ключевое слово static указывает компилятору создавать переменную один раз в процессе работы программы в определенной области памяти и не перемещать ее куда бы то ни было (в другую область памяти), в том числе не создавать ее копии. Поэтому, статическая переменная объявленная в классе Point создается внутри него и не переходит в экземпляры этого класса, а остается общей для всех.
Статические методы
Похожим образом ведут себя и статические методы классов: они принадлежат непосредственно классу и не дублируются в его экземпляры. Давайте для примера добавим статический метод в класс Point:
Мы здесь сделали поле cnt приватным, а доступ к нему – через геттер getCounter. И обратите внимание в какой последовательности записываются модификаторы доступа, слово static и тип поля или метода:
Соответственно, в функции main мы теперь должны прописать этот геттер вместо прямого обращения к cnt:
В итоге картина расположения статических и нестатических полей будет следующей:
Здесь статический метод getCounter() общий для всех экземпляров класса Point. Фактически, он принадлежит только классу Point, но также может вызываться из его объектов. Именно поэтому, мы можем обращаться к нему непосредственно через класс Point, используя конструкцию:
Так можно делать с любыми статическими методами и полями класса. Но статичность налагает и определенные ограничения. В частности, метод getCounter() может получать доступ к статической переменной cnt, но не может работать с динамическими полями x, y. Действительно, если написать что-то вроде:
то возникнет ошибка, так как статический метод на уровне класса просто «не видит» переменные x, y в экземплярах. Все что ему доступно – это другие статические методы и поля класса Point. То есть, из статических методов можно вызывать только другие статические методы и обращаться исключительно к статическим переменным. Или же, создавать объекты и переменные непосредственно внутри статического метода:
Отчасти это мы делаем в статическом методе main().
Статический импорт
Наконец, есть еще такое понятие как статический импорт. Что это такое? Все достаточно просто. Если в пакете имеются классы со статическими элементами, например, в пакете System мы обращаемся к классу out со статическим методом println(), то простой импорт:
не импортирует такой класс, только классы без статических данных. А вот если добавить ключевое слово static:
то получим статический импорт и класс out появится в нашем текущем модуле.
Вот так работают и используются статические переменные и методы классов.
Ключевое слово final
В заключении этого занятия я расскажу об еще одном ключевом слове final. Оно позволяет задавать константы в языке Java. Например, если у поля cnt добавить это ключевое слово, то дальнейшее изменение переменной cnt станет невозможным:
Опять же, обратите внимание на очередность ключевых слов. Конечно, это странный пример, поэтому давайте оставим переменную cnt как обычную статическую, а в класс Point добавим еще одно поле с указанием final:
Теперь, переменная MAX_COORD является константой и не может быть изменена. Мало того, мы должны таким переменным сразу присваивать определенное значение, то есть, записывать их вот так нельзя:
Ключевое слово final можно использовать и у методов. Но особенность их поведения будет проявляться только в момент наследования. Поэтому я буду говорить об этом в теме наследования классов.
Подвиг 1. Объявите класс ShopItem для представления продуктов в магазине с полями: id (идентификатор – целое число), название товара, габариты, вес, цена. Поле id должно быть уникальным для каждого объекта класса. Это следует реализовать через статическую переменную, которая подсчитывает количество создаваемых экземпляров.
Подвиг 2. Реализовать класс Rect для описания прямоугольника с полями: x1, y1, x2, y2 – координат вершин верхнего правого и нижнего левого углов. Прописать два статических метода для вычисления ширины и высоты прямоугольника. В качестве параметра этим методам передавать ссылку на экземпляр класса Rect, для которого выполняется вычисление.
Подвиг 3. Реализовать класс Singleton, в котором определить статический метод getInstance(). Этот метод должен возвращать экземпляр класса, если он еще не создавался. Иначе, возвращается ссылка на ранее созданный экземпляр. Также следует запретить создание объектов класса Singleton напрямую через оператор new. (Полученная реализация будет гарантировать существование только одного экземпляра класса в процессе работы программы и, фактически, является примером известного паттерна singleton).
Видео по теме
#11 Концепция объектно-ориентированного программирования (ООП)
#12 Классы и создание объектов классов
#13 Конструкторы, ключевое слово this, инициализаторы
#14 Методы класса, сеттеры и геттеры, public, private, protected
#15 Пакеты, модификаторы конструкторов и классов
#16 Ключевые слова static и final
#17 Внутренние и вложенные классы
#18 Как делается наследование классов
#19 Ключевое слово super, оператор instanceof
#20 Модификаторы private и protected, переопределение методов, полиморфизм
#21 Абстрактные классы и методы
#24 Анонимные внутренние классы
#25 Перечисления (enum)
#26 Обобщения классов (Generics)
#27 Ограничения типов, метасимвольные аргументы, обобщенные методы и конструкторы
#28 Обобщенные интерфейсы, наследование обобщенных классов
© 2021 Частичное или полное копирование информации с данного сайта для распространения на других ресурсах, в том числе и бумажных, строго запрещено. Все тексты и изображения являются собственностью сайта
