Java Applications

This is a concise explanation of the command-line environment and other related things. For more information, see Sun's tutorial. Some sections are still under construction, as Java continues to evolve.

  1. Java Programs
  2. Command-Line Environments
  3. Command-Line Arguments

1. Java Programs

1.1 Applications and Applets

You can write Java programs in two general ways:

1.2 Files and Classes

An application that you write is usually either a single text file (see also Section 2.2.1) or collection of text files. You can also use Jar files, but for now, just focus on code that you write. Each file that you write will contain Java code and, thus, have the extension .java. You need to follow certain rules when creating these files:

Examples:

1.3 Main Class

To be an application, at least one Java class inside a Java file must contain a main method. The main method has this header:

      public static void main(String[] args)
Which class should contain main? Use the public class from one of the .java files that form your program. We specify the class that contains the main method that starts your program as the Main Class. When you run a program, Java starts with the main method from the Main Class.

Example:

We explain how to specify a Main Class at the command line in Sections 2.5 and 2.6. If you would like to get a head start, (and are willing to check if your PATH and CLASSPATH are set), try the following commands:

Why bother with a Main Class? Java allows each class in a program to have its own main method. So, you can actually change which class to use to start your program.

What do the public static void modifiers mean?

2. Command-Line Environments

2.1 Operating Systems and Window Environments

The advice herein is really just a snippet of Sun's instructions at http://java.sun.com/docs/books/tutorial/getStarted/cupojava/index.html:

2.1.1 Using Microsoft Windows

Accessing command windows:

Using MSDOS: for a full set of DOS commands, enter help at the DOS prompt. I've summarized common commands, below:

2.1.2 Mac

We need more info here. For now, see Sun's tutorial.

2.1.3 Unix

Unix windows:

Unix commands:

2.2 Editing Java Programs

Inside a command window, you can enter all of Java command along with operating systems commands, but your system must be set up to know where the commands reside. The primary Java commands that you need (java ,javac) are located in the directory that contains the JDK programs.

2.2.1 ASCII Text

ASCII text, or plain text (or even just text) is a universal format for characters that you type. When you use a proprietary editor, like Word or OpenOffice, those program convert your characters into a relatively indecipherable format. But when you use a text editor or save your work to text, your file can be viewed by pretty every editor. Plain text abounds: the format used for writing HTML, programs, e-mail, and characters you type at the command line. If you want to dig a bit further, you need to know about bits and bytes. For more information, try the following links:

To test a file to determine if it is ASCII, try viewing it with a command like type (Windows) or more (Unix, Mac), loading it into a webpage, using an IDE's built-in editor.

2.2.2 Common Editors

Note that you can use the text editors that are part of most IDEs.

2.2.3 Other Text Editors

Some commonly used text editors are as follows:

2.3 Compiling and Running Java Programs

There are two directory paths (the list of directories from the top to the current directory) that you need to keep track of:

2.4 Path and Classpath Variables

To find your Java files, your operating system needs to "know" which Java files to compile and run. For example, if you do not want to bother setting the Microsoft Windows PATH variable, you might have to enter something like the following command-line to compile a Java program called MyProgram:

To run a compiled program, you issue this command:

Irritating, isn't it? See below for salvation!

2.4.1 Microsoft Windows

I recommend that you permanently set the PATH variable for all command windows:

When you want to run Java commands on specific files, you have the same issue: The operating system needs to know which files you want to act upon. You can either type the path name for each file or use Java's CLASSPATH variable.

To temporarily set the path variables, use this: set classpath=. or set class path=%classpath%;. (include the .)

For more information, see Sun's Installation Guide and Additional Help.

2.4.2 Unix

Some minor help:

See Sun's help for more information.

2.4.3 Mac

need someone to fill this in....

2.5 Compiling A Java Program From The Command-Line

Assuming you have set you system's paths as described in Section 2.4 above, you have very little work to compile a Java program!

Assuming you have programmed perfectly, your current directory will now contain .class for all classes in the Java files in that directory.

2.6 Executing A Java Program From The Command-Line

Again, assuming you have set you system's paths as described in Section 2.4 above, you have very little work to run a Java program!

3. Command-Line Arguments

3.1 Definition

Command-line arguments are strings that you supply to the main method from the command-line. How do they work? Since main is a method that you activate at the prompt, you (and the operating system) are effectively another part of a larger program that is calling a particular method. Since all methods can take arguments, why can't main? So, whatever you type after java MyProgram at the command-line is entered in the arguments of main.

3.2 Applications

Command-line arguments have great importatn when you want various applications to "communicate" with each other when developing larger tools. When programming in C and doing Unix development, communicating at the command-line is crucial. Moreover, having the ability to enter data directly into main makes running larger numbers of the same program vastly easier for grading!

3.3 Syntax

Method main expects the user to enter zero to many strings. Here are some rules:

Since command-line arguements are often meant to be values other than strings, you will need to use methods, like Integer.parseInt(String) and Double.parseDouble(String). For example, if the user enters java MyProgram 1 to particular program, inside MyProgram's main method the programmer, could write Integer.parseInt(args[0]) to convert the String "1" to an integer 1.

3.4 Example

Compile the following program:

   public class TestArgs {
      public static void main(String[] args) { // could use any name for args!
         for (int i=0; i < args.length; i++)
            System.out.println(args[i]);
         }
      }
   }

Run the program at the command-line as follows:

  • java TestArgs: no output.
  • java TestArgs a 1 outputs a and 1 on new lines.
  • To Be Continued....

    Javadoc, Jar files, User I/O, File I/O, Mac, ....