Перейти к содержимому

Как называть пакеты в java

  • автор:

Java — Пакеты

Пакеты используются в Java для предотвращения конфликтов имен, для контроля доступа, для упрощения поиска / размещения и использования классов, интерфейсов, перечислений и аннотаций и т. Д.

Пакет может быть определен как группа связанных типов (классы, интерфейсы, перечисления и аннотации), обеспечивающие защиту доступа и управление пространством имен.

Некоторые из существующих пакетов в Java:

  • java.lang — связывает фундаментальные классы
  • java.io — классы для ввода, функции вывода включены в этот пакет

java.lang — связывает фундаментальные классы

java.io — классы для ввода, функции вывода включены в этот пакет

Программисты могут определять свои собственные пакеты для объединения групп классов / интерфейсов и т. Д. Рекомендуется группировать связанные классы, реализованные вами, чтобы программист мог легко определить, что классы, интерфейсы, перечисления и аннотации связаны между собой.

Поскольку пакет создает новое пространство имен, не будет никаких конфликтов имен с именами в других пакетах. Используя пакеты, легче обеспечить контроль доступа, а также легче найти связанные классы.

Создание пакета

При создании пакета вы должны выбрать имя для пакета и включить инструкцию пакета вместе с этим именем в верхней части каждого исходного файла, который содержит классы, интерфейсы, перечисления и типы аннотаций, которые вы хотите включить в пакет.

Инструкция пакета должна быть первой строкой в ​​исходном файле. В каждом исходном файле может быть только один оператор пакета, и он применяется ко всем типам в файле.

Если оператор пакета не используется, класс, интерфейсы, перечисления и типы аннотаций будут помещены в текущий пакет по умолчанию.

Для компиляции программ Java с помощью операторов пакета вы должны использовать опцию -d, как показано ниже.

javac -d Destination_folder file_name.java

Затем в указанном месте назначения создается папка с заданным именем пакета, и скомпилированные файлы классов будут помещены в эту папку.

пример

Давайте посмотрим на пример, который создает пакет под названием животных . Рекомендуется использовать имена пакетов с строчными буквами, чтобы избежать конфликтов с именами классов и интерфейсов.

Следующий пример пакета содержит интерфейс с именем animals

/* File name : Animal.java */ package animals; interface Animal  public void eat(); public void travel(); >

Теперь давайте реализуем вышеуказанный интерфейс в том же пакете животных

package animals; /* File name : MammalInt.java */ public class MammalInt implements Animal  public void eat()  System.out.println("Mammal eats"); > public void travel()  System.out.println("Mammal travels"); > public int noOfLegs()  return 0; > public static void main(String args[])  MammalInt m = new MammalInt(); m.eat(); m.travel(); > > 

Теперь скомпилируйте Java-файлы, как показано ниже —

$ javac -d . Animal.java $ javac -d . MammalInt.java

Теперь пакет / папка с именем животных будет создан в текущем каталоге, и эти файлы классов будут размещены в нем, как показано ниже.

пакеты

Вы можете выполнить файл класса в пакете и получить результат, как показано ниже.

Mammal eats Mammal travels

Ключевое слово импорта

Если класс хочет использовать другой класс в том же пакете, имя пакета не нужно использовать. Классы в одном пакете находят друг друга без какого-либо специального синтаксиса.

пример

Здесь класс с именем Boss добавляется к пакету заработной платы, который уже содержит Employee. Затем босс может ссылаться на класс Employee без использования префикса начисления заработной платы, как демонстрирует следующий класс Boss.

package payroll; public class Boss  public void payEmployee(Employee e)  e.mailCheck(); > >

Что произойдет, если класс Employee отсутствует в пакете заработной платы? Класс Boss должен затем использовать один из следующих методов для ссылки на класс в другом пакете.

  • Полное имя класса может быть использовано. Например —
payroll.Employee
  • Пакет можно импортировать с помощью ключевого слова import и подстановочного знака (*). Например —

Пакет можно импортировать с помощью ключевого слова import и подстановочного знака (*). Например —

import payroll.*;
  • Сам класс может быть импортирован с помощью ключевого слова import. Например —
import payroll.Employee;

Примечание . Файл класса может содержать любое количество операторов импорта. Операторы импорта должны появляться после оператора пакета и перед объявлением класса.

Структура каталогов пакетов

Два основных результата возникают, когда класс помещается в пакет.

  • Имя пакета становится частью имени класса, как мы только что обсуждали в предыдущем разделе.
  • Имя пакета должно соответствовать структуре каталогов, в которой находится соответствующий байт-код.

Имя пакета становится частью имени класса, как мы только что обсуждали в предыдущем разделе.

Имя пакета должно соответствовать структуре каталогов, в которой находится соответствующий байт-код.

Вот простой способ управления вашими файлами в Java —

Поместите исходный код для класса, интерфейса, перечисления или типа аннотации в текстовый файл, имя которого является простым именем типа, а расширение — .java .

// File Name : Car.java package vehicle; public class Car  // Class implementation. >

Теперь поместите исходный файл в каталог, имя которого отражает имя пакета, к которому принадлежит класс.

. \vehicle\Car.java

Теперь квалифицированное имя класса и путь будут выглядеть следующим образом:

  • Название класса → vehicle.Car
  • Имя пути → транспортное средство \ Car.java (в окнах)

Как правило, компания использует свое обратное доменное имя в Интернете для своих имен пакетов.

Пример . Интернет-домен компании называется apple.com, тогда все имена его пакетов начинаются с com.apple. Каждый компонент имени пакета соответствует подкаталогу.

Пример — у компании был пакет com.apple.computers, который содержал исходный файл Dell.java, он будет содержаться в ряде таких подкаталогов, как этот —

. \com\apple\computers\Dell.java

Во время компиляции компилятор создает разные выходные файлы для каждого класса, интерфейса и перечисления, определенных в нем. Базовое имя выходного файла — это имя типа, а его расширение — .class .

// File Name: Dell.java package com.apple.computers; public class Dell  > class Ups  >

Теперь скомпилируйте этот файл следующим образом, используя опцию -d —

$javac -d . Dell.java

Файлы будут скомпилированы следующим образом —

.\com\apple\computers\Dell.class .\com\apple\computers\Ups.class

Вы можете импортировать все классы или интерфейсы, определенные в \ com \ apple \ computers \, следующим образом:

import com.apple.computers.*;

Как и исходные файлы .java, скомпилированные файлы .class должны находиться в серии каталогов, отражающих имя пакета. Однако путь к файлам .class не обязательно должен совпадать с путем к исходным файлам .java. Вы можете расположить свои исходные и классные каталоги отдельно, так как —

\sources\com\apple\computers\Dell.java \classes\com\apple\computers\Dell.class

Делая это, можно предоставить доступ к каталогу классов другим программистам, не раскрывая ваши источники. Вам также необходимо управлять исходными файлами и файлами классов таким образом, чтобы компилятор и виртуальная машина Java (JVM) могли найти все типы, используемые вашей программой.

Полный путь к каталогу классов, \ classes, называется путем к классу и задается системной переменной CLASSPATH. И компилятор, и JVM создают путь к вашим файлам .class, добавляя имя пакета в путь к классу.

Скажите, что \ classes — это путь к классу, а имя пакета — com.apple.computers, тогда компилятор и JVM будут искать файлы .class в \ classes \ com \ apple \ computers.

Путь к классу может включать несколько путей. Несколько путей должны быть разделены точкой с запятой (Windows) или двоеточием (Unix). По умолчанию компилятор и JVM ищут текущий каталог и файл JAR, содержащий классы платформы Java, так что эти каталоги автоматически находятся в пути к классам.

Задать системную переменную CLASSPATH

Чтобы отобразить текущую переменную CLASSPATH, используйте следующие команды в Windows и UNIX (оболочка Bourne) —

  • В Windows → C: \> установить CLASSPATH
  • В UNIX →% echo $ CLASSPATH

Чтобы удалить текущее содержимое переменной CLASSPATH, используйте —

  • В Windows → C: \> установить CLASSPATH =
  • В UNIX →% не установлено CLASSPATH; экспорт CLASSPATH

Чтобы установить переменную CLASSPATH —

именование пакетов в java

Как тут дать объективный ответ? Нужно больше вводных. Какая ответственность этого класса сущности? Используете анемичную (martinfowler.com/bliki/AnemicDomainModel.html) модель? С какими другими классами взаимодействует? Названия пакетов диктуется логикой разбиения классов, а это в свою очередь их ответственностями и взаимодействиями.

Commented 4 мар 2021 в 8:56

Если вы собираетесь публиковать свой проект, то надо обеспечить уникальность полных имен классов. Обычно это достигается употреблением реверсированного имени своего домена в начале имени всех пакетов (т.е. если ваш домен example.com , то имена пакетов начинаются с com.example ). В остальном на ваше усмотрение, ну желательно, чтобы имена пакетов отражали смысл того, что в них находится, и желательно соблюдать конвенции — только нижний регистр в именах пакетов. Если это чисто учебный проект, для себя, то вообще можете называть как хотите.

Руководство по пакетам 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 

Наш вывод должен выглядеть так:

./00c0454e434426d47b2ab0ad1809bba5.jpg

6. Заключение​

В этой короткой статье мы узнали, что такое пакеты и почему мы должны их использовать.

Мы обсудили соглашения об именах и то, как пакеты соотносятся со структурой каталогов. Мы также увидели, как создавать и использовать пакеты.

Наконец, мы рассмотрели, как скомпилировать и запустить приложение с пакетами с помощью команд javac и java .

Полный код примера доступен на GitHub .

  • 1. Введение
  • 2. Обзор пакетов Java
  • 3. Создание пакета
    • 3.1. Соглашения об именах
    • 3.2. Структура каталогов
    • 4.1. Импорт
    • 4.2. Полное имя

    Пакеты Java – назначение и использование

    Пакеты Java – это механизм для группировки классов, которые связаны друг с другом, в одну и ту же «группу» (пакет). Когда проект становится больше, например, приложение или API, полезно разделить код на несколько классов, а классы – на несколько пакетов. Тогда становится легче выяснить, где находится определенный класс, который вы ищете.

    Пакет подобен каталогу в файловой системе. На самом деле на диске он является каталогом. Все исходные файлы и файлы классов, принадлежащих одному и тому же пакету, находятся в одном каталоге.

    Могут содержать подпакеты. Таким образом, могут составлять так называемую структуру пакета, похожую на структуру каталогов. Это дерево пакетов, подпакетов и классов внутри этих классов. Организована как каталоги на вашем жестком диске или как каталоги внутри zip-файла (JAR-файлы).

    Вот скриншот примера структуры:

    Пример структуры пакета Java

    Вверху вы видите каталог с именем “src”. Это исходный корневой каталог. Это не сам пакет. Внутри этого каталога все подкаталоги соответствуют пакетам. Таким образом, «коллекции», «com», «параллелизм» и т. д. – это все пакеты (которые также являются каталогами на диске). На снимке экрана выше они показаны значком папки.

    Расширено два пакета подуровня, чтобы вы могли видеть классы внутри. Классы проиллюстрированы с помощью маленького синего круга с буквой C внутри, на скриншоте выше.

    Полный путь к подпакету – это его имя со всеми именами пакетов-предков, разделенных точками. Например, полный путь к «навигационному» подпакету:

    com.blog.navigation

    Точно так же полное имя класса включает имя его пакета. Например, полное имя класса «Page»:

    com.blog.navigation.Page

    Создание структуры

    Чтобы создать пакет, вы должны сначала создать корневой каталог на вашем жестком диске. Он сам по себе не является частью структуры пакета. Содержит все исходные коды, которые должны войти в структуру.

    Создав исходный корневой каталог, вы можете начать добавлять в него подкаталоги. Каждый подкаталог соответствует пакету. Вы можете добавить подкаталоги в подкаталоги, чтобы создать более глубокую структуру.

    Добавление классов

    Чтобы добавить классы, вы должны сделать две вещи:

    1. Поместите исходный файл в каталог, соответствующий пакету, в который вы хотите поместить класс.
    2. Объявите этот класс как часть пакета.

    Первый пункт довольно прост. Создайте корневой каталог источника и внутри него создайте каталоги для каждого пакета и подпакета рекурсивно. Поместите файлы классов в каталог, соответствующий пакету, в который вы хотите добавить его.

    Когда вы поместили свой исходный файл в правильный каталог (соответствующий пакету, к которому должен принадлежать класс), вы должны объявить внутри этого файла класса, что он принадлежит этому пакету:

    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

    Всего три пакета, два вложенных в другие.

    Метод «деления по функциональности приложения» имеет тенденцию работать лучше, чем «деление по слоям», поскольку в вашем приложении растет число классов.

    Вместо того, чтобы иметь фиксированное количество пакетов слоев, число которых продолжает расти, вы получаете растущее число пакетов функциональности приложения с меньшим количеством классов внутри.

    Встроенные

    Платформа поставляется с множеством встроенных пакетов. Они содержат классы для самых разных целей, которые часто нужны программистам, например, чтение и запись файлов с локального жесткого диска, отправка и получение данных по сетям и Интернету, подключение к базам данных и многое, многое другое.

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *