{"id":2285,"date":"2020-04-01T17:57:57","date_gmt":"2020-04-01T17:57:57","guid":{"rendered":"https:\/\/www.h2kinfosys.com\/blog\/?p=2285"},"modified":"2020-04-23T15:30:41","modified_gmt":"2020-04-23T10:00:41","slug":"java-language-packages","status":"publish","type":"post","link":"https:\/\/www.h2kinfosys.com\/blog\/java-language-packages\/","title":{"rendered":"Java Language packages"},"content":{"rendered":"

Java language<\/a> has thousands of built-in classes. Java packages are a nice way to organize classes, interfaces, enumerations with similar functionality to groups. Packages help to avoid name conflicts. A code with packages is easier to maintain. They are the way of encapsulation. It can be compared to pieces of paper sorted in different folders by content. You don’t need to search for some information through all the papers. You will use a particular folder. The same with code. You need to tell in what package to look to find code. Therefore, packages make search and usage of classes, annotations, interfaces, enumerations easier.
\nThis code doesn’t compile, because we don’t know the package to search the class Date.<\/p>\n

public<\/span>\u00a0<\/span>class<\/span>\u00a0ImportExample {<\/span>
\n\u00a0 \u00a0\u00a0<\/span><\/span>public<\/span>\u00a0<\/span>static<\/span>\u00a0<\/span>void<\/span>\u00a0main(String[]\u00a0<\/span>args<\/span>) {<\/span>
\n\u00a0 \u00a0\u00a0<\/span><\/span>\u00a0 \u00a0\u00a0<\/span><\/span>System.<\/span>out<\/span>.println(new Date());\u00a0<\/span>\/\/ DOES NOT COMPILE<\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>}<\/span><\/p>\n

}<\/span><\/p>\n

We will get an error that the Date cannot be resolved to a type. The compiler cannot find the class Date(). The code can be fixed if you provide the fully qualified name:<\/span><\/p>\n

public<\/span>\u00a0<\/span>class<\/span>\u00a0ImportExample {<\/span>
\n\u00a0 \u00a0\u00a0<\/span><\/span>public<\/span>\u00a0<\/span>static<\/span>\u00a0<\/span>void<\/span>\u00a0main(String[]\u00a0<\/span>args<\/span>) {<\/span>
\n System.<\/span>out<\/span>.println(new\u00a0<\/span>java.util.<\/span>Date());\u00a0<\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>}<\/span><\/p>\n

}<\/span><\/p>\n

Usually, your developer’s environment (Eclipse, NetBeans, etc) will give you a hint that you have missed an import. So, you can fix this error in another way. You will be able to compile after adding the import:<\/span><\/p>\n

import<\/span>\u00a0java.util.Date;<\/span><\/p>\n

public<\/span>\u00a0<\/span>class<\/span>\u00a0ImportExample {<\/span>
\n\u00a0 \u00a0\u00a0<\/span><\/span>public<\/span>\u00a0<\/span>static<\/span>\u00a0<\/span>void<\/span>\u00a0main(String[]\u00a0<\/span>args<\/span>) {<\/span>
\n\u00a0 \u00a0\u00a0<\/span><\/span>\u00a0 \u00a0\u00a0<\/span><\/span>System.<\/span>out<\/span>.println(new Date());\u00a0<\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>}<\/span><\/p>\n

}<\/span><\/p>\n

As you can see, package names are hierarchical, sub realm names are separated by dots. To import then, we use the reserved word import. In the current case, we are importing just one class from the package java.util. But, there is also another way.<\/p>\n

Wildcard<\/strong><\/h2>\n

Let’s assume the situation that we need to import two classes from the same package. For example, ArrayList and Date from package java.util:<\/p>\n

import<\/span>\u00a0java.util.Date;<\/span>
\nimport<\/span>\u00a0<\/span>java.util.ArrayList;<\/span><\/p>\n

public<\/span>\u00a0<\/span>class<\/span>\u00a0ImportExample {<\/span>
\n\u00a0 \u00a0\u00a0<\/span><\/span>public<\/span>\u00a0<\/span>static<\/span>\u00a0<\/span>void<\/span>\u00a0main(String[]\u00a0<\/span>args<\/span>) {<\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>\u00a0 \u00a0\u00a0<\/span><\/span>ArrayList<Date>\u00a0<\/span>list<\/span>\u00a0=\u00a0<\/span>new<\/span>\u00a0ArrayList<Date>();<\/span>
\n\u00a0 \u00a0\u00a0<\/span><\/span>\u00a0 \u00a0\u00a0<\/span><\/span>list<\/span>.add(<\/span>new<\/span>\u00a0Date());<\/span>
\n\u00a0 \u00a0\u00a0<\/span><\/span>\u00a0 \u00a0\u00a0<\/span><\/span>System.<\/span>out<\/span>.println(<\/span>list<\/span>.size());\u00a0<\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>}<\/span><\/p>\n

}<\/span><\/p>\n

What if developers need to import 3 or more classes from the same package together? For this purpose they can use the wildcard *, that matches all classes in the package:<\/span>What if developers need to import 3 or more classes from the same package together? For this purpose they can use the wildcard *, that matches all classes in the package:<\/span><\/p>\n

import<\/span>\u00a0java.util.*;<\/span><\/p>\n

 <\/p>\n

This will import all classes from the package java.util, but not from child packages like java.util.concurrent, java.util.regex, java.util.stream, etc.
\nListing the classes used makes the code easier to read, but using the wildcard can shorten the import list. Including so many classes does not slow down your application. The compiler can figure out what is actually needed.
\nLet’s try to write all the imports together:<\/p>\n

import<\/span>\u00a0java.util.Date;<\/span>
\nimport<\/span>\u00a0<\/span>java.util.ArrayList;<\/span>
\nimport<\/span>\u00a0java.util.*;<\/span><\/p>\n

 <\/p>\n

In this case, your developer’s environment will notify you that the import of java.util.* is redundant.
\nIt is illegal to use more than one wildcard in one import and it must be at the end. This does not compile:<\/p>\n

import<\/span>\u00a0java.*.*; \/\/DOES NOT COMPILE<\/span><\/p>\n

Also, this type of import is wrong:<\/p>\n

import<\/span>\u00a0java.util.ArrayList.*; \/\/DOES NOT COMPILE<\/span><\/p>\n

Naming Conflicts<\/strong><\/h2>\n

Using of packages has one more reason. Class names don\u2019t have to be unique across all of Java. There are two implementations for class the Date in Java language<\/a>. They are in the packages java.util and java.sql.
\nIf you include both imports, your code would not compile:<\/p>\n

import<\/span>\u00a0java.util.*;<\/span>
\nimport<\/span>\u00a0java.sql.*;<\/span><\/p>\n

public<\/span>\u00a0<\/span>class<\/span>\u00a0ConflictsExample {<\/span>
\n\u00a0 \u00a0\u00a0<\/span><\/span>public<\/span>\u00a0<\/span>static<\/span>\u00a0<\/span>void<\/span>\u00a0main(String[]\u00a0<\/span>args<\/span>) {<\/span>
\n\u00a0 \u00a0\u00a0<\/span><\/span>\u00a0 \u00a0\u00a0<\/span><\/span>System.<\/span>out<\/span>.println(new Date());\u00a0<\/span>\/\/ DOES NOT COMPILE<\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>}<\/span><\/p>\n

}<\/span><\/p>\n

    \n
  1. You can fix imports on the top of your class:<\/span><\/li>\n<\/ol>\n

    import<\/span>\u00a0java.util.Date;<\/span><\/p>\n

    2. You can write a package that you want to use right in the code of your class:<\/span><\/p>\n

    System.<\/span>out<\/span>.println(new java.util.Date());<\/span><\/p>\n

    This code also doesn’t compile:<\/span><\/p>\n

    import java.util.Date;\u00a0<\/span>
    \nimport java.sql.Date;<\/span><\/p>\n

     <\/p>\n

    This example will work even without imports:<\/span><\/p>\n

    public<\/span>\u00a0<\/span>class<\/span>\u00a0ConflictsExample {<\/span>
    \n\u00a0 \u00a0\u00a0<\/span><\/span>java.util.Date\u00a0<\/span>date<\/span>;<\/span>
    \n\u00a0 \u00a0\u00a0<\/span><\/span>java.sql.Date\u00a0<\/span>sqlDate<\/span>;<\/span>
    \n}<\/span><\/p>\n

     <\/p>\n

    Consequently, when we have a naming conflict, we need to use a fully qualified class name for at least one of the classes.<\/span><\/p>\n

    Creating a New Package\u00a0<\/b><\/h2>\n

    Let’s look at the new package creation. The directory structure on your operating system is related to the package name. Look at the example below.<\/span><\/p>\n

    Windows directory:
    \n<\/span>C:\\temp\\my\\test\\ClassA.java
    \n<\/span>The ClassA code:<\/span><\/p>\n

    package<\/span>\u00a0my.test;\u00a0<\/span><\/p>\n

    import<\/span>\u00a0java.util.Date;<\/span><\/p>\n

    public<\/span>\u00a0<\/span>class<\/span>\u00a0ClassA {\u00a0<\/span>
    \n\u00a0 \u00a0\u00a0<\/span><\/span>public<\/span>\u00a0<\/span>void<\/span>\u00a0printDate() {<\/span>
    \n\u00a0 \u00a0\u00a0<\/span><\/span>\u00a0 \u00a0\u00a0<\/span><\/span>System.<\/span>out<\/span>.println(\u201cCurrent date: \u201d + new Date());\u00a0<\/span><\/p>\n

    \u00a0 \u00a0\u00a0<\/span><\/span>}<\/span><\/p>\n

    }<\/span><\/p>\n

     <\/p>\n

    Our ClassA is inside package mytest. To define a package we have to use Java reserved word package. We have to use this statement before the class declaration and before all our imports. It has to be the very first line of code in our file.<\/span><\/p>\n

    If you want to import the ClassA you have to write:<\/span><\/p>\n

    import my.test.ClassA;<\/span><\/p>\n

    or<\/span><\/p>\n

    import my.test.*;<\/span><\/p>\n

     <\/p>\n

    Assuming that a class ClassB is using our class ClassA. The class ClassB is in another package my.test.usage:<\/span><\/p>\n

    package<\/span>\u00a0my.test.usage;\u00a0<\/span><\/p>\n

    import<\/span>\u00a0my.test.ClassA;<\/span><\/p>\n

    public<\/span>\u00a0<\/span>class<\/span>\u00a0ClassB {\u00a0<\/span>
    \n\u00a0 \u00a0\u00a0<\/span><\/span>public<\/span>\u00a0<\/span>void<\/span>\u00a0callClassA() {<\/span>
    \n\u00a0 \u00a0\u00a0<\/span><\/span>\u00a0 \u00a0\u00a0<\/span><\/span>System.<\/span>out<\/span>.println(new ClassA().printDate());\u00a0<\/span><\/p>\n

    \u00a0 \u00a0\u00a0<\/span><\/span>}<\/span>
    \n}\u00a0<\/span><\/p>\n

     <\/p>\n

    Let’s look at more examples to understand how packages correspond with the directory structure.
    \nPackage: edu.mytest.subpackage.*
    \nWindows path: C:\\temp\\edu\\mytest\\subpackage<\/p>\n

    Package: com.example.myapplication.*
    \nWindows path: C:\\temp\\com\\example\\ myapplication<\/p>\n

    All packages and sub-packages have their own directory. Sub-packages are not imported by default. You have to import them explicitly. And vise versa, members of a sub-package have no access to its general package. They are considered as different packages. In other words, package my.test have to import package my.test.usage to have access to its java classes<\/a>. Similarly, package my.test.usage have to import package my.test.
    \n———————-<\/p>\n

    public<\/span>\u00a0<\/span>class<\/span>\u00a0StaticExample {<\/span>
    \n\u00a0 \u00a0\u00a0<\/span><\/span>\u00a0 \u00a0\u00a0<\/span><\/span>public<\/span>\u00a0<\/span>static<\/span>\u00a0<\/span>void<\/span>\u00a0main(String[]\u00a0<\/span>args<\/span>) {<\/span>
    \n\u00a0 \u00a0\u00a0<\/span><\/span>\u00a0 \u00a0\u00a0<\/span><\/span>\u00a0 \u00a0\u00a0<\/span><\/span>System.<\/span>out<\/span>.println(Math.<\/span>sqrt<\/span>(9));<\/span>
    \n\u00a0 \u00a0\u00a0<\/span><\/span>\u00a0 \u00a0\u00a0<\/span><\/span>}<\/span>
    \n}<\/span><\/p>\n

    In code with static import we can remove class name before the method sqrt:<\/p>\n

    import<\/span>\u00a0<\/span>static<\/span>\u00a0java.lang.Math.<\/span>sqrt<\/span>; \u00a0\/\/ STATIC IMPORT<\/span><\/p>\n

    public<\/span>\u00a0<\/span>class<\/span>\u00a0StaticExample {<\/span>
    \n\u00a0 \u00a0\u00a0<\/span><\/span>\u00a0 \u00a0\u00a0<\/span><\/span>public<\/span>\u00a0<\/span>static<\/span>\u00a0<\/span>void<\/span>\u00a0main(String[]\u00a0<\/span>args<\/span>) {<\/span>
    \n\u00a0 \u00a0\u00a0<\/span><\/span>\u00a0 \u00a0\u00a0<\/span><\/span>\u00a0 \u00a0\u00a0<\/span><\/span>System.<\/span>out<\/span>.println(<\/span>sqrt<\/span>(9));<\/span>
    \n\u00a0 \u00a0\u00a0<\/span><\/span>\u00a0 \u00a0\u00a0<\/span><\/span>}<\/span>
    \n}<\/span><\/p>\n

    In case you want to use several static methods or variables from the same package you can use a wildcard:<\/p>\n

    import<\/span>\u00a0<\/span>static<\/span>\u00a0java.lang.Math.*; \/\/ STATIC IMPORT with WILDCARD<\/span><\/p>\n

    public<\/span>\u00a0<\/span>class<\/span>\u00a0FutureExample {<\/span>
    \n\u00a0 \u00a0\u00a0<\/span><\/span>\u00a0 \u00a0\u00a0<\/span><\/span>public<\/span>\u00a0<\/span>static<\/span>\u00a0<\/span>void<\/span>\u00a0main(String[]\u00a0<\/span>args<\/span>) {<\/span>
    \n\u00a0 \u00a0\u00a0<\/span><\/span>\u00a0 \u00a0\u00a0<\/span><\/span>\u00a0 \u00a0\u00a0<\/span><\/span>System.<\/span>out<\/span>.println(<\/span>sqrt<\/span>(9));<\/span>
    \n\u00a0 \u00a0\u00a0<\/span><\/span>\u00a0 \u00a0\u00a0<\/span><\/span>\u00a0 \u00a0\u00a0<\/span><\/span>System.<\/span>out<\/span>.println(<\/span>abs<\/span>(9));<\/span>
    \n\u00a0 \u00a0\u00a0<\/span><\/span>\u00a0 \u00a0\u00a0<\/span><\/span>\u00a0 \u00a0\u00a0<\/span><\/span>System.<\/span>out<\/span>.println(<\/span>PI<\/span>);<\/span>
    \n\u00a0 \u00a0\u00a0<\/span><\/span>\u00a0 \u00a0\u00a0<\/span><\/span>\u00a0 \u00a0\u00a0<\/span><\/span>System.<\/span>out<\/span>.println(<\/span>E<\/span>);<\/span>
    \n\u00a0 \u00a0\u00a0<\/span><\/span>\u00a0 \u00a0\u00a0<\/span><\/span>}<\/span>
    \n}<\/span><\/p>\n

    Build-in packages<\/b><\/h2>\n

    Java platform has a lot of build-in packages that are free to use.<\/span><\/p>\n

    java.lang<\/b> is a basic package. It is allowed to use without an import statement. This package contains fundamental types and basic functionality. Here is some of them:\u00a0<\/span><\/p>\n