used to keep the class name space compartmentalized. Defining a Package To create a package is quite easy: simply include a package command as the first statement in a Java source file The package statement defines a name space in which classes are stored If you omit the package statement, the class names are put into the default package, which has no name. Default package is fine for short, sample programs, it is inadequate for real applications. This is the general form of the package statement: package MyPackage; Java uses file system directories to store packages For example, the .class files for any classes you declare to be part of MyPackage must be stored in a directory called MyPackage. The directory name must match the package name exactly You can create a hierarchy of packages. package pkg1[.pkg2[.pkg3]]; Eg:package java.awt.image; needs to be stored in java\awt\image Finding Packages and CLASSPATH How does the Java run-time system know where to look for packages that you create? First, by default, the Java run-time system uses the current working directory as its starting point. Thus, if your package is in a subdirectory of the current directory, it will be found. Second, you can specify a directory path or paths by setting the CLASSPATH environmental variable Third, you can use the -classpath option with java and javac to specify the path to your classes INTERFACE
Using the keyword interface, you can fully abstract a class’
interface from its implementation using interface, you can specify what a class must do, but not how it does it. Interfaces are syntactically similar to classes, but they lack instance variables, and their methods are declared without any body Once it is defined, any number of classes can implement an interface. Also, one class can implement any number of interfaces. To implement an interface, a class must create the complete set of methods defined by the interface By providing the interface keyword, Java allows you to fully utilize the “one interface, multiple methods” aspect of polymorphism. Defining an Interface An interface is defined much like a class. This is the general form of an interface: access interface name { return-type method-name1(parameter-list); return-type method-name2(parameter-list); type final-varname1 = value; type final-varname2 = value; // ... return-type method-nameN(parameter-list); type final-varnameN = value; } Example interface Callback { void callback(int param); } Implementing Interfaces\ Once an interface has been defined, one or more classes can implement that interface class classname [extends superclass] [implements interface [,interface...]] { // class-body } The methods that implement an interface must be declared public. Also, the type signature of the implementing method must match exactly the type signature specified in the interface definition class Client implements Callback { // Implement Callback's interface public void callback(int p) { System.out.println("callback called with " + p); } } It is both permissible and common for classes that implement interfaces to define additional members of their own.
class Client implements Callback {
// Implement Callback's interface public void callback(int p) { System.out.println("callback called with " + p); } void nonIfaceMeth() { System.out.println("Classes that implement interfaces " + "may also define other members, too."); } } Accessing Implementations Through Interface References The following example calls the callback( ) method via an interface reference variable: class TestIface { public static void main(String args[]) { Callback c = new Client(); c.callback(42); } } Although c can be used to access the callback( ) method, it cannot access any other members of the Client class // Another class TestIface2 { implementation of Callback. public static void main(String args[]) { class AnotherClient implements Callback { Callback c = new Client(); // Implement Callback's interface AnotherClient ob = new AnotherClient(); public void callback(int p) { c.callback(42); System.out.println("Ano c = ob; // c now refers ther version of to AnotherClient callback"); object System.out.println("p c.callback(42); squared is " + (p*p)); } } } } Partial Implementations If a class includes an interface but does not fully implement the methods defined by that interface, then that class must be declared as abstract. For example: abstract class Incomplete implements Callback { int a, b; void show() { System.out.println(a + " " + b); } // ... } Nested Interfaces An interface can be declared a member of a class or another interface Such an interface is called a member interface or a nested interface. A nested interface can be declared as public, private, or protected. // A nested interface example. class NestedIFDemo { // This class contains a member interface. public static void main(String args[]) { class A { // use a nested interface // this is a nested interface reference public interface NestedIF { A.NestedIF nif = new B(); boolean isNotNegative(int x); if(nif.isNotNegative(10)) } System.out.println("10 is not } negative"); if(nif.isNotNegative(-12)) // B implements the nested System.out.println("this won't interface. be displayed"); class B implements A.NestedIF { } public boolean isNotNegative(int } x) { return x < 0 ? false : true; } } Interfaces Can Be Extended // One interface can extend another. interface A { System.out.println("Implement void meth1(); meth3()."); void meth2(); } } } // B now includes meth1() and class IFExtend { meth2() -- it adds meth3(). public static void main(String arg[]) { interface B extends A { MyClass ob = new MyClass(); void meth3(); ob.meth1(); } ob.meth2(); // This class must implement all of A ob.meth3(); and B } class MyClass implements B { } public void meth1() { System.out.println("Implement meth1()."); } public void meth2() { System.out.println("Implement meth2()."); } public void meth3() { As an experiment, you might want to try removing the implementation for meth1( ) in MyClass. This will cause a compile-time error. As stated earlier, any class that implements an interface must implement all methods defined by that interface, including any that are inherited from other interfaces.