First, in general, setting the env var CLASSPATH usually causes more problems than it solves -- since not all app's want/need the same classpath, & often break when undesired or even unneeded jars are included in the classpath. A java app should only include the minimum number of jars it requires, no more, no less.

When you have specific, individual apps that do require that the classpath be set, then usually the command-line option is preferred: java -cp path1:path2:.... Desktop icons can have their command altered to include these options, or shell scripts can be modified to include these options.

That being said (and since there are always exceptions to the rule), then depending on the version of java (this requres java 6 or later), you can specify that a whole directory of jars be added to the classpath by adding a "*" at the end of a directory; e.g, the following:

 /dir1/foo.jar:/dir2/dir3:/dir5/dir6/*:etc...

Means:

• /dir1/foo.jar - (the single jar) will be added to the classpath;
• /dir2/dir3 - all un-jar'd classes in this directory will be added to the classpath (must be in proper package structure; e.g, com.my.Foo.class must be in /dir2/dir3/com/my/Foo.class)
• /dir5/dir6/* - all jars in this directory (i.e., /dir5/dir6/*.jar) will be added to the classpath. Note that this "*" isn't a wildcard (you can't use f*.jar or even *.jar); it's a special character indicating "add all jars"

In general, if you have to add a whole directory of jars to the application's classpath, the app was not bundled correctly. Rather, the app should have a manifest containing the list of jars it depends on. Or at the very least, only one jar should be added to your classpath, and that jar can have in its manifest the whole list of jars in some subdirectory.

To set the classpath, it is in most cases better to use the the -cp or -classpath argument when calling javac and java. It gives you more flexibility to use different classpaths for different java applications.

With the -cp and -classpath arguments your classpath can contain multiple jars and multiple locations separated with a : (colon)

javac -cp ".:/somewhere/A.jar:/elsewhere/B.jar" MyClass.java
java -cp ".:/somewhere/A.jar:/elsewhere/B.jar" MyClass

The classpath entry in the example sets the classpath to contain the current working directory (.), and the two jar files A.jar and B.jar.

If you want to use the CLASSPATH environment variable you can do

export CLASSPATH=".:/somewhere/A.jar:/elsewhere/B.jar"
javac MyClass.java
java MyClass

For JAR files, you have to set the CLASSPATH and not the PATH environment variable.

If you're using BASH, it is: export CLASSPATH="$CLASSPATH:<full_path_to_each_jar_files>"

You better add it in the file .bashrc unless you know what you are doing.

Example:

export CLASSPATH="$CLASSPATH:$HOME/java/lib/foebar.jar:$HOME/extra/lib/another.jar"

But of course, if you are still invoking the jar file with the Main class you have to use the full path for it:

java -jar $HOME/java/lib/main-prog.jar

However, you can set its execution right and run it:

chmod u+x $HOME/java/lib/main-prog.jar
export PATH=$PATH:$HOME/java/lib
main-prog.jar

But you have to take care that your classpath is correct and list all required jar.

CLASSPATH is not meant to search for jars. It is meant to search for classes. Putting a jar in CLASSPATH means java will see the classes inside the jar, but not the jar itself.

What you want is more likely a shell script wrapper starting the jar.

Create a text file containing the following lines:

#!/bin/sh
java -jar /usr/local/bin/gatk/GenomeAnalysisTK.jar

Make the file executable (suppose you name it GenomeAnalysisTK):

chmod +x GenomeAnalysisTK

Put that file in /usr/local/bin or ~/bin or wherever you want provided the path is in your $PATH.

From now on you can call the shell script and it will start the jar. No need to mess with CLASSPATH anymore.

Alternatively: with the jar in the classpath you can start the main class from inside the jar like this:

java org.broadinstitute.sting.gatk.CommandLineGATK

The main class of the jar is specified in the file META-INF/MANIFEST.MF inside the jar. For more information see the wikipedia article about jar files.

First thing to note - you're not using "Putty" to set the CLASSPATH, you're using the 'shell' that you login to, using Putty as your SSH client.

Depending on your shell, there are different ways to set your classpath -

Bash (or compatible shells

export CLASSPATH=/full/path/to/xalan.jar:/full/path/to/serializer.jar:/full/path/to/xml-apis.jar:/full/path/to/xercesImpl.jar:$CLASSPATH

C Shell (or compatible shells)

setenv CLASSPATH /full/path/to/xalan.jar:/full/path/to/serializer.jar:/full/path/to/xml-apis.jar:/full/path/to/xercesImpl.jar:$CLASSPATH

You should add your jar files to your CLASSPATH instead:

export CLASSPATH=/home/somebody/lib/java/a.jar:/home/somebody/lib/java/b.jar

The classpath supports directories (with *.class files) or individual jar files. You can also add wildcards (or use java -classpath option) but I will leave that off for now to don't further complicate things ;)

By the way, you don't need to change your PATH environment variable at all. The CLASSPATH is more than enough.

Say you have multiple jar files a.jar,b.jar and c.jar. To add them to classpath while compiling you need to do

$javac -cp .:a.jar:b.jar:c.jar HelloWorld.java

To run do

$java -cp .:a.jar:b.jar:c.jar HelloWorld

Typically you specify the classpath when you start your java program with the switch java -cp your.jar xxxx.java

But you can also permanently add it to your java installation by copying the jar to the default-java/jre/lib/ext folder.

Finally take a look at this question: Setting multiple jars in java classpath

OK, I finally figured this out by myself. This is how you correctly add modules, which the JAR expects to be present:

/usr/bin/java --module-path /usr/share/java/jaxws-api.jar --add-modules jaxws.api -jar exchange-sync.jar

So it does not really have anything to do with the classpath, it's just about adding the module.

The package name doesn’t include bin, and you need to list the JARs on the classpath:

CLASSPATH=bin
for jar in lib/*.jar; do CLASSPATH="$CLASSPATH:$jar"; done
export CLASSPATH
java com.program.d1.Main

Your problem is min separator you are using. Separator ; is for windows. On Unix systems you should use : instead:

java -classpath "bin:mysql-connector-java-5.1.19-bin.jar" MyProgram