Outline of Class 2: Introduction to Java

Miscellaneous notes

• It appears that Java does not work on the back two rows of computers in 2435. Why not? Because they have small hard disks, which means that they don't have enough virtual memory.
  • Solution one: move forward in the classroom
  • Solution two: rlogin to another machine
  • Solution three: become rich and donate hard disks
• Mr. Stone has now installed the non-beta version of Java 1.1 in /usr/local/java with symbolic links from many other places. Thanks you Mr. Stone.
• I've put a few "Introduction to Java" type books in the MathLan lab. Feel free to go over them, but please don't take them out of the lab.
• I responded to every survey I received by 9pm on Sunday. If you didn't receive a response, let me know.
• You can find answers to your survey questions in QandA/survey.html (starting with the course root).
• Anyone have any questions about the readings? Don't worry, you're not yet expected to understand any of the Flanagan book.

Introduction to Java

• Java is an object-oriented language developed by Sun Microsystems.
  • It was ostensibly developed for developing large programs.
  • Often, 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 transportable applications.
• Java looks a lot like C and C++, two popular languages. It has many differences from the two.
  • It is object-oriented, unlike C; and has a different view of object-orientation than C++.
  • It provides automatic memory management (yay!).
  • We'll see some others as time goes on (some even in the next topic).
• 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 those libraries.
  • Object-oriented. Java focusses 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 for 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.
  • 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 neutral and distributed.
  • 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.

Preparing to work with Java

• While you are free to do your Java development on any machine that you deem appropriate, while you're in class you'll need to work on the departmental MathLAN. That's also where I'll be doing my work.
• There are two versions of Java installed on the MathLAN. We'll be using the beta version of the Java 1.1 compiler, as that matches the one in our textbooks.
• You will need to configure your account to use Java. In particular, you will need to make two basic changes to your .cshrc file.
  • Somewhere in your .cshrc add the line
    set path = (/usr/local/java/bin ${path})
    This tells your shell to look in the new Java bin for the appropriate programs.
  • Somewhere in your .cshrc add the line
    setenv CLASSPATH ".:/u2/rebelsky/Courses/152/structure.zip"
    This tells Java to use that file for some classes. (Yes, even if you're not in 152, you may want to use those classes.)
  • It's best to log out and log in again to make sure those changes take (or, minimally, to open a new shell), but you can also type source ~/.cshrc to get those changes accepted in the same session.
• To translate a .java file to a .class file, you use javac, the Java compiler.
• To interpret a .class file, you use java, the Java interpreter.

Your first Java program

• What do you need to know to write a Java program?
  • A Java "program" begins with a particular class (the class that you tell the Java interpreter to execute).
  • That class must have a main routine, which is the routine that the interpreter executes.
• Here is a simple Java program to print "Hello World!" on the screen.

  public class HelloWorld {
    public static void main(String[] args) {
      System.out.println("Hello World!");
    } // main
  } // HelloWorld
  

• Save that program as HelloWorld.java.
• To compile the program, type
  javac HelloWorld.java
• To execute the program, type
  java HelloWorld
• Let's try to deconstruct our program
  • The first public says that our class is publically accessible. Later, we'll see why and how you might want to have private classes.
  • The class tells the Java compiler that we're defining a class.
  • The HelloWorld names the class. In general, the name of your class should correspond to the name of the file that defines the class (and you should only define one class per file).
  • The left brace begins the definition of the class.
  • Skipping ahead to the end, the final right brace ends the definition of the class.
  • The two slashes begin a one-line comment. I make it a practice to comment every (or nearly every) right brace.
  • Backing up, the second public says that our main function is publically accessible.
  • The static says that the function belongs to the class as a whole, and need not be associated with a particular object of the class.
  • The void says that the function has no return value.
  • The main names the function.
  • The stuff in parentheses are the parameters to the function. Every main function takes the same set of parameters, even if it may not use them.
    • The String[] indicates that the parameter is an array/vector of strings.
    • The args names that parameter.
  • The left brace begins the function.
  • The right brace ends the function.
  • The body of the function says to call the println method of the out object provided by the System class, using the string Hello World! as a parameter.
• Ignoring the class, in Scheme this would be written something like

  (define (main args) (write "Hello World!"))
  

Exercise

• Make the aforementioned modifications to your .cshrc file.
• Try entering and running the Java program.