Setting classpath in java mac

In setting up JDK and Java applications, you will encounter these environment variables: In short:. To display a particular variable, use command " set varname ". For examples,. Try issuing a set command on your system, and study the environment variables listed.

Pay particular attention to the variable called PATH. Variables in Unixes are case-sensitive. Local variables available to the current process only are in lowercase. Under bash shell:. Take note that files beginning with dot. To display hidden files, use command " ls -a " or " ls -al ". For example,. Take note that Bash shell uses colon: To refresh the bash shell, issue a " source " command or re-start the bash shell:. Notes For the older csh C-shell and ksh Korn-shell. When you launch a program from the command line, the operating system uses the PATH environment variable to search for the program in your local file system.

In other words, PATH maintains a list of directories for searching executable programs. When you launch an executable program with file extension of ". If the program cannot be found in these directories, you will get the following error:. For example, if Java Compiler " javac. PATH maintains a list of directories.

The directories are separated by semi-colon ';'. The JDK's " bin " directory should be listed before " c: This is because some older Windows systems provide their own Java runtime which is often out-dated in these directories try search for " java. But as PATH is frequently used, a dedicated command called path is provided.

In Windows, the current working directory '. In other words, the current working directory is searched first, before searching the other entries specified in PATH , in a the order specified. DO NOT remove any existing entry; otherwise, some programs may not run. When you launch an executable program with file permission of executable in a Bash shell, the system searches the program in ALL the directories listed in the PATH.

Managing the Java classpath (UNIX and Mac OS X)

This is given as a path to that file from the current working directory. For example, suppose you are in the project directory shown in Figure 1. This directory contains an src directory.

The src directory contains a com directory, which contains the example directory, which contains the Fraction. The following command line compiles it:. If you see this error message, check each piece of the path to make sure it's spelled correctly. Then check that the file really is where it's supposed to be by doing an ls like the one shown here:. This problem usually indicates a mistyped path, but it can also mean that you're not in the directory you think you're in. In this example, you'd check to see that the current working directory is the project directory.

The pwd command is helpful here.

Assuming there are no syntax errors, javac places the compiled. You do not want this. This makes clean builds problematic and tends to result in versioning problems. It also makes it hard to jar up just the compiled. Therefore, you need to tell the compiler to put the compiled output in a completely different directory. The -d switch specifies the output directory usually called bin, build, or classes:. Now the output is as shown in Figure 2. You do not need to do it manually. The directory where Java looks for source files is called the sourcepath.


  • Package structure;
  • Description!
  • counter strike go config mac;
  • How do I set a CLASSPATH for java? | Mac Support.
  • canon mp250 printer driver for mac.

In the scheme outlined here, this is the src directory. It is the directory that contains the hierarchy of source files, organized into their own directories. Most projects use more than one class and more than one package. These are connected by import statements and fully package-qualified class names. For example, suppose you now create a new MainFrame class in the com.

This class uses the com. Fraction class in a different package from the MainFrame class. The source setup is now as shown in Figure 3. I have deleted the compiled output from the previous step. I can always compile it again. Now let's see what happens when I try to compile MainFrame. The errors in Listing 2 happened because although javac knew where to find MainFrame.

You'd think it would be smart enough to notice the matching package hierarchies, but it's not. To clue it in, I have to specify the sourcepath. This specifies the directories where the compiler looks for the hierarchy of source files. In Listing 2, that's src. So I use the -sourcepath option, like so:. Now the program compiles without error and produces the output shown in Figure 4. Notice that javac also compiled the file Fraction. You can actually have more than one directory in your sourcepath, separated by colons, though this is usually not necessary.

This command does not compile every file found in either of those hierarchies. It only compiles the files referenced directly or indirectly by the single. Much more commonly, you'll have a single source directory for. This is the role of the classpath. In medium-to-large projects, recompiling every file every time can be time-consuming. You can ease this burden by separately compiling and storing independent parts of the same project in different classes or bin directories.

These directories are added to the classpath. There are several ways to add a class to the classpath. The -classpath command-line switch is the only one you should use, however. Then I would include them both separated by a colon, like this:. Directories whose names match package names com, elharo, math, etc. Of course, you can use various forms of relative paths if you prefer. For instance, if project1 and project2 are siblings of the current working directory that is, they have the same parent directory , then I could reference them like this:.

So far, I've assumed the program is complete onto itself and does not use any separately compiled third-party libraries. If it does, you'll need to add them to the classpath too.


  1. .
  2. Environment Variables for Java Applications - PATH, CLASSPATH, JAVA_HOME.
  3. mac and cheese chicken pot pie.
  4. mac os lion boot camp windows 7;
  5. vocal editing software free mac!
  6. .
  7. Libraries are usually distributed as JAR files such as junit. In this case, it is the JAR file itself that you add to the classpath, not the directory that contains it. In essence, the JAR file acts as a directory that contains compiled. For example, the following command adds three things to the classpath: JAR files are only used for. You have now successfully compiled your program, and are ready to run it.

    This is similar to but simpler than compiling. When running a program, you only need to specify two things:. Usually the classpath is the same classpath you used to compile the program, with the addition of the directory where the compiled output was placed. For example, if the compile command was this:. MainFrame , then you would run the program like this:.

    co.organiccrap.com/153102.php

    Setting the class path

    Take careful note that the last item on the command line is a class name. It is not a file name. It does not end in. This class must be found somewhere on the classpath. I strongly recommend that you always explicitly specify the classpath when you compile and when you run.

    Set JAVA_HOME and path for JDK on Linux

    There are other places you can put files so that they are added to the classpath and found by both the javac compiler and the java interpreter. These options save only a little amount of typing, and they do so at the expense of a large amount of debugging when -- not if -- you accidentally place an old version of a class in the classpath. In this section, I'll show you some of the places you might expect to find classes hiding, that unexpectedly pop into your classpath and cause problems. This is especially likely to happen on machines you don't control, such as a server.

    Your Answer

    The compiler uses the current working directory. However, as soon as you set the classpath in some other way--e. You have to add the current working directory to the classpath just like any other directory. In either case, it's too easy to forget what is or isn't in the same directory as you are.

    Thus, try to avoid putting any classes or hierarchies into your project or home directory. Instead, always keep things neatly separated into src directories for. After a while, you may get tired of manually adding the bin directories and JAR archives to the classpath. Then you don't have to type their paths every time you run javac or java. Resist this temptation. It will cause problems when you load the wrong class or the wrong version of a class. Any time you save typing now will be taken back from you a hundred times over in debugging problems caused by accidentally loading the wrong classes.

    There are better ways to automate classpaths and avoid typing. Sooner or later probably sooner , you'll load the wrong version of a class from a place you aren't even thinking about and waste hours debugging. This problem is especially serious when deploying server-side applications.

    Problems caused by the wrong version of a JAR archive in the classpath can be extremely hard to debug if you don't recognize the symptoms or know just what to look for. To avoid these problems, some frameworks have even gone so far as to write their own class loaders that bypass Java code's usual class loading mechanisms. The difference is that these files are actually added to the bootclasspath rather than the usual classpath and can replace the standard classes shipped with the JDK.