Main java classes and packages

Packages in java and how to use them

A package as the name suggests is a pack(group) of classes, interfaces and other packages. In java we use packages to organize our classes and interfaces. We have two types of packages in Java: built-in packages and the packages we can create (also known as user defined package). In this guide we will learn what are packages, what are user-defined packages in java and how to use them.

In java we have several built-in packages, for example when we need user input, we import a package like this:

Here:
→ java is a top level package
→ util is a sub package
→ and Scanner is a class which is present in the sub package util.

Before we see how to create a user-defined package in java, lets see the advantages of using a package.

Advantages of using a package in Java

These are the reasons why you should use packages in Java:

• Reusability: While developing a project in java, we often feel that there are few things that we are writing again and again in our code. Using packages, you can create such things in form of classes inside a package and whenever you need to perform that same task, just import that package and use the class.
• Better Organization: Again, in large java projects where we have several hundreds of classes, it is always required to group the similar types of classes in a meaningful package name so that you can organize your project better and when you need something you can quickly locate it and use it, which improves the efficiency.
• Name Conflicts: We can define two classes with the same name in different packages so to avoid name collision, we can use packages

Types of packages in Java

As mentioned in the beginning of this guide that we have two types of packages in java.
1) User defined package: The package we create is called user-defined package.
2) Built-in package: The already defined package like java.io.*, java.lang.* etc are known as built-in packages.

We have already discussed built-in packages, lets discuss user-defined packages with the help of examples.

Example 1: Java packages

I have created a class Calculator inside a package name letmecalculate . To create a class inside a package, declare the package name in the first statement in your program. A class can have only one package declaration.
Calculator.java file created inside a package letmecalculate

package letmecalculate; public class Calculator < public int add(int a, int b)< return a+b; >public static void main(String args[]) < Calculator obj = new Calculator(); System.out.println(obj.add(10, 20)); >>

Now lets see how to use this package in another program.

import letmecalculate.Calculator; public class Demo < public static void main(String args[])< Calculator obj = new Calculator(); System.out.println(obj.add(100, 200)); >>

To use the class Calculator, I have imported the package letmecalculate . In the above program I have imported the package as letmecalculate.Calculator , this only imports the Calculator class. However if you have several classes inside package letmecalculate then you can import the package like this, to use all the classes of this package.

Example 2: Creating a class inside package while importing another package

As we have seen that both package declaration and package import should be the first statement in your java program. Lets see what should be the order when we are creating a class inside a package while importing another package.

//Declaring a package package anotherpackage; //importing a package import letmecalculate.Calculator; public class Example < public static void main(String args[])< Calculator obj = new Calculator(); System.out.println(obj.add(100, 200)); >>

So the order in this case should be:
→ package declaration
→ package import

Example 3: Using fully qualified name while importing a class

You can use fully qualified name to avoid the import statement. Lets see an example to understand this:
Calculator.java

package letmecalculate; public class Calculator < public int add(int a, int b)< return a+b; >public static void main(String args[]) < Calculator obj = new Calculator(); System.out.println(obj.add(10, 20)); >>

Example.java

//Declaring a package package anotherpackage; public class Example < public static void main(String args[])< //Using fully qualified name instead of import letmecalculate.Calculator obj = new letmecalculate.Calculator(); System.out.println(obj.add(100, 200)); >>

In the Example class, instead of importing the package, I have used the full qualified name such as package_name.class_name to create the object of it. You may also want to read: static import in Java

Sub packages in Java

A package inside another package is known as sub package. For example If I create a package inside letmecalculate package then that will be called sub package.

Lets say I have created another package inside letmecalculate and the sub package name is multiply . So if I create a class in this subpackage it should have this package declaration in the beginning:

package letmecalculate.multiply;

package letmecalculate.multiply; public class Multiplication < int product(int a, int b)< return a*b; >>

Now if I need to use this Multiplication class I have to either import the package like this:

import letmecalculate.multiply;

or I can use fully qualified name like this:

letmecalculate.multiply.Multiplication obj = new letmecalculate.multiply.Multiplication();

Points to remember:

1. Sometimes class name conflict may occur. For example: Lets say we have two packages abcpackage and xyzpackage and both the packages have a class with the same name, let it be JavaExample.java . Now suppose a class import both these packages like this:

import abcpackage.*; import xyzpackage.*;

This will throw compilation error. To avoid such errors you need to use the fully qualified name method that I have shown above. For example

abcpackage.JavaExample obj = new abcpackage.JavaExample(); xyzpackage.JavaExample obj2 = new xyzpackage.JavaExample();

This way you can avoid the import package statements and avoid that name conflict error.

2. I have already discussed this above, let me mention it again here. If we create a class inside a package while importing another package then the package declaration should be the first statement, followed by package import. For example:

package abcpackage; import xyzpackage.*;

3. A class can have only one package declaration but it can have more than one package import statements. For example:

package abcpackage; //This should be one import xyzpackage; import anotherpackage; import anything;

4. The wild card import like package.* should be used carefully when working with subpackages. For example: Lets say: we have a package abc and inside that package we have another package foo, now foo is a subpackage.

classes inside abc are: Example1, Example 2, Example 3
classes inside foo are: Demo1, Demo2

So if I import the package abc using wildcard like this:

Then it will only import classes Example1, Example2 and Example3 but it will not import the classes of sub package.

To import the classes of subpackage you need to import like this:

This will import Demo1 and Demo2 but it will not import the Example1, Example2 and Example3.

So to import all the classes present in package and subpackage, we need to use two import statements like this:

Top Related Articles:

About the Author

I have 15 years of experience in the IT industry, working with renowned multinational corporations. Additionally, I have dedicated over a decade to teaching, allowing me to refine my skills in delivering information in a simple and easily understandable manner.

Источник

Пакеты — Основы Java

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

Для решения проблемы конфликта имен вводится система пакетов. Пакеты позволяют группировать похожие классы.

Определение пакетов

Структура пакетов тесно связана со структурой директорий. Как правило, структура пакетов соответствует файловой структуре директорий проекта, в которых находится файлы с исходным кодом. Например, если классы размещены в пакете example.package1 , то и файлы в проекте должны быть расположены в директории example/package1. Некоторые IDE, например популярная IntelliJ IDEA, при создании пакета автоматически создают соответствующую файловую структуру в директории проекта

Здесь имя User — это так называемое простое имя класса. А полным именем класса считается имя, состоящее из всех пакетов, перечисленных через точку, и простого имени класса. Например, полные имена для классов User будут такими: example.package1.User и example.package2.User . Теперь проблема одинаковых имён классов в большом проекте решена, так как в разных пакетах могут находиться классы с одинаковым простым именем

Для примера в пакете example.package1 создадим класс User , который будет описывать методы для работы с пользователем:

// Файл src/main/java/example/package1/User.java // Именовать пакет начинаем от директории src/main/java/, // в которой расположен корневой пакет package example.package1; class User  public static String getGreeting(String userName)  return "Hello, " + userName + "!"; > > 

Используем этот класс в том же пакете:

// Файл src/main/java/example/package1/App.java // Класс расположен в том же пакете, что и класс User package example.package1; class App  public static void main(String[] args)  // Внутри своего пакета класс можно использовать, // обратившись к нему по простому имени var greeting = User.getGreeting("John"); System.out.println(greeting); // => Hello, John! > > 

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

Контроль доступа

По умолчанию все классы внутри пакета доступны только классам этого же пакета. Чтобы получить доступ к классу снаружи, из другого пакета, этот класс нужно сделать публичным. Вернемся к нашему примеру с пользователем и сделаем класс User в пакете example.package1 публичным

package example.package1; // К определению класса добавляем модификатор public // Теперь класс User становится публичным // и к нему можно обратиться из другого пакета public class User  public static String getGreeting(String userName)  return "Hello, " + userName + "!"; > > 

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

// Файл src/main/java/example/App.java // Уже другой пакет package example; class App  public static void main(String[] args)  // Обращаемся по полному имена класса var greeting = example.package1.User.getGreeting("John"); System.out.println(greeting); // => Hello, John! > > 

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

package example; // Импортируем класс User из пакета example.package1 import example.package1.User; class App  public static void main(String[] args)  // Теперь класс можно использовать, обратившись к нему по простому имени var greeting = User.getGreeting("John"); System.out.println(greeting); // => Hello, John! > > 

Остались вопросы? Задайте их в разделе «Обсуждение»

Вам ответят команда поддержки Хекслета или другие студенты

Источник