Department of Engineering

Java Course Examples

• The CUED Java Course page
• Issues related to CUED's C++ courses (for those confident enough about C++ to use it as a basis for learning Java)
• Issues related to CUED's IIA Computing course (for those taking course 3F6 )
• Selected Topics
  • I/O
  • Exceptions
  • Interfaces
  • Graphics
• A short Glossary
• Further References

• Program 1 - Put the following into a file called Program1.java.

  class Program1 {
      public static void main(String[] args) {
         System.out.println("99 euros = " + 99. *(61./100.) + " pounds");
      }
  }
  

  It has a root class which prints out 2 strings and the result of a calculation by calling the println method (in Java, functions are called methods). Note that the method has a long name which shows where it comes from. println belongs to out which belongs to System (which in turn is part of the java.lang package, which is implicitly imported - more on this later). Java has many routines but because they're organised in a hierarchy, sorting through the documentation isn't too hard - the name of the method shows you where to look.

  To execute this program it first needs to be compiled into a byte-code file. The Java compiler, javac, takes your source file and translates its text into the native language of the Java Virtual Machine.

     javac Program1.java
  

  This produces a file called Program1.class which can be fed to the Java interpreter by typing

     java Program1
  

• Program 2 - Now for some file handling. This program prints hello into a file called abcde. It's not as simple as you might have hoped for - details elsewhere! Java (like C++) has a small core of keywords. It gains its power by importing packages of classes. Each package can be complicated. It's important to have access to package documentation either online or in a big book. This program uses the io package.

  Note the addition of throws Exception. Without this the program won't compile. Exceptions in Java and C++ are a way of dealing with errors. Java knows that the file-handling commands might come up against problems (it might be impossible to create files, for example) and insists that the program recognises this possibility.

  import java.io.*;
  class Program2 {
     public static void main(String[] args) throws Exception {
        PrintStream pstream;
        FileOutputStream fstream;
        File myfile;
             
        myfile= new File("abcde");
        fstream = new FileOutputStream(myfile);
        pstream = new PrintStream(fstream);  
        pstream.println("hello");
     }
  }
  

• Program 3 - Before continuing with file-handling, a short graphical interlude. Creating C++ graphical programs that can run in a browser would at best require 100s of lines of source code. In Java we can exploit inheritance to create an applet in a few lines. This applet will be based on the standard Applet class, but will write our own paint routine for it.

  import java.applet.Applet;
  import java.awt.Graphics;
  
  public class Program3 extends Applet {
      public void paint(Graphics g) {
         g.drawString("Hello world!", 50, 25);
      }
  }
  

  Note that we use extends to mean that Program3 is going to be derived from Applet (whose definition we've imported). We're also importing the Abstract Window Toolkit (awt) to do graphics. For now, we'll gloss over the details. To make this work you need to compile it, put it somewhere on the WWW then write a page including HTML code similar to what's below (with the codebase appropriately set). Here's how to run my (tpl's) copy

    <applet codebase="http://www2.eng.cam.ac.uk/~tpl/javateaching"
          code="Program2.class" width=400 height=75 align=center >
    <param name="text" value="This is a demo.">
    <blockquote>
    <hr>
    If you were using a Java-enabled browser,
    you wouldn't see this paragraph.
    <hr>
    </blockquote>
    </applet>
  

• Program 4 - This time we'll try to use a file (called /impossible) that ordinary users can't create. This will generate (or throw) an exception which we're going to catch. All we'll do it print a message but in other circumstances we could try to recover. The try command shows the region where thrown exceptions will be caught by our code rather than by the default catcher.

  import java.io.*;
  class Program4 {
      public static void main(String[] args) throws Exception {
          PrintStream pstream;
  	FileOutputStream filestream;
          File myfile;
          try {
              myfile= new File("/impossible");
              filestream = new FileOutputStream(myfile);
              pstream = new PrintStream(filestream);  
              pstream.println("hello");
          }
          catch(Exception e) {
              System.err.println("An error has happened");
          }
      }
  }
  

• Program 5 - You can find out about the system the program is running on, the Java set-up, and the user running the program by listing Properties

  import java.util.Properties;
  class Program5 {
     public static void main(String[] args) {
        Properties properties;
        properties=System.getProperties();
        properties.list(System.out); 
     }
  }
  

Note that if you put this code into an applet, you wouldn't be able to get this information - Java's security features forbid it.
• Program 6 - Java was designed at a time when new lists of common basic operations were emerging. Often in programming nowadays an object needs to know about a change in another. Java has a facility that lets Observers be notified when a resource (an Observable) changes. Here 2 students are being added to the list of observers of SupervisionAppointments. When there's a change in the appointments each student gets a message.

  import java.util.*;
  
  public class SupervisionAppointments extends Observable {
    private String message;
    public String getMessage() {
        return message;
    }
    public void changeMessage(String message) {
      this.message = message;
      setChanged();
      notifyObservers(message);
    }
  
    public static void main (String [] args ) {
      SupervisionAppointments appointments = new SupervisionAppointments();
      Student janet = new Student();
      Student john = new Student();
      appointments.addObserver(janet);
      appointments.addObserver(john);
      appointments.changeMessage("Friday meeting cancelled");
    }
  }
  
  // an observer is expected to have an appropriate "update" routine.
  // "Observer" is an "interface" (like a C++ prototype?)
  class Student implements Observer {
    public void update(Observable o, Object arg) {
      System.out.println("appointment changed! " + arg);
    }
  }
  

• Program 7 - Compile and run this program then explain the output

  class Program7 {
     public static void main(String[] args) {
        int i=1, j=3;
        System.out.println("i+j="+i+j);
        System.out.println("i+j="+(i+j));
     }
  }