0% found this document useful (0 votes)
77 views9 pages

Java Lang Util Io Awt Net Appl Et

Packages in Java are used to organize related classes and interfaces by providing a namespace. There are two types of packages - Java API packages which contain classes grouped by functionality that are part of the Java library, and user-defined packages which contain classes created by the user. Packages allow for reusability of classes, hiding of classes for internal use only, and separation of design from code. To use a class from a package, it must be imported using an import statement.
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
0% found this document useful (0 votes)
77 views9 pages

Java Lang Util Io Awt Net Appl Et

Packages in Java are used to organize related classes and interfaces by providing a namespace. There are two types of packages - Java API packages which contain classes grouped by functionality that are part of the Java library, and user-defined packages which contain classes created by the user. Packages allow for reusability of classes, hiding of classes for internal use only, and separation of design from code. To use a class from a package, it must be imported using an import statement.
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
You are on page 1/ 9

Packages

Introduction

Most programming languages provide ready made code libraries that contain a
group of related files. By using those contents of these libraries, we can
considerably save coding time and effort. The files under these code libraries are
sorted and arranged according to their functionality. In different languages they are
known by different names. In C they are called header files, in C++ class libraries
and in Java they are called Packages.

A package is a combination of classes, interfaces and sub packages. In fact


packages act as containers for class.

The main feature of OOP is its reusability. One way achieving this is by
extending the classes and implementing the interfaces. Another way of achieving
the reusability in Java is to use packages.

Advantages of packages

The classes contained in the packages of other programs can be easily


reused.
In packages, classes can be unique compared with classes in other packages
that is two classes in two different packages can have the same name.
Packages can provide a way to hide classes, thus preventing other program
of packages from accessing classes that are meant for internal use only.
Packages also provide a way for separating design from coding.

Java packages are therefore classified into two types

1. Java API packages.


2. User defined packages

Java API packages

Java API provides a large number of classes grouped into different packages
according to functionality. The frequently used java API packages are

java
appl
lang util io awt net
et
java.lang
o This package contains utility classes such as vectors, date, random etc.
java.util
o This package contains input/output support classes. They provide
facilities for the input and output of date.
java.io
o This package contains input/output support classes. They provide
facilities for the input and output of date.
java.awt
o This package contains a set of classes for implementing graphical user
interface. They provide facilities for the input and output of date.
java.net
o This package contains classes for networking. They include classes for
communicating with local computers as well as with internet servers.
java.applet
o This package contains classes for creating and implementing applets.

Using system packages:

This packages are organized in a hierarchial structure. There are two ways of
accessing the classes stored in a package. The first approach is to use the fully
qualified class name of the class that we want to use. This is done by using the
package name containing the class and then appending the class name to it using
the dot operator.

For example: java.io.DataInputStream

Naming conventions

Packages can be named using the standard java naming rules. By


conventions, however, packages begin with lowercase letters. This makes it easy for
users to distinguish packages begin with lowercase letters. This makes it easy for
users to distinguish package names from class names when looking at an explicit
reference to a class.

Every package name must be unique to make the best use of packages.
Duplicate names will cause run-time errors.

Creating packages(user defined packages)

Java language provides facility for creating our own packages. These
packages are called user-defined packages.

Creating packages

To create a user defined packages steps are as follows

Method1
1) Declare the package at the beginning of a file using the package keyword
followed by a package name. This must be first statement in java source
file(except for comments)
Syntax: package my package;
Ex: siva
2) Import the required standard packages available using the import statement.
Ex: import java.util.*;
3) Declare and define the classes that will be included in the package. All the
members of the package should be public to be accessed from outside.
Ex: package mypackage;
Import java.util.*;
Public class Math
{
// class definition
}
4) Save the above definition in a java file and compile the classes defined in the
package. Compilation can be done with a -d option. This creates a folder
with the package name and places the .class file into the specified folder.
Javac d c:\java math.java

Method2

1) Create a subdirectory where the main source files are stored, the directory
name must match the package name exactly.
2) Store the listing as the classname.java file in the subdirectory created.
3) Compile the file. This creates .class file in the subdirectory.

Accessing a package

Java includes import statement to bring certain classes or entire package


accessability.

The import statement can be used to search a list of packages for a particular class.

In java source file,import statements occur immediately following the


package statement(if it exists) and before any class definitions.

The general form of the import statement is

Import package1 [package2].classname;

Here

Package1 is the name of the top-level package.

Package2 is the name of the package that is inside package1.

The outer package separated by dot.


classname/* which indicates that the java compiler should import the specified
class or a package.

import statement should end with semicolon.

Ex: import java.awt.colour; //importing system packages.

Import java.awt.*;

Import pack1.ClassName; //importing user defined packages

Where pack1 is the name of the user defined package when we import a package
using astrick(*) all public classes are imported. However we may refer to not
import certain outside of the package. Such classes should be declared not public.

CLASSPATH

While packages solve many problems from an access control and name space
collision prespective, they cause some curious difficulties. When you compile and
run programs. This is because the specific location that the java compilers will
consider as the root of any package hierarchy is controlled by CLASSPATH.

When java program is executed, the JVM searches for the classes used within
the program on the file system. It uses one of two elements to find a specific class.

1. The package name and


2. The directories listed in the CLASSPATH environment variable. If no
CLASSPATH is defined, then JVM looks for the default java\lib directly and the
current working directory.

The different access modifiers and its access locations as shown below while using
packages and inheritance in a program

Public Protecte Friendly(defau Private priva


d lt) Protected te
Same class Yes Yes Yes Yes Yes
Sub class in the same Yes Yes Yes Yes No
package
Other classes in same Yes Yes Yes No No
package
Subclasses in other Yes Yes No Yes No
packages
Non subclasses in other Yes No No No No
packages

/*user defines package demonstration program*/

//creating arith class as a member in math package


Package math; //package statement

Public class Arith

Public int add(int x, int y)

Return(x+y);

Public int sub(int x,int y)

Return(x-y);

Public int mul(int x, int y)

Return(x*y);

Public int div(int x, int y)

Return(x/y);

//save as arith.java

//javac d E:\java Arith.java

//creating stat class as a member in math package

Package math; //package statement

Public class stat


{

Public int max(int x, int y)

Return(x>y?x:y);

Public int min(int x, int y)

Return(x<y?x:y);

//save as Stat.java

//javac d E:\java Stat.java

/*package testing program*/

Import math.Arith; //importing Arith class from math package

Import math.Stat; //importing Stat class from math package

Import java.io.*;

Class Pack Test

Public static void main(String args[])

Arith a =new Arith(); //creating an instance of Arith class

System.out.println(addition :+a.add(10,20));

System.out.println(substraction:+a.sub(20,10));

System.out.println(multiplication+a.mul(10,20));

System.out.println(division:+a.div(20,10));
Stat s=new Stat(); //creating an instance of Stat class

System.out.println(maximum value:+s.max(10,20));

System.out.println(minimum value:+s.min(10,20));

//execution procedure

>set class path= ; E:/java; //setting class path

>javac PackTest.java //compilation

>java PackTest //run

Adding a class to a package

It is simple to add a class to an existing package. For example

Package p1;

Public class A

//body of class A\

In the above example, the package p1 contains one public class by name A.
Suppose we want to add class B to this package. This can be done as follows:

Define the class and make it public.


Place the package statement before the class definition as follows:
Package p1;
Public class B
{
//body of class B
}
Store
Compile

Hiding classes

When we import a package using asterisk(*), all public classes are imported.
If you want to hide these classes from accessing from outside of the package, such
classes should be declared not public.
For example

Package p1;

Public class

//body of class

Class Y

//body of class Y

Here, the class Y which is not declared public is hidden from outside of the
package p1. This class can be seen and used only by other classes in the same
package.

Static import

Static import is another feature introduced with the J2SE 5.0 release. This
feature eliminates the need of qualifying a static member with class name. We can
use the static import statement to import static members from classes and use
them without qualifying class name.

The syntax for static import feature is

Import static packagename.subpackagename.classname.static membername.

Import static packagename.subpackagename.classname.*;

Public class MathDemo

Public void MathDemo

Double area=PI*r*r;

System.out.println(the area of circle is:+area);

}
Public static void main(String args[])

MathDemo mt=new MathDemo();

Mt.circle(3.4);

You might also like