Java Applications

This is David Schwartz's attempt to give a concise explanation of the command-line enviroment and other related things. The document is based on the handout supplied to David Gries's CS100J students in Spring 2003, Sun's on-line tutorial and downloading instructions, and numerous postings from CS100/CS211 staff. For more information, see Sun's tutorial. Some sections are still under concstruction, given the upcoming changes in Java 1.5.


1. Java Programs

1.1 Applications and Applets

You can write Java programs in two general ways:

1.2 Main Class

To be an application, one Java class must contain a main method. The main method typically has this header:

Every class in Java can have a main method. The user must decide which class to use for a particular application. The class whose main you use to run your program is called the Main Class.

1.3 Files and Classes

This section describes general rules for where you place your code:

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

[need to add this section: how to save from Word, Notepad, Wordpad, using DOS's EDIT, using DOS's TYPE command to view text]

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

You must create a file in ASCII text format. 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 does 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.
  • 4. Development Enviroments

    This section provides a brief overview of how various IDEs handle Main Classes and command-line arguments.

    4.1 CodeWarrior

    4.2 Main Class settings

    4.3 Command-Line Arguments

    Other IDEs...

    need more input here

    5. Stand-Alone Java Applications (JAR Files)

    under construction!

    Working on converting and cleaning up http://www.cs.cornell.edu/courses/cs212/2003fa/Sam/DOWNLOADS/applications.html.

    5.1 Definition and Purpose

    5.2 Creating JAR files

    5.2 Running JAR files

    [ java -jar file-name.jar ]

    6. Javadoc

    under construction!

    Working on converting and cleaning up http://www.cs.cornell.edu/courses/cs212/2003fa/Sam/DOWNLOADS/applications.html. Temporary version: Suppose you write the comment for every public class and method and static or nonstatic field as follows: /** here is the comment */ That is, it begins with "/**". These are "javadoc" comments. Navigate to the directory where your Java program is and type this: mkdir doc javadoc -d doc *java

    6. User I/O and File

    under construction!

    [to add: Windows vs Unix: use System.getProperty("line.separator") (\n\r or ....)]