Руководство по пакетам Java
В этом кратком руководстве мы рассмотрим основы пакетов в Java. Мы увидим, как создавать пакеты и получать доступ к типам, которые мы помещаем в них.
Мы также обсудим соглашения об именах и их связь с базовой структурой каталогов.
Наконец, мы скомпилируем и запустим наши упакованные классы Java.
2. Обзор пакетов Java
В Java мы используем пакеты для группировки связанных классов, интерфейсов и подпакетов .
Основными преимуществами этого являются:
- Облегчение поиска связанных типов — пакеты обычно содержат типы, которые логически связаны.
- Избегайте конфликтов имен — пакет поможет нам однозначно идентифицировать класс; например, у нас может быть класс com.foreach.Application, а также классы com.example.Application.
- Управление доступом — мы можем контролировать видимость и доступ к типам, комбинируя пакеты и модификаторы доступа .
Далее давайте посмотрим, как мы можем создавать и использовать пакеты Java.
3. Создание пакета
Чтобы создать пакет, мы должны использовать оператор package , добавив его в качестве самой первой строки кода в файле .
Давайте поместим тип в пакет с именем com.foreach.packages :
package com.foreach.packages; Настоятельно рекомендуется помещать каждый новый тип в упаковку. Если мы определим типы и не поместим их в пакет, они попадут в пакет по умолчанию или безымянный пакет. Использование пакетов по умолчанию имеет несколько недостатков:
- Мы теряем преимущества пакетной структуры и не можем иметь подпакеты.
- Мы не можем импортировать типы в пакете по умолчанию из других пакетов.
- Области доступа protected и package-private были бы бессмысленными .
Как указано в спецификации языка Java , безымянные пакеты предоставляются платформой Java SE главным образом для удобства при разработке небольших или временных приложений или при начале разработки.
Поэтому нам следует избегать использования безымянных пакетов или пакетов по умолчанию в реальных приложениях .
3.1. Соглашения об именах
Чтобы избежать пакетов с одинаковыми именами, мы следуем некоторым соглашениям об именах:
- мы определяем наши имена пакетов в нижнем регистре ****
- имена пакетов разделены точкой
- имена также определяются компанией или организацией, которые их создают
Чтобы определить имя пакета на основе организации, мы обычно начинаем с обращения URL-адреса компании. После этого соглашение об именовании определяется компанией и может включать названия подразделений и названия проектов.
Например, чтобы создать пакет из www.foreach.com , давайте перевернем его:
com.foreach Затем мы можем дополнительно определить его подпакеты, например com.foreach.packages или com.foreach.packages.domain.
3.2. Структура каталогов
Пакеты в Java соответствуют структуре каталогов.
Каждый пакет и подпакет имеет свой собственный каталог. Итак, для пакета com.foreach.packages у нас должна быть структура каталогов com -> foreach -> packages .
Большинство IDE помогут создать эту структуру каталогов на основе имен наших пакетов, поэтому нам не нужно создавать их вручную.
4. Использование членов пакета
Начнем с определения класса TodoItem в подпакете с именем domain :
package com.foreach.packages.domain; public class TodoItem private Long id; private String description; // standard getters and setters > 4.1. Импорт
Чтобы использовать наш класс TodoItem из класса в другом пакете, нам нужно его импортировать. После импорта мы можем получить к нему доступ по имени.
Мы можем импортировать один тип из пакета или использовать звездочку для импорта всех типов в пакете.
Давайте импортируем весь подпакет домена :
import com.foreach.packages.domain.*; Теперь давайте импортируем только класс TodoItem :
import com.foreach.packages.domain.TodoItem; JDK и другие библиотеки Java также поставляются со своими собственными пакетами. Таким же образом мы можем импортировать уже существующие классы, которые мы хотим использовать в нашем проекте.
Например, давайте импортируем базовый интерфейс Java List и класс ArrayList :
import java.util.ArrayList;import java.util.List; Затем мы можем использовать эти типы в нашем приложении, просто используя их имена:
public class TodoList private ListTodoItem> todoItems; public void addTodoItem(TodoItem todoItem) if (todoItems == null) todoItems = new ArrayListTodoItem>(); > todoItems.add(todoItem); > > Здесь мы использовали наши новые классы вместе с базовыми классами Java для создания списка задач .
4.2. Полное имя
Иногда мы можем использовать два класса с одинаковыми именами из разных пакетов. Например, мы можем использовать как java.sql.Date , так и java.util.Date . Когда мы сталкиваемся с конфликтами имен, нам нужно использовать полное имя класса по крайней мере для одного из классов.
Давайте используем TodoItem с полным именем:
public class TodoList private Listcom.foreach.packages.domain.TodoItem> todoItems; public void addTodoItem(com.foreach.packages.domain.TodoItem todoItem) if (todoItems == null) todoItems = new ArrayListcom.foreach.packages.domain.TodoItem>(); >todoItems.add(todoItem); > // standard getters and setters > 5. Компиляция с помощью javac
Когда пришло время компилировать наши упакованные классы, нам нужно помнить нашу структуру каталогов. Начиная с исходной папки, нам нужно указать javac , где найти наши файлы.
Сначала нам нужно скомпилировать наш класс TodoItem , потому что наш класс TodoList зависит от него.
Давайте начнем с открытия командной строки или терминала и перехода в наш исходный каталог.
Теперь давайте скомпилируем наш класс com.foreach.packages.domain.TodoItem :
> javac com/foreach/packages/domain/TodoItem.java Если наш класс компилируется корректно, мы не увидим сообщений об ошибках, а файл TodoItem.class должен появиться в нашем каталоге com/foreach/packages/domain .
Для типов, которые ссылаются на типы в других пакетах, мы должны использовать флаг -classpath , чтобы сообщить команде javac , где найти другие скомпилированные классы.
Теперь, когда наш класс TodoItem скомпилирован, мы можем скомпилировать наши классы TodoList и TodoApp :
>javac -classpath . com/foreach/packages/*.java Опять же, мы не должны видеть никаких сообщений об ошибках, и мы должны найти два файла классов в нашем каталоге com/foreach/packages .
Давайте запустим наше приложение, используя полное имя нашего класса TodoApp :
>java com.foreach.packages.TodoApp Наш вывод должен выглядеть так:
6. Заключение
В этой короткой статье мы узнали, что такое пакеты и почему мы должны их использовать.
Мы обсудили соглашения об именах и то, как пакеты соотносятся со структурой каталогов. Мы также увидели, как создавать и использовать пакеты.
Наконец, мы рассмотрели, как скомпилировать и запустить приложение с пакетами с помощью команд javac и java .
Полный код примера доступен на GitHub .
- 1. Введение
- 2. Обзор пакетов Java
- 3. Создание пакета
- 3.1. Соглашения об именах
- 3.2. Структура каталогов
- 4.1. Импорт
- 4.2. Полное имя
Как создать пакет java
Как правило, в Java классы объединяются в пакеты. Пакеты позволяют организовать классы логически в наборы. По умолчанию java уже имеет ряд встроенных пакетов, например, java.lang , java.util , java.io и т.д. Кроме того, пакеты могут иметь вложенные пакеты.
Организация классов в виде пакетов позволяет избежать конфликта имен между классами. Ведь нередки ситуации, когда разработчики называют свои классы одинаковыми именами. Принадлежность к пакету позволяет гарантировать однозначность имен.
Чтобы указать, что класс принадлежит определенному пакету, надо использовать директиву package , после которой указывается имя пакета:
package название_пакета;
Как правило, названия пакетов соответствуют физической структуре проекта, то есть организации каталогов, в которых находятся файлы с исходным кодом. А путь к файлам внутри проекта соответствует названию пакета этих файлов. Например, если классы принадлежат пакету mypack, то эти классы помещаются в проекте в папку mypack.
Классы необязательно определять в пакеты. Если для класса пакет не определен, то считается, что данный класс находится в пакете по умолчанию, который не имеет имени.
Например, создадим в папке для исходных файлов каталог study . В нем создадим файл Program.java со следующим кодом:
package study; public class Program < public static void main(String[] args) < Person kate = new Person("Kate", 32); kate.displayInfo(); >> class Person < String name; int age; Person(String name, int age)< this.name = name; this.age = age; >void displayInfo() < System.out.printf("Name: %s \t Age: %d \n", name, age); >>Директива package study в начале файла указывает, что классы Program и Person, которые здесь определены, принадлежат пакету study.
Когда мы работаем в среде разработки, например, в Netbeans, то IDE берет на себя все вопросы компиляции пакетов и входящих в них файлов. Соответственно нам достаточно нажать на кнопку, и все будет готово. Однако если мы компилируем программу в командной строке, то мы можем столкнуться с некоторыми трудностями. Поэтому рассмотрим этот аспект.
Для компиляции программы вначале в командной строке/терминале с помощью команды cd перейдем к папке, где находится каталог study.
cd C:\java
Например, в моем случае это каталог C:\java (то есть файл с исходным кодом расположен по пути C:\java\study\Program.java).
Для компиляции выполним команду
javac study\Program.java
После этого в папке study появятся скомпилированные файлы Program.class и Person.class. Для запуска программы выполним команду:
java study.Program
Импорт пакетов и классов
Если нам надо использовать классы из других пакетов, то нам надо подключить эти пакеты и классы. Исключение составляют классы из пакета java.lang (например, String ), которые подключаются в программу автоматически.
Например, знакомый по прошлым темам класс Scanner находится в пакете java.util , поэтому мы можем получить к нему доступ следующим способом:
java.util.Scanner in = new java.util.Scanner(System.in);
То есть мы указываем полный путь к файлу в пакете при создании его объекта. Однако такое нагромождение имен пакетов не всегда удобно, и в качестве альтернативы мы можем импортировать пакеты и классы в проект с помощью директивы import , которая указывается после директивы package:
package study; import java.util.Scanner; // импорт класса Scanner public class Program < public static void main(String[] args) < Scanner in = new Scanner(System.in); >>
Директива import указывается в самом начале кода, после чего идет имя подключаемого класса (в данном случае класса Scanner).
В примере выше мы подключили только один класс, однако пакет java.util содержит еще множество классов. И чтобы не подключать по отдельности каждый класс, мы можем сразу подключить весь пакет:
import java.util.*; // импорт всех классов из пакета java.util
Теперь мы можем использовать любой класс из пакета java.util.
Возможна ситуация, когда мы используем два класса с одним и тем же названием из двух разных пакетов, например, класс Date имеется и в пакете java.util , и в пакете java.sql . И если нам надо одновременно использовать два этих класса, то необходимо указывать полный путь к этим классам в пакете:
java.util.Date utilDate = new java.util.Date(); java.sql.Date sqlDate = new java.sql.Date();
Статический импорт
В java есть также особая форма импорта — статический импорт. Для этого вместе с директивой import используется модификатор static :
package study; import static java.lang.System.*; import static java.lang.Math.*; public class Program < public static void main(String[] args) < double result = sqrt(20); out.println(result); >>
Здесь происходит статический импорт классов System и Math. Эти классы имеют статические методы. Благодаря операции статического импорта мы можем использовать эти методы без названия класса. Например, писать не Math.sqrt(20) , а sqrt(20) , так как функция sqrt() , которая возвращает квадратный корень числа, является статической. (Позже мы рассмотрим статические члены класса).
То же самое в отношении класса System: в нем определен статический объект out , поэтому мы можем его использовать без указания класса.
Как создать пакет на Java?
Пакет в Java — это механизм для инкапсуляции группы классов, подпакетов и интерфейсов. Все, что нам нужно сделать, это поместить связанные классы в пакеты. После этого мы можем просто написать класс импорта из существующих пакетов и использовать его в нашей программе. Пакет — это контейнер группы связанных классов, в котором одни классы доступны, а другие хранятся для внутренних целей. Мы можем повторно использовать существующие классы из пакетов столько раз, сколько они нам понадобятся в нашей программе. Имена пакетов и структура каталогов тесно связаны
- Пользовательский пакет (создайте свой собственный пакет)
- Встроенные пакеты, которые представляют собой пакеты из интерфейса программирования приложений Java, например, пакеты из API Java. как swing, util, net, io, AWT, lang, javax и т. д.
import package.name. *;
Пример: чтобы импортировать пакет
Here In The Above Program, ‘java.util’ package is imported and run for a simple program. These are called as Inbuilt Packages.
- Сначала мы должны выбрать имя для пакета, который мы собираемся создать и включить. Команда пакета In Первая строка исходного кода java-программы.
- Дальнейшее включение классов, интерфейсов, типов аннотаций и т. Д., Необходимых в пакете, может быть выполнено в пакете. Например, приведенный ниже единственный оператор создает имя пакета с именем « FirstPackage» .
package FirstPackage;
- Сначала объявите имя пакета как первое утверждение нашей программы.
- Затем мы можем включить класс как часть пакета.
Java
// Name of package to be created
Пакеты Java – назначение и использование
Пакеты Java – это механизм для группировки классов, которые связаны друг с другом, в одну и ту же «группу» (пакет). Когда проект становится больше, например, приложение или API, полезно разделить код на несколько классов, а классы – на несколько пакетов. Тогда становится легче выяснить, где находится определенный класс, который вы ищете.
Пакет подобен каталогу в файловой системе. На самом деле на диске он является каталогом. Все исходные файлы и файлы классов, принадлежащих одному и тому же пакету, находятся в одном каталоге.
Могут содержать подпакеты. Таким образом, могут составлять так называемую структуру пакета, похожую на структуру каталогов. Это дерево пакетов, подпакетов и классов внутри этих классов. Организована как каталоги на вашем жестком диске или как каталоги внутри zip-файла (JAR-файлы).
Вот скриншот примера структуры:
Вверху вы видите каталог с именем “src”. Это исходный корневой каталог. Это не сам пакет. Внутри этого каталога все подкаталоги соответствуют пакетам. Таким образом, «коллекции», «com», «параллелизм» и т. д. – это все пакеты (которые также являются каталогами на диске). На снимке экрана выше они показаны значком папки.
Расширено два пакета подуровня, чтобы вы могли видеть классы внутри. Классы проиллюстрированы с помощью маленького синего круга с буквой C внутри, на скриншоте выше.
Полный путь к подпакету – это его имя со всеми именами пакетов-предков, разделенных точками. Например, полный путь к «навигационному» подпакету:
com.blog.navigation
Точно так же полное имя класса включает имя его пакета. Например, полное имя класса «Page»:
com.blog.navigation.Page
Создание структуры
Чтобы создать пакет, вы должны сначала создать корневой каталог на вашем жестком диске. Он сам по себе не является частью структуры пакета. Содержит все исходные коды, которые должны войти в структуру.
Создав исходный корневой каталог, вы можете начать добавлять в него подкаталоги. Каждый подкаталог соответствует пакету. Вы можете добавить подкаталоги в подкаталоги, чтобы создать более глубокую структуру.
Добавление классов
Чтобы добавить классы, вы должны сделать две вещи:
- Поместите исходный файл в каталог, соответствующий пакету, в который вы хотите поместить класс.
- Объявите этот класс как часть пакета.
Первый пункт довольно прост. Создайте корневой каталог источника и внутри него создайте каталоги для каждого пакета и подпакета рекурсивно. Поместите файлы классов в каталог, соответствующий пакету, в который вы хотите добавить его.
Когда вы поместили свой исходный файл в правильный каталог (соответствующий пакету, к которому должен принадлежать класс), вы должны объявить внутри этого файла класса, что он принадлежит этому пакету:
package com.blog.navigation; public class Page
Первая строка в приведенном выше коде – это то, что объявляет класс Page принадлежащим к com.blog.navigation.
Соглашения об именах
Пакеты всегда пишутся строчными буквами. В отличие от классов, где первая буква обычно является заглавной.
Чтобы избежать создания пакетов с такими же именами, как у других общедоступных, рекомендуется начинать иерархию с обратного доменного имени вашей компании. Например, поскольку доменное имя компании – blog.com, надо начать со структуры с именем com.blog. Другими словами, пакет верхнего уровня с именем com с подпакетом внутри называется blog.
Импорт
Если класс A должен использовать класс B, вы должны ссылаться на класс B внутри класса A. Если классы A и B находятся в одном и том же пакете, компилятор будет принимать ссылки между двумя классами:
public class B < public void doIt() < // do something. >>
public class A < public static void main(String[] args)< B theBObj = new B(); b.doIt(); >>
Если классы A и B находятся в одном и том же пакете, проблем с кодом выше нет. Однако, если класс A и B находятся в разных, класс A должен импортировать класс B, чтобы использовать его:
import anotherpackage.B; public class A < public static void main(String[] args)< B theBObj = new B(); b.doIt(); >>
Это первая строка в примере, которая импортирует класс B. В примере предполагается, что класс B находится в пакете с именем anotherpackage.
Если бы класс B находился в подпакете другого пакета, вам пришлось бы перечислить полный путь пакета и подпакета к классу B. Например, если бы класс B находился в пакете anotherpackage.util, то оператор import выглядел бы так:
import anotherpackage.util.B;
Импорт всех классов из другого пакета
Если вам нужно использовать много классов из определенного пакета, их импорт по одному приводит к большому количеству операторов импорта. Можно импортировать все классы, используя символ * вместо имени класса:
import anotherpackage.util.*;
Использование классов через определенное имя
Можно использовать класс из другого пакета, не импортируя его с помощью оператора импорта. Вы можете написать полное имя его, а не просто имя самого класса. Полное имя класса состоит из полного пути пакета до подкласса, содержащего класс, а также самого имени класса. Полное имя класса – это то, что вы написали бы в операторе импорта. Например:
anotherpackage.util.TimeUtil;
Вы можете использовать это полное имя класса для ссылки на класс TimeUtil внутри другого класса, например так:
public class A < public static void main(String[] args)< anotherpackage.util.TimeUtil timeUtil = new anotherpackage.util.TimeUtil(); timeUtil.startTimer(); >>
Пакетное разделение
Официального стандарта для этого нет, но есть два широко используемых метода.
Разделить на слои
Первый метод состоит в том, чтобы разделить классы после определения, к какому «слою» приложения они принадлежат. Например, ваше приложение может иметь слой базы данных. Тогда вы создадите пакет базы данных. Все классы, участвующие в обмене данными с базой данных, будут расположены в нем.
Разделить по функциональности приложения
Второй метод – разделить ваши классы в зависимости от того, к какой части функциональности приложения они принадлежат. Таким образом, если ваше приложение имеет функциональную область, которая рассчитывает пенсии, вы можете создать пакет с именем pension. Все классы, так или иначе участвующие в пенсионных расчетах, будут включены в него (или подпакеты, если число классов в пенсии станет большим).
В сочетании с доменным именем структура для пенсионного пакета будет:
com.jenkov.pension
Всего три пакета, два вложенных в другие.
Метод «деления по функциональности приложения» имеет тенденцию работать лучше, чем «деление по слоям», поскольку в вашем приложении растет число классов.
Вместо того, чтобы иметь фиксированное количество пакетов слоев, число которых продолжает расти, вы получаете растущее число пакетов функциональности приложения с меньшим количеством классов внутри.
Встроенные
Платформа поставляется с множеством встроенных пакетов. Они содержат классы для самых разных целей, которые часто нужны программистам, например, чтение и запись файлов с локального жесткого диска, отправка и получение данных по сетям и Интернету, подключение к базам данных и многое, многое другое.