To create a package, you choose a name for the package and put a package statement with that name at the top of every source file that contains the types (classes, interfaces, enumerations, and annotation types) that you want to include in the package.
The package statement (for example, package graphics;) must be the first line in the source file.
There can be only one package statement in each source file, and it applies to all types in the file.
Note: If you put multiple types in a single source file, only one can be public, and it must have the same name as the source file.
For example, you can define public class Circle in the file Circle.java, define public interface Draggable in the file Draggable.java, define public enum Day in the file Day.java, and so forth.
You can include non-public types in the same file as a public type (this is strongly discouraged, unless the non-public types are small and closely related to the public type), but only the public type will be accessible from outside of the package.
All the top-level, non-public types will be package private.
package pack2;
public class ClassC /* in a package only one class can be public. A class cannot be private or protected except inner classes */
{
public void display1()
{
System.out.println("Use public if field is to be visible everywhere.");
}
}
If you do not use a package statement, your type ends up in an unnamed package. Generally speaking, an unnamed package is only for small or temporary applications or when you are just beginning the development process. Otherwise, classes and interfaces belong in named packages.
With programmers worldwide writing classes and interfaces using the Java programming language, it is likely that many programmers will use the same name for different types.
In fact, the previous example does just that: It defines a Rectangle class when there is already a Rectangle class in the java.awt package.
Still, the compiler allows both classes to have the same name if they are in different packages.
The fully qualified name of each Rectangle class includes the package name.
That is, the fully qualified name of the Rectangle class in the graphics package is graphics.Rectangle, and the fully qualified name of the Rectangle class in the java.awt package is java.awt.Rectangle.
This works well unless two independent programmers use the same name for their packages. What prevents this problem? Convention.
Package names are written in all lower case to avoid conflict with the names of classes or interfaces.
Companies use their reversed Internet domain name to begin their package names—for example, com.example.mypackage for a package named mypackage created by a programmer at example.com.
Name collisions that occur within a single company need to be handled by convention within that company, perhaps by including the region or the project name after the company name (for example, com.example.region.mypackage).
Packages in the Java language itself begin with java. or javax.
In some cases, the internet domain name may not be a valid package name.
This can occur if the domain name contains a hyphen or other special character, if the package name begins with a digit or other character that is illegal to use as the beginning of a Java name, or if the package name contains a reserved Java keyword, such as "int".
In this event, the suggested convention is to add an underscore.
The types that comprise a package are known as the package members.
To use a public package member from outside its package, you must do one of the following:
Refer to the member by its fully qualified name
Import the package member
Import the member's entire package
Each is appropriate for different situations, as explained in the sections that follow.
Referring to a Package Member by Its Qualified Name So far, most of the examples in this tutorial have referred to types by their simple names, such as Rectangle and StackOfInts. You can use a package member's simple name if the code you are writing is in the same package as that member or if that member has been imported.
However, if you are trying to use a member from a different package and that package has not been imported, you must use the member's fully qualified name, which includes the package name. Here is the fully qualified name for the Rectangle class declared in the graphics package in the previous example.
graphics.Rectangle
You could use this qualified name to create an instance of graphics.Rectangle:
graphics.Rectangle myRect = new graphics.Rectangle();
Qualified names are all right for infrequent use. When a name is used repetitively, however, typing the name repeatedly becomes tedious and the code becomes difficult to read.
As an alternative, you can import the member or its package and then use its simple name.
To import a specific member into the current file, put an import statement at the beginning of the file before any type definitions but after the package statement, if there is one.
Here's how you would import the Rectangle class from the graphics package created in the previous section.
import graphics.Rectangle;
Now you can refer to the Rectangle class by its simple name.
Rectangle myRectangle = new Rectangle();
This approach works well if you use just a few members from the graphics package. But if you use many types from a package, you should import the entire package.
Importing an Entire Package To import all the types contained in a particular package, use the import statement with the asterisk (*) wildcard character.
import graphics.*;
Now you can refer to any class or interface in the graphics package by its simple name.
Circle myCircle = new Circle();
Rectangle myRectangle = new Rectangle();
The asterisk in the import statement can be used only to specify all the classes within a package, as shown here. It cannot be used to match a subset of the classes in a package. For example, the following does not match all the classes in the graphics package that begin with A.
// does not work
import graphics.A*;
Instead, it generates a compiler error. With the import statement, you generally import only a single package member or an entire package.
Note: Another, less common form of import allows you to import the public nested classes of an enclosing class. For example, if the graphics.Rectangle class contained useful nested classes, such as Rectangle.DoubleWide and Rectangle.Square, you could import Rectangle and its nested classes by using the following two statements.
import graphics.Rectangle;
import graphics.Rectangle.*;
Be aware that the second import statement will not import Rectangle.
Another less common form of import, the static import statement, will be discussed at the end of this section.
For convenience, the Java compiler automatically imports two entire packages for each source file: (1) the java.lang package and (2) the current package (the package for the current file).
At first, packages appear to be hierarchical, but they are not. For example, the Java API includes a java.awt package, a java.awt.color package, a java.awt.font package, and many others that begin with java.awt.
However, the java.awt.color package, the java.awt.font package, and other java.awt.xxxx packages are not included in the java.awt package. The prefix java.awt (the Java Abstract Window Toolkit) is used for a number of related packages to make the relationship evident, but not to show inclusion.
Importing java.awt.* imports all of the types in the java.awt package, but it does not import java.awt.color, java.awt.font, or any other java.awt.xxxx packages.
If you plan to use the classes and other types in java.awt.color as well as those in java.awt, you must import both packages with all their files:
import java.awt.*;
import java.awt.color.*;
If a member in one package shares its name with a member in another package and both packages are imported, you must refer to each member by its qualified name. For example, the graphics package defined a class named Rectangle. The java.awt package also contains a Rectangle class.
If both graphics and java.awt have been imported, the following is ambiguous.
Rectangle rect;
In such a situation, you have to use the member's fully qualified name to indicate exactly which Rectangle class you want. For example,
graphics.Rectangle rect;
There are situations where you need frequent access to static final fields (constants) and static methods from one or two classes.
Prefixing the name of these classes over and over can result in cluttered code.
The static import statement gives you a way to import the constants and static methods that you want to use so that you do not need to prefix the name of their class.
The java.lang.Math class defines the PI constant and many static methods, including methods for calculating sines, cosines, tangents, square roots, maxima, minima, exponents, and many more. For example,
public static final double PI
= 3.141592653589793;
public static double cos(double a)
{
...
}
Ordinarily, to use these objects from another class, you prefix the class name, as follows.
double r = Math.cos(Math.PI * theta);
You can use the static import statement to import the static members of java.lang.Math so that you don't need to prefix the class name, Math. The static members of Math can be imported either individually or in group:
import static java.lang.Math.PI;
import static java.lang.Math.*;
Once they have been imported, the static members can be used without qualification. For example, the previous code snippet would become:
double r = cos(PI * theta);
Obviously, you can write your own classes that contain constants and static methods that you use frequently, and then use the static import statement. For example,
import static mypackage.MyConstants.*;
Note: Use static import very sparingly. Overusing static import can result in code that is difficult to read and maintain, because readers of the code won't know which class defines a particular static object. Used properly, static import makes code more readable by removing class name repetition.
Step 1: Create a Package - Store below code in a file and name the file ClassC.java. Place ClassC.java in a folder "Demo".
package pack2;
public class ClassC /* in a package only one class can be public. A class cannot be private or protected except inner classes */
{
public void display1()
{
System.out.println("Use public if field is to be visible everywhere.");
}
protected void display2()
{
System.out.println("Use protected if field is to be visible everywhere in current package and also subclasses in other packages");
}
private void display3()
{
System.out.println("Use private if field is not to be visible anywhere except in its own class.");
}
void display4() //default access- friendly
{ System.out.println("Use default or friendly if field is to be visible in the current package only");
}
}
Step 2: Create a file to access the package. Copy paste the below code in noepad and save as ClassF.java. Store it in same folder "Demo" as ClassC.java.
import pack2.ClassC; // importing all the classes of package pack2
class ClassD
{
void display5()
{
ClassC c = new ClassC(); /*ok bcz ClassC is public in pack2 and so can be accesed outside the package*/
c.display1(); //ok bcz display1() is public
//c.display2(); /*error bcz display2() is protected and can only be accessed in subclasses inheriting ClassC */
//c.display3(); //error bcz display3() is private
//c.display4(); /*error bcz display4() is friendly (or have default visibilty mode) and cannot be accessed outside its package i.e. pack2 */
}
}
class ClassE extends ClassC //creating subclass
{
void display6()
{
display1(); //ok bcz display1() is public and can be inheritated
display2(); //ok bcz display2() is protected and can be inheritated
//display3(); //error bcz display3() is private and cannot be inheritated
//display4(); /*error bcz display4() is friendly (or have default visibilty mode) and cannot be inheritated*/
}
}
class ClassF
{
public static void main(String args[])
{
ClassD d = new ClassD();
d.display5();
ClassE e = new ClassE();
e.display6();
}
}
Step3: Compile and Execute - Open command prompt and type four commands given below one after another. Remember command prompt directory location should be set to location of folder "Demo". I
cd C:\Users\Admin\Desktop\Demo
javac ClassC.java
javac ClassF.java
java ClassF