• Compilation Units
• Sub-Package
• A compilation unit is a source code file of Java (also known as translation unit). Each compilation unit must have a name, ending with .java extension. A compilation unit can have a public class that must have same name as the fi le name. Only one class can be declared public in a compilation unit, otherwise the complier will show error message.
  If a compilation unit contains additional non-public classes, they will be hidden from the outside world but can be used as support classes to the main public class.
• A sub-package is a subdirectory or a sub-folder that may also contain compilation unit and sub-package of its own.

Named and Unnamed Packages

Named Packages

         package packageName;

Unnamed Packages

  class demo
    { public static void main(String args[])
        { System.output.println(“Learn Java Really”);
        }
    }    
  

Creating Package

1. Create folder(package) "realjava" having 2 sub folders(sub-packages) "loops" and "decisions" in "jdk/bin" folder.
2. Create "SumN.java" and "FactN.java" files and save them "realjava\loops" package. The code of both files is given below:
SumN.java : for sum of n natural numbers.

  package realjava.loops;
  public class SumN //Class must be public 
    { 
      public void doSum(int n)//method must be bublic
        { 
          int i=1,sum=0;
          for(i=1;i<=n;i++)
             {
                sum=sum+i;
             }
        System.output.println(“Sum=”+sum);
        }
    }

FactN.java : for factorial of n.

  package realjava.loops;
  public class FactN //Class must be public 
    { 
      public void factorial(int n)//method must be public
        { 
          int i=1,fact=1;
          for(i=1;i<=n;i++)
             {
                fact=fact*i;
             }
        System.output.println(“Factorial=”+fact);
        }
    }

3. Similarly create "Max2.java" and "Max3.java" files and save them in "realjava\decision" package. The code of both files is given below:
Max2.java : for greater of 2 numbers.

  package realjava.decision;
  public class Max2 //Class must be public 
    { 
      public void max2(int a,int b)//method must be bublic
        { 
          if(a>b)
        	System.output.println(“A is Greater" );
          else
          	System.output.println(“B is Greater" );
        }
    }

Max3.java : for greatest of 3 numbers.

  package realjava.decision;
  public class Max3 //Class must be public 
    { 
      public void max3(int a,int b,int c)//method must be bublic
        { 
          if(a>b && a>c)
        	System.output.println(“A is Greatest" );
          else
            if(b>c)
          	System.output.println(“B is Greatest" );
              else
               System.output.println(“C is Greatest" );
        }
    }

4. Using package:Create "UsePack.java" file and save it in "jdk\bin" folder. For using the ".java" file from "realjava" package we use the import declarations as shown in program below:
   

       import realjava.loops.*; //to import all files
       import realjava.decision.Max2;  //to import Max2.java file only
       class UsePack
       {
         public static vooid main(String args[])
         	{
             SumN s=new SumN();
               s.doSum(5);
             FactN f=new FactN();
               f.factorial(5);
             Max2 m2=new Max2();
               m2.max2(20,30);
               
           //using fully qualified path to use Max3.java
             realajava.decision.Max3 m3=new realajava.decision.Max3();
               m3.max3(10,30,40);  
           }
       }

   Compile and interprete the program(UsePack.java) to see the expected output.

Using/Accessing Packages

1. Import declarations
2. Fully qualified name

1. Import declarations
Import declaration statement(if any) must be the first statement after package declaration statement in your program.
Import Declaration Types:
1. Single-Type-Import Declaration.
2. Type-Import-On-Demand Declaration.
3. Single-Static-Import-Declaration.
4. Static-Import-On-Demand-Declaration.
Explanation:

1. Single-Type-Import Declaration
It imports a single type (class, interface) by specifying its canonical name. Some times fully qualified name is used as an alternative of canonical name. The difference between both can be seen in the following example:


       package p;
       class A { class AA { }
               }
       class B extends A { }

In this example p.A.AA and p.B.AA are fully qualified names but only p.A.AA is canonical name.
Syntax : Single-Type-Import Declaration:


import TypeName;

Note that, TypeName must be the canonical name of a class or an interface and it must be in existence, for example:

import java.util.ArrayList;

The above statement avails class ArrayList only from java.util package in the compilation unit.
If there are two import declarations to import a class or an interface with same name, then the compiler shows error message. Consider the following lines of code:

import packa.Rect;
import packb.Rect;

This causes compile time error because of duplicate declarations of Rect type. If the type (class or interface) imported is also declared in the same compilation unit, then the import type is ignored, as shown below:

import packa.Rect
class Rect {
        -----------
        -----------
            }

2. Type-Import-On-Demand Declarations
A type-import-on-demand declaration avails all the types (classes, interfaces) to the compilation unit.


Syntax:
       import PackageName.*;

The package name must be the canonical name of the package for example:


import java.io.*;

The above statement will avail all the public types to the compilation unit for use.
Each compilation unit automatically imports all the public types declared in the predefined package java.lang.
If there are two packages first:packa containing a class Rect and other:packb also containing a class Rect, then use the following import declarations:

import packa.*;
import packb.Rect;

The above statements will not cause compile-time error because class Rect of packb will have higher priority while instantiation.If you write the following declaration statements:

import packa.*;
import packb.*;

This will cause ambiguity error on instantiation of class Rect in compilation unit code. To resolve ambiguity, full qualifi ed path can be used as follows:

packa.Rect ref = new packa.Rect ();

3. Single-Static-Import Declarations
Using import statement to access the static members of a type (class,interface) from packages is often called static import.Using a single static import declaration, you can avail only one static member(field, method, class,interface).It means that for multiple static members, you will need multiple single-static-import declarations.


Syntax: import static PackageName.TypeName.staticMemberName;

4. Static-Import-On-Demand Declarations
It avails all static members of a type to the compilation unit.

Syntax:  import static packageName.typeName.*;

2. Fully Qualified Name
Types (classes, interfaces) from packages can be accessed without using import declarations also. It is possible using fully qualifi ed name.

Syntax:   packageName.TypeName refVar=new packageName.TypeName();

But using fully qualified name in code for use types is not a very good programming practice.

Accessibility Specifiers

Using accessibility specifiers provided in Java, a class can control the visibility of its members to the outside world.
Types of accessibility Specifiers:
1. public
2. protected
3. default (package accessibility)
4. private
Explanation:
1. public Members
The public members of a class are accessible everywhere, whether it is in the same package or in other packages. These are accessible in derived and non-derived classes whether of the same package or in other packages, as shown below:
2. protected Members
Members declared using keyword protected are accessible in all classes in the same package, whether the classes are derived or non-derived. But for other packages, these are accessible in derived classes only. However, non-derived classes of other packages can not access them, as shown follows:
3. Default/Package Accessibility Members
Members of a class, declared without any accessibility specifi er, have default accessibility. They are accessible in derived and non-derived classes of same package only. Even if the class is public, these members are not visible in other packages, as shown below:
4. private Members
The private members of a class have more restrictive access as compared to other accessibility specifi ers. It is because private members are accessible within the owning class only and other classes can not access them. Even, private members are not accessible in the derived classes of the same package. Unlike C++,members declared without any accessibility specifi er are not private, instead they have default accessibility, as shown below: