Java classpath
The Java™ virtual machine uses the Java classpath to find 
classes during runtime. Java commands and tools also use 
the classpath to locate classes. The default system 
classpath, the CLASSPATH environment variable, and the 
classpath command parameter all determine what directories 
are searched when looking for a particular class.
In the Java 2 Software Development Kit (J2SDK), Standard 
Edition, the java.ext.dirs property determines the 
classpath for the extensions that are loaded. 
The default bootstrap classpath is system-defined, and you 
should not change it. On your server, the default bootstrap 
classpath specifies where to find the classes that are part 
of the IBM® Developer Kit for Java, the Native Abstract 
Window Toolkit (NAWT), and other system classes.
To find any other classes on the system, you must specify 
the classpath to search by using the CLASSPATH environment 
variable or the classpath parameter. The classpath 
parameter that is used on a tool or command overrides the 
value that is specified in the CLASSPATH environment 
variable.
You can work with the CLASSPATH environment variable using 
the Work with Environment Variable (WRKENVVAR) command. 
From the WRKENVVAR display, you can add or change the 
CLASSPATH environment variable. The Add Environment 
Variable (ADDENVVAR) command and Change Environment 
Variable (CHGENVVAR) command either add or change the 
CLASSPATH environment variable.
The value of the CLASSPATH environment variable is a list 
of path names, separated by colons (:), which are searched 
to find a particular class. A path name is a sequence of 
zero or more directory names. These directory names are 
followed by the name of the directory, the ZIP file, or the 
JAR file that is to be searched in the integrated file 
system. The components of the path name are separated by 
the slash (/) character. Use a period (.) to indicate the 
current working directory.

Q2(A)
In the Java programming language, an interface is a 
reference type, similar to a class, that can contain only 
constants, method signatures, and nested types. There are 
no method bodies. Interfaces cannot be instantiated—they 
can only be implemented by classes or extended by other 
interfaces. Extension is discussed later in this lesson. 

java comes with the Swing widgets. The only hard part is 
learning the different Layout methods. We have to have a 
LayoutManager in a top-level container -- such as a JFrame. 
The Layout will divide up all the space to present the 
buttons, listboxes, checkboxes and so forth. Really, the 
Sun Swing tutorials are the best route to learning GUI.

Defining an interface is similar to creating a new class: 
public interface OperateCar {

   // constant declarations, if any

   // method signatures
   int turn(Direction direction,   // An enum with values 
RIGHT, LEFT
              double radius, double startSpeed, double 
endSpeed);
   int changeLanes(Direction direction, double startSpeed, 
double endSpeed);
   int signalTurn(Direction direction, boolean signalOn);
   int getRadarFront(double distanceToCar, double 
speedOfCar);
   int getRadarRear(double distanceToCar, double 
speedOfCar);
         ......
   // more method signatures
}
Note that the method signatures have no braces and are 
terminated with a semicolon. 
To use an interface, you write a class that implements the 
interface. When an instantiable class implements an 
interface, it provides a method body for each of the 
methods declared in the interface. For example, 
public class OperateBMW760i implements OperateCar {

   // the OperateCar method signatures, with 
implementation --
   // for example:
   int signalTurn(Direction direction, boolean signalOn) {
      //code to turn BMW's LEFT turn indicator lights on
      //code to turn BMW's LEFT turn indicator lights off
      //code to turn BMW's RIGHT turn indicator lights on
      //code to turn BMW's RIGHT turn indicator lights off
   }

   // other members, as needed -- for example, helper 
classes
   // not visible to clients of the interface

}
In the robotic car example above, it is the automobile 
manufacturers who will implement the interface. Chevrolet's 
implementation will be substantially different from that of 
Toyota, of course, but both manufacturers will adhere to 
the same interface. The guidance manufacturers, who are the 
clients of the interface, will build systems that use GPS 
data on a car's location, digital street maps, and traffic 
data to drive the car. In so doing, the guidance systems 
will invoke the interface methods: turn, change lanes, 
brake, accelerate, and so forth.