Package in Java
Introduction
A package is a grouping of
related types providing access protection and name space management. Here type means classes, interfaces, enumerations, and annotation . Enumerations and
annotation types are special kinds of classes and interfaces, respectively. So
types are often referred to in this lesson simply as classes and interfaces. A
Java package is a mechanism for organizing Java classes into namespaces. Thus
Java Packages are containers for classes. That are used to keep the class name space
compartmentalized. In Java package is mapped to a folder on your hard drive.
Java packages can be stored in compressed files called JAR files, allowing
classes to download faster as a group rather than one at a time. Programmers
also typically use packages to organize classes belonging to the same category
or providing similar functionality. A package provides a unique namespace for the
types it contains. Classes in the same package can access each other's
package-access members.
Thus we can say that
- Every class is part of some package.
- All classes in a file are part of the same package.
- You can specify the package using a package declaration:
package name ; as the first (non-comment) line in the file. - Multiple files can specify the same package name.
- You can access public classes in another (named) package using:
package-name.class-name - You can access the public fields and methods of such classes using:
package-name.class-name.field-or-method-name - You can avoid having to include the package-name using:
import package-name.*; or
import package-name.class-name; at the beginning of the file (after the package declaration). The former imports all of the classes in the package, and the second imports just the named class. - You must still use:Class-name to access the classes in the packages, and
class-name.field-or-method-name to access the fields and methods of the class; the only thing you can leave off is the package name.
Some core packages of java are
| java.lang | Basic language functionality and fundamental types |
| java.util | Collection data structure classes |
| java.io | File operations |
| java.math | Multiprecision arithmetics |
| java.nio | The New I/O framework for Java |
| java.net | Networking operations, sockets, DNS lookups |
| java.security | key generation, encryption and decryption |
| java.sql | Java Database Connectivity to access databases |
| java.awt | Basic hierarchy of packages for native GUI components |
| javax.swing | Hierarchy of packages for platform-independent rich GUI |
| java.applet | Classes for creating an applet |
Create It's Own package
For creating a
package we follow the following steps:
Defining a Package
To define a package, include a package command as the
first statement in a Java source file.
Any classes declared within that file will belong to the specified package.If
you omit the package statement, the class names are put into the default
package, which has no name.This is the general form of the package statement:
package packageName;
Create a hierarchy of packages
To create a hierarchy of packages,
separate each package name from the one above it by use of a period. The general
form of a multileveled package statement:
package pkg1[.pkg2[.pkg3]];
Example: In this example we create a folder of name
MyPack and save this java file with name My1.java
.The package name and folder name should be same:
My1.java
package MyPack;
public class My1 {
public static void main(String args[])
{
System.out.println("Hi Friends");
System.out.println("My name is Vikas
Mishra");
System.out.println("This application is
the example of How to create it's own package in java");
System.out.println("Hope its help you
to understand the package concept");
}
}
Compile and Run it
After running this code will give the output as
follow:
Using The packages
For using the java core packages we Importing the
packages and for importing we use the import statement
.In a Java source file, import statements occur immediately following the
package statement and before class definitions.
This is the general form of the import statement:
import pkg1[.pkg2].(classname|*);
(*) means including all classes under that package.
For example:
import java.lang.*;
An Another Application
In this
example we are going to import util package to use the class:
A. java:
import java.util.Date;
public class A {
public static void main(String args[])
{
System.out.println(new Date());
System.out.println("My name is vikas");
System.out.println("This is an example of using A
java package util");
}
}
Output
After running the above application we'll find the
following output:
Thus this article may be help you to understand
the package and it's creation: