Java Applications

This is David Schwartz's attempt to explain all about 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.

• 1. Java Programs
• 2. Command-Line Environments
• 3. Command-Line Environments Arguments
• 4. Development Environments
• 5. Stand-Alone Java Applications (JAR Files)
• 6. Javadoc

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 Main Class

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

public static void main(String[] args)

1.3 Files and Classes

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

• All code (except for import statements) must be written inside a class.
• One class must be public and contain a main method. The main method header must declare mainpublic static void:
  • 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 Thing {
                 public static void main(String[] args) {
    	        Thing t = new Thing(); 
                    /* code that uses t */ 
                 } 
              }

• Each class should be in a separate file called Classname.java. You can break this rule, but we strongly advise against doing so!
• Each file should contain one public class. All other classes should not have public in their headers. You can actually break this rule if you a database-driven IDE, like CodeWarrior, but we strongly advise against doing so!

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 windowing environments, text-based screens were all we had. Talk to some older computer users, and they will regale you will 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 DOS:

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

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 windowing 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.0

TO ADD: ASCII TEXT/WHAT IS IT?/HOW TO SAVE FROM WORD, NOTEPAD, WORDPAD,..../EXAMPLE JAVA PROGRAM TO DEMO CHAR TYPE/USING DOS TO VIEW A TEXT FILE (> TYPE FILENAME -- IF YOU SEE ONLY TEXT, THE FILE IS TEXT :-)

2.2.1 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.
• Unix: Use emacs. Enough said.
• 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.2 Other Text Editors

You must create a file in ASCII text format. Some commonly used text editors are as follows:

• Emacs
• SynEdit
• EditPad Lite

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_01\.
  • Unix: On my system, /usr/j2se.
  • Max: 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:>\j2sdk1.4.2_yourversion\bin\javac  C:\docume~1\dis\desktop\a2cs211fa03\MyProgram.java

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&rarrControl 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:\j2sdk1.4.2_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 set classpath=. or sett classt path=%classpath%;.

   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]);
         }
      }
   }