Packages In Java

Package in Java is a mechanism to encapsulate a group of classes, sub packages and interfaces.
Packages are used for:

 Preventing naming conflicts. For example there can be two classes with name Employee in
two packages, college.staff.cse.Employee and college.staff.ee.Employee
 Making searching/locating and usage of classes, interfaces, enumerations and annotations
easier
 Providing controlled access: protected and default have package level access control. A
protected member is accessible by classes in the same package and its subclasses. A default
member (without any access specifier) is accessible by classes in the same package only.
 Packages can be considered as data encapsulation (or data-hiding).

All we need to do is put related classes into packages. After that we can simply write a import a
class from existing packages and use it in our program. A packages is container of group of related
classes where some of the classes are accessible are exposed and others are kept for internal
purpose.
We can reuse existing classes from the packages as many time as we need it in our program.
How packages work?
Package names and directory structure are closely related. For example if a package name is
college.staff.cse, then there are three directories, college, staff and cse such that cse is present in
staff and staff is present college. Also, the directory college is accessible through CLASSPATH
variable, i.e., path of parent directory of college is present in CLASSPATH. The idea is to make sure
that classes are easy to locate.
Package naming conventions : Packages are named in reverse order of domain names, i.e.,
org.geeksforgeeks.practice. For example, in a college, the recommended convention is
college.tech.cse, college.tech.ee, college.art.history, etc.
Adding a class to a Package : We can add more classes to an created package by using package
name at the top of the program and saving it in the package directory. We need a new java file to
define a public class, otherwise we can add the new class to an existing .java file and recompile it.

Subpackages: Packages that are inside another package are the subpackages. These are not
imported by default, they have to imported explicitly. Also, members of a subpackage have no
access privileges, i.e., they are considered as different package for protected and default access
specifiers.

NOTE:

1. Can group similar classes in the form of a directory structure so searching of classes becomes
easy.
2. can create classes with same name in different package.
3. can use class of one package into another package

Example :
import java.util.*;

util is a subpackage created inside java package.

Types of packages:

Built-in Packages
These packages consist of a large number of classes which are a part of Java API.Some of the
commonly used built-in packages are:
1) java.lang: Contains language support classes(e.g classed which defines primitive data types,
math operations). This package is automatically imported.
2) java.io: Contains classed for supporting input / output operations.
3) java.util: Contains utility classes which implement data structures like Linked List, Dictionary
and support ; for Date / Time operations.
4) java.applet: Contains classes for creating Applets.
5) java.awt: Contain classes for implementing the components for graphical user interfaces (like
button , ;menus etc).
6) java.net: Contain classes for supporting networking operations.
User-defined packages
These are the packages that are defined by the user. First we create a directory myPackage (name
should be same as the name of the package). Then create the MyClass inside the directory with the
first statement being the package names.

EXAMPLE

COMMUNICATION BETWEEN PACKAGES

TWO METHODS

1) USING FULLY QUALIFIED NAME OF THE CLASS

2) USING IMPORT STATEMENT

1) USING FULLY QUALIFIED NAME OF THE CLASS – EXAMPLE

package myPack1; // only compile 'cant run

public class A

{
public void show()
{
System.out.print(“hello”);
}
}

------------------------------
package myPack2;
public class B
{
public static void main(String args[])
{
myPack1.A ob= new myPack1.A();
ob.show();
}

}
---------------------------------

c:\java myPack1 -> A.java -> A.class

 myPack2 -> B.java

c:\java javac myPack1\A.java

javac myPack2\B.java
java myPack2.B
Hello
----------------------------------------------------------------------------------------
1) USING IMPORT STATEMENT – EXAMPLE

package myPack1; // only compile 'cant run

public class A

{
public void show()
{
System.out.print(“hello”);
}
}

------------------------------
package myPack2;
import myPack1.*; // all classes
public class B
{
public static void main(String args[])
{
A ob= new A();
ob.show();
}

}
---------------------------------

c:\java myPack1 -> A.java -> A.class

myPack2 -> B.java

c:\java javac myPack1\A.java

javac myPack2\B.java
java myPack2.B
Hello
--------------------------------------------------------------------------------------------------

ACCESS MODIFIERS (VISIBILITY KEYWORDS)

As the name suggests access modifiers in Java helps to restrict the scope of a class, constructor ,
variable , method or data member. There are four types of access modifiers available in java:
1. Default – No keyword required (No Access Modifiers)
2. Private
3. Protected
4. Public
 (A-A)

(A-C)

(A-B)

(A-E)

(A-D)

C:

JAVA

pack1

A.class
B.class
C.class extends A

pack2

D.class
E.class extends pack1.A

SAME CLASS (A-A)

package pack1;
public class A
{
private void f1()
{
System.out.println(“F1”);
}
public void f2()
{
System.out.println(“F2”);
}
protected void f3()
 {
System.out.println(“F3”);
}

void f4()
{
System.out.println(“F4”);
} <--------------------------------------------------------------***

public static void main(String args[])

{
A ob=new A();
ob.f1();
ob.f2();
ob.f3();
ob.f4();
}

OUTPUT :
F1
F2
F3
F4
_______________________________________________________________

SAME PACKAGE NON- SUBCLASS(A-B)

continue to (***) from previous example

package pack1;
class B
{
public static void main(String args[])
{
A ob=new A();
ob.f2();
ob.f3();
ob.f4();
// ob.f1(); //error
}
}

_______________________________________________________________

SAME PACKAGE SUBCLASS(A-C)

continue to (***) from previous example

package pack1;
class C extends A
{
public static void main(String args[])
{
C ob=new C();
ob.f2();
ob.f3();
ob.f4();
// ob.f1(); //error
}
}

_______________________________________________________________

DIFFERENT PACKAGE NON-SUBCLASS(A-D)

continue to (***) from previous example

package pack2;
class D
{
public static void main(String args[])
{
pack1.A ob=new pack1.A();
ob.f2();
// ob.f3(); //error
// ob.f4(); //error
// ob.f1(); //error
}
}

_______________________________________________________________

DIFFERENT PACKAGE SUBCLASS(A-E)

continue to (***) from previous example

package pack2;
class E extends pack1.A
{
public static void main(String args[])
{
E ob=new E();
ob.f2();
ob.f3();
// ob.f4(); //error
// ob.f1(); //error
}
}

-----------------------------------------------------------------------------------------------------------