Class 30: Getting Started with Java

Held: Tuesday, 11 March 2003

Summary: Today we begin our exploration of the Java programming language.

Related Pages:

• EBoard.
• Lab J1.

Assignments:

• Read Introduction to J2: Objects in Java and Discussion for J2: Objects in Java.

Notes:

• I've rearranged the order of topics slightly.
• Extra credit for attending the Marlene Zuk convocation or 4:15 lecture on Thursday (double extra credit for attending both).
• Are there more questions on exam 2? Yes, the partition! problem is intentionally hard.

Overview:

• About Java.
• Your first Java program.
• Java in the MathLAN.
• Lab.

An Introduction to Java

• Java is an object-oriented language developed by Sun Microsystems.
  • It was ostensibly developed for building large programs.
  • Many of these programs were to run on autonomous systems, like toasters.
  • With the popularization of the World Wide Web, it has also become popular as a language for creating Web applications.
  • It is also a reasonably good introductory language (or so say many computer science educators).
• Java looks a lot like C and C++, two popular languages. It has many differences from the two.
  • It is object-oriented (which C is not but C++ is)
  • It has a different view of object-orientation than C++.
  • It provides automatic memory management (yay!).
  • We'll see some others as time goes on.
• Sun says that Java is a simple, object-oriented, distributed, interpreted, robust, secure, architecture neutral, portable, high-performance, multithreaded, and dynamic language.
  • Simple. Compared to many modern languages, there is not too much to the core of Java. However, a great deal of functionality exists in the standard libraries, and you will eventually need to learn many parts of those libraries. In addition, the core is relatively large compared to many other languages (as my co-authors and I have found as we tried to focus on just the essentials). Java is also much larger than Scheme or Pascal.
  • Object-oriented. Java focuses on the creation of classes and objects. Every Java program begins with a central class or object.
  • Distributed. Java permits you to place different portions of a program on different servers, to segment processing between servers, and so on and so forth.
  • Interpreted. Although a compiler translates Java code to another format (byte codes), an interpreter is required to execute or further translate the byte codes.
  • Robust. Java provides a number of facilities for ensuring that things don't go wrong or that, when they do, the programmer provides ways to resole problems.
  • Secure. The Java interpreter will often limit what a program can do (from accessing the file system to reading memory outside of a valid range). We often say that Java gives each program a sandbox to play in. Note that our HP implementation is somewhat less secure, and it is possible to crash it in some situations.
  • Architecture neutral. A Java program will run identically (except for speed) on every platform. Unlike most languages, which can have a different implementation on every platform, Java has specific requirements for essentially every part of the language (from the amount of storage used for various data types to the algorithms used for numeric computation).
  • Portable. See the sections above on architecture neutrality and distributed programming.
  • Multithreaded. A program can have separate threads of computation, and it is relatively easy to manage those threads.
  • Dynamic. New objects can easily be created, and new classes can be loaded as the program runs.
• Unfortunately, Java is also a moving target.
• Java also has an enormous library.
  • This has some benefits. For example, there are libraries that handle many of the things you'd like to do as part of a program (sort, make a list, put up a window)
  • It also has many drawbacks. In particular, there are a lot of things that you need to learn to be fluent in Java.

Your First Java Program

• When you put together a complete Java program, you'll use a number of different classes. One class, which we might call the driver (or conductor or director) provides the main method that directs everything else.
• The main method generally
  • Creates objects
  • Tells them to do things.
• Here is a simple Java program that prints a greeting message. We'll talk about the parts in class.

  import java.io.PrintWriter;              // Load library
  /**                                      
   * Your first Java program.
   *
   * @author Samuel A. Rebelsky            // Author of the program
   * @version 1.1 of March 2003            // Version of the program
   */                                      // End of introductory comment
  public class FirstProgram                // Class declaration
  {                                        // Start body of class
    public static void main(String[] args) // Declare main method
    {                                      // Start body of main method
      PrintWriter output;                  // Declare variable
      output = new PrintWriter(System.out,true);         
                                           // Create object
      output.println("That's it!");        // Call object method
    } // main(String[] args)               // End body of main method
  } // class FirstProgram                  // End body of class
  

• Here, the main method creates one object, output, and tells it to do one thing, print a string.

Compiling and Interpreting

• As you may know, computers work with a number of different languages.
• Each computer really understands only one language: its underlying machine language.
• We make computers understand another language by either
  • writing programs that translate the other language to the computer's machine language (compilation)
  • writing programs that read programs written in the other language and then directly executing those programs (interpretation)
• Java uses an interesting combination of compilation and interpretation.
• You must first compile your Java program to Java Virtual Machine (JVM) code.
  • You then interpret the JVM code.
• To compile Java programs, write

  % javac file.java
  

  • That is, run the program called javac (Java compiler).
• To interpret compiled Java programs, write

  % java file.class
  

  • That is, run the program called java (Java interpreter).
• In the MathLAN, you need to tell the computer where to find both things with

  export PATH=/usr/java/j2sdk1.4.1_01/bin:$PATH
  

• Try it.

Lab

• If there's time, we'll try experiments from lab J1.
• Start with J1.3 and J1.5.
  • Do others if you have extra time or need more background.