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.

Java Programs
Command-Line Environments
Command-Line Arguments

1. Java Programs

1.1 Applications and Applets

You can write Java programs in two general ways:

Java applet: Program that run a browser. See http://java.sun.com/docs/books/tutorial/applet/index.html.
Java application: Program that runs "on its own" (not from a browser) by executing the main method of a given class. A Java application is typically composed of many classes.

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:

All code (except for import and package statements) must be written inside a Java class.
In terms of good style, you should write each class in a separate .java file called Classname.java.
If you choose to include more than one class in a .java file, you must modify only one of those classes as public. All other classes must not have public in their headers. (Some IDEs allow you to break this rule, but since we use the JDK command line to compile your code, you must not break this rule!
The name of the file must correspond to the name of public class. So, if your file is called Blah.java, the file must contain a public class called Blah. No other classes in that file should be public.

Examples:

Thing.java	A.java
`public class Thing { }`	`class C { } public class A { } class B { }`

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:

Test.java

public class Test {}
   public static void main(String[] args) {
      Thing t = new Thing();
      t.print("Hello,"); 
      t.print(" world!");
      t.print("\n");
   }
}
class Thing {
   public void print(String s) {
      System.out.print(s);
   }
}

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:

javac Test.java (compile the program)
java Test (run the program)

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?

public: allow an outside source/user to call the method.
void: the main method returns nothing.

static: the outside user/source doesn't create an object of the Main Class. However, the code inside the class can create an object of that class. For example,

public class MyThing {
   public static void main(String[] args) {
      MyThing t = new MyThing(); 
      t.something();
   } 
   private void something() {
      System.out.println("Hi!");
   }
}

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:

Command windows: Assuming you download a copy of the JDK, you can compile and run your programs from a command window. A command window is special kind of window in which you enter text-based commands to your operating system to perform a variety of tasks. Before we had window environments, text-based screens were all we had. Talk to some older computer users, and they will regale you with tales of teletype and punchcards....
Command line: The area in a window in which you type commands. You press Enter or Return after typing your commands.
Command prompt: A special collection of characters that indicate where you should type your command line.

2.1.1 Using Microsoft Windows

Accessing command windows:

From Start menu, select Run. In the window that pops up, enter cmd.
Try also Start→All Programs→Accessories→Command Prompt.
For more information, see Sun's tutorial.

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

C:: change to a particular drive.
dir: list files in a directory. Try dir | more to page through long listings.
tree: show directory tree for current directory.
cd: change directories.

For names with spaces, use ~1. For example, to access Program Files on the C drive,
To move up one directory, use cd ...
Desktop: I use cd C:\docume~1\dis\desktop.

type: view contents of a file. For example, type Thing.java.
edit: create/edit/save a text file.
copy: copy a file. For example, copy Thing.java ThingCopy.java.
ren: rename a file. For example, ren ThingOld.java ThingNew.java.
del: delete a file. For example, del Thing.java.

2.1.2 Mac

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

2.1.3 Unix

Unix windows:

All hail Unix!
If you're using Unix, you probably don't need any help :-)
See here just in case.
For information on window environments in Unix, see http://www.plig.org/xwinman/.

Unix commands:

http://www.bsd.org/unixcmds.html
See also Introduction to Unix by David I. Schwartz

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:

General information about characters and codes: http://www.lookuptables.com
Quick overview of ASCII: http://www.eresumeiq.com/ABC.html

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

Microsoft Windows: If you do not wish to install another text editor, use Notepad or Wordpad, but be sure to save your work in ASCII or UNICODE text format. See also the DOS command edit. If you do not get line breaks or you a lot of mysterious "boxes." try another editor. A nifty trick is loading the document into a web browser and then saving back to ASCII.
Unix: Use emacs. Enough said. Some people prefer vi.
Mac: I have no idea what you use at this point.

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:

Java software: Look for a directory name, like j2sdk, jdk, j2se:
- Microsoft Windows: The Java software commands are somewhere in C:\, like C:\j2sdk1.4.2_03\.
- Unix: On my system, /usr/j2se.
- Mac: beats me.
Inside the Java directory, there is a subdirectory called bin. Inside of it, you will see programs called javac and java:
- javac: This program compiles your Java programs (.java extensions) into class files .class extensions) that contain Java bytecodes. In Microsoft Windows, this program is called javac.exe.
- java: This program runs your compiled Java classes. In Microsoft Windows, this program is called java.exe.
Java file: You need to pick a specific place to put your Java files. Generally, you should create a new directory each time you want to work on a new program with multiple classes.

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:

C:\Program Files\Java\jdk1.5.0_01\bin\javac 
            C:\docume~1\dis\desktop\MyProgram.java

To run a compiled program, you issue this command:

C:\Program Files\Java\jdk1.5.0_01\bin\java 
            C:\docume~1\dis\desktop\MyProgram

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:

Select Start→Control Panel and find System. On my system its under Performance and Maintenance.
Click on the Advanced tab.
Click on the Environment Variables button.
Select PATH in the System Variables portion of the panel.
Click on the Edit button.
Move the end of the PATH value.
Enter a semicolon ; and then the path to your Java software, followed by the word bin. For example, on my system I have entered the following:
```
;C:\Program Files\Java\jdk1.5.0_01\bin\
```
Note the semicolon in front of this path to separate it from the previous individual path in the list.

Click OK. If you are finished, click OK on the Environment Variables and OK on the System Properties window.
To check the current path, enter path at the prompt in a command window.

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.

Access the Environment Variables panel, just as you did for changing PATH.
See if a variable called CLASSPATH is set in the User variables panel.
Either create or change CLASSPATH to be just . (just one period). The lone period means the current directory. So, when you run the Java compiler (javac.exe) or interpreter (java.exe), Java will use the current directory to compile or run the Java files you specify on the command line.

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:

My alias for javac is /usr/j2se/bin/javac.
My alias for java is /usr/j2se/bin/java.

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!

Open a command window.
Change directories to the directory that contains the Java files you want to compile:

To compile a single file, enter javac MyProgram.java.
To compile all Java files in the directoy, enter javac *.java.

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!

Open a command window.
Change directories to the directory that contains the Java files you want to compile.
Enter java MyProgram, where MyProgram is the name of Main Class:

Recall that the Main Class is the class that with main that you want to run.
Do not enter java MyProgram.java or java MyProgram.class.

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:

The name of parameter, which is typically args could be any legal Java name.
When you run a program, the command java and Main Class MyProgram are not included as command-line arguments unlike some other languages.
If you enter no arguments, args is an array of length zero.
If you enter at least one arugment, each argument is read as a Java String and stored in args from left to right, starting at index 0 in the args array.
Special characters, like the double quote (”) must be quoted with a backslash (\).

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, ....