[Chapter 2] How Java Differs from C

#

| Chapter 2 |

# 2. How Java Differs from C

Contents:
The Name Space: Packages, Classes, and Members
Comments
No Preprocessor
Unicode and Character Escapes
Primitive Data Types
Reference Data Types
Objects
Arrays
Strings
Operators
Statements
Exceptions and Exception Handling
Miscellaneous Differences

Java is a lot like C, which makes it relatively easy for C programmers to learn. But there are a number of important differences between C and Java, such as the lack of a preprocessor, the use of 16-bit Unicode characters, and the exception handling mechanism. This chapter explains those differences, so that programmers who already know C can start programming in Java right away!

This chapter also points out similarities and differences between Java and C++. C++ programmers should beware, though: While Java borrows a lot of terminology and even syntax from C++, the analogies between Java and C++ are not nearly as strong as those between Java and C. C++ programmers should be careful not to be lulled into a false sense of familiarity with Java just because the languages share a number of keywords.

One of the main areas in which Java differs from C, of course, is that Java is an object-oriented language and has mechanisms to define classes and create objects that are instances of those classes. Java's object-oriented features are a topic for a chapter of their own, and they'll be explained in detail in Chapter 3, Classes and Objects in Java.

## 2.1 Program Structure and Environment

A program in Java consists of one or more class definitions, each of which has been compiled into its own .class file of Java Virtual Machine object code. One of these classes must define a method `main()`, which is where the program starts running. [1]

> [1] Method is an object-oriented term for a procedure or function. You'll see it used throughout this book.

To invoke a Java program, you run the Java interpreter, java, and specify the name of the class that contains the `main()` method. You should omit the .class extension when doing this. Note that a Java applet is not an application--it is a Java class that is loaded and run by an already running Java application such as a Web browser or applet viewer.

The `main()` method that the Java interpreter invokes to start a Java program must have the following prototype:

    public static void main(String args[])

The Java interpreter runs until the `main()` method returns, or until the interpreter reaches the end of `main()`. If no threads have been created by the program, the interpreter exits. Otherwise, the interpreter continues running until the last thread terminates.

### Command-Line Arguments

The single argument to `main()` is an array of strings, conventionally named `args` or `argv`. The length of this array (which would be passed as the `argc` argument in C) is available as `argv.length`, as is the case with any Java array. The elements of the array are the arguments, if any, that appeared on the interpreter command line after the class name. Note that the first element of the array is not the name of the class, as a C programmer might expect it to be. Example 2.1 shows how you could write a UNIX-style echo command (a program that simply prints out its arguments) in Java.

#### Example 2.1: An Echo Program in Java

    public class echo {
        public static void main(String argv[]) {
            for(int i=0; i < argv.length; i++)
                System.out.print(argv[i] + " ");
            System.out.print("\n");
            System.exit(0);
        }
    }

### Program Exit Value

Note that `main()` must be declared to return `void`. Thus you cannot return a value from your Java program with a `return` statement in `main()`. If you need to return a value, call `System.exit()` with the desired integer value, as we've done in Example 2.1. Note that the handling and interpretation of this exit value are, of course, operating-system dependent. `System.exit()` causes the Java interpreter to exit immediately, whether or not other threads are running.

### Environment

The Java API does not allow a Java program to read operating system environment variables because they are platform-dependent. However, Java defines a similar, platform-independent mechanism, known as the system properties list, for associating textual values with names.

A Java program can look up the value of a named property with the `System.getProperty()` method:

    String homedir = System.getProperty("user.home");
    String debug = System.getProperty("myapp.debug");

The Java interpreter automatically defines a number of standard system properties when it starts up. You can insert additional property definitions into the list by specifying the `-D` option to the interpreter:

    % java -Dmyapp.debug=true myapp

See Chapter 14, System Properties for more information on system properties.

A Simple Example |  | The Name Space: Packages, Classes, and Members