Java Classes How does it find them?
Java Classes
How does it find them?
Basic Approach
• Different from c++.– Uses header files for prototypes– uses INCLUDE variable to indicate location
of .h files not in system directories– libraries are stored elsewhere and located by
LIB variable
• Java uses only the java source.– No prototypes– uses a more complex naming/search scheme– details follow
C++
#include “myclass.h”
void main ()
{ myclass x;
…..
}
public class myclass()
{ int a;
int b;
public:
myclass();
~myclass();
…..
}
myclass.cpp
myclass.h
How does c++ find theheader files? .. Searching the “include” path.
No “include” in Java!
Only one file!
Java connects files with“package” and “import”
package •Groups class definitions together for privileged access, lets other classes in the package see more details •Generally a way of grouping a set of library routines
import •Very similar to include, but there is no include file counterpart •Identifies all packages OTHER THAN the one that class is in, from which this class needs access
Directory location is important
• Classes in the same package are stored in directory hierarchies to help import find the files.
• These directories also aid in resolution of ambiguous naming problems.
• More later….
package first;
class classB { // most of your code}
package first;
class classA { classB b = … new classB();}
Two classes defined to be in package first
Being declared in the same package will allow each class to access each other without extra work.
classA using classB
classA.java
classB.java
package second;
class classB { // most of your code}
package first; import second;class classA { classB b = … new classB();}
Two classes in different packages!
Being declared in the different package will require the use of import to access each other.
classA.java
classB.java
Package names• Can be dotted to show directory organization
• Example– math.algebra.sets– math.calculus.integration– math.calculus.differentiation
math
algebra calculus
integrationsets differentiation
import math.*; orimport math.algebra.sets;
Example Format of a filepackage com.myplace.mygroup.myclass; // OPTIONAL
import java.io.*; // OPTIONALimport anotherclass.mathlib.vectors; // OPTIONAL
public class thisclass { // most of your code}
So let’s examine this one element at a time.
package com.myplace.mygroup.myclass; // OPTIONAL
import java.io.*; // OPTIONALimport anotherclass.mathlib.vectors; // OPTIONALpublic class thisclass { // most of your code}
•Provides a solution to the problem of generating a unique package name•Groups classes for more convenient use of related classes.•Defines the package in which a class is placed•Helps to define the directory in which the compiled file will be placed•Only ONE package statement per file because a class can only be in a single package.•If no package, class is considered to be in default package.
Unique package names• Lots of programmers in the world
• Significant opportunity for redundant naming of classes
• General principle -> namespaces
• Here, classes are grouped in packages to provide a means to give uniqueness to name– two programmers name the routine x
• com.mycompany.billy.io.x
• com.mycompany.sam.io.x
– x can be uniquely identified by qualification
Package name -> Directory name• A package name dictates the directory
structure in which class is stored.
• Does NOT indicate the complete path but a path that exists somewhere.
• E.g., com.mycompany.billy.io.x/
bin home ?
com
company
billy
iox
iox
sam
It DOES provide a unique name to usein accessing x!
package com.myplace.mygroup.myclass; // OPTIONAL
import java.io.*; // OPTIONALimport anotherclass.mathlib.vectors; // OPTIONALpublic class thisclass { // most of your code}
•Directly related to packages•Used to provide a shorthand•Used for accessing OTHER classes NOT related to the package statement (if it exists in the file)•CAN have import without package and vice versa.•While they are related, the use of the use of them in the SAME file is typically independent/coincidental•package defines the package THIS class is IN•import used to ease USE of classes in OTHER packages
import just makes is easier!
• The names have a tendency to be long in order to be unique
• import lets you use a shorthand for qualification.
• Like “with” in pascal to avoid listing all substructures in a record to access names.
• Example follows:
How to define the CLASSPATH
/
bin home develop
com
company
billy
iox
iox
sam
Using a unix example,the code references “com..”In order to reference com.company.billy.io.xthe CLASSPATH must include /dev, everythingup to but not includingcom.
CLASSPATH= /lib/java;/develop
What can one import access?import examples
company
billy
io
x
com
y
logoorganization
red - directoriesblack -> classes
// can’t access ANY classesimport com;
// can access // logo and organizationimport com.company.*;
// can’t access ANY classesimport com.*;
// can access only x import com.company.billy.io.x;
Which x?package com.myplace.mygroup.myclass; // OPTIONAL
import com.mycompany.sam.io.x;
public class thisclass { // most of your code x thisx = new x;}
Here x can be referenced in shorthand and is uniquelydefined to be the x in the io package defined by sam.
This also emphasizes disconnect between the packagein the package statement and the package in the import.
What about * in import?
package com.myplace.mygroup.myclass; // OPTIONAL
import com.mycompany.sam.io.*;
public class thisclass { // most of your code x thisx = new x; y thisy = new y;}
* indicates that you can shorthand any class in the package.
In this example, y is considered to be in the same io packageand can be accessed in the same manner as x (shorthand).
So how does java figure outEXACTLY where to put package?
• We used a ‘?’ in directory to indicate it was not known where.
• Determined at compile time
• uses -d option to say where
• E.g.– javac -d /project1/devstuff thisclass
– creates the package and the com.mycompany… directory under /project/devstuff
– /project/devstuff/com/mycompany/mygroup/...
Now how does it find the class when it compiles the program?
· 1. Look in java system class directories
· 2. Look in extensions directory (???)
· 3. Look in CLASSPATH.· Environment variable· default is current directory· unix example: .:/project/dev/java:/home/dgame/611
· current directory first
· then /project/dev/java
· and lastly /home/dgame/611
Confusion• Search of path is documented in
contradicting manner
• O’reilly Java in a Nutshell:– “The interpreter always appends the location of
the system classes to the end of the path specified by the environment variable.”
• other references indicate it searches in the system first.
• Regardless, there can be no naming ambiguity
What if there are 2 classes with the same name?
• Compiler will alert you if there are multiple names in the path AND no means to resolve the ambiguity (import) is coded.
• Using import resolves which one you are referencing.
• If error message occurs, use more specific reference to the class.