Class 04: An Introduction to Java (1)

Held: Friday, January 27, 2006

Summary: Today we begin our exploration of Java with a simple program.

Related Pages:

• EBoard.
• Espresso: An Introduction to Java.

Assignments

• Reread Espresso: An Introduction to Java.

Notes:

• Sorry about Wednesday. I'll leave time for questions.
• Another day without written homework. Yay!
• Today will be Java background. We may start a lab today; if not, we'll do it on Monday.

Overview:

• Questions on Unix.
• Java basics.
• Detours: Packages and Projects.
• Your first Java program.
• Running programs.

Some Basics of Java

• Java is a popular object-oriented language.
• What do you expect to see in an object-oriented language?
  • Support for defining classes: The templates that let us build objects.
  • Support for creating objects: The primary components of our programs.
  • Ways to define new classes in terms of old classes.
  • Some how to "start" our program: Build the initial objects and tell them what to do.
  • Some forms of protection or encapsulation
• In Java,
  • Each class is usually defined in a separate file, typically NameOfClass.java
  • Related classes are typically grouped into packages.
  • Classes contain a list of fields (along with what type of value they hold) and methods.
  • Fields and methods may be prefixed by a protection level (private, protected, or public)
  • New objects are created by writing new, the name of the class, and any parameters the constructor for the class needs.
  • A special class (which I call the Main class) contains a method called main which one uses to start the program.

Detour: Packages

• Packages are one of the things introductory Java programmers often have difficulty with, so we'll start with them.
• As I mention above, we tend to group related files in packages.
• You specify the package for a Java class at the beginning of the class with the package command.
• Package names can include many components separated by periods. For example, I might put the files for the first CSC152 Java exercises in package rebelsky.csc152.2005s.introjava.
  • I've used a slightly simpler naming scheme for this class.
• Package names often include the author (and authoring institution).
  • Package names for general use often look like reversed hostnames: e.g., edu.grinnell.cs.rebelsky.cs152.2005S.introjava
  • For this class, I'd just like you to use a two-part package name: your name followed by a short name for the "project".
• The source files for packages should be placed in directories that correspond to their names.
  • For example, something in package foo.bar.baz should be in a directory called baz, which is a subdirectory of bar, which is a subdirectory of foo.
  • The starting point (the parent directory of foo, in this example) gets specified elsewhere.

Projects

• Eclipse, our development environment, further complicates things by requiring all code to be in a project.
• A project is a somewhat larger container than a package. Projects are, in essence, a collection of packages.
• Whenever you start a new lab, you should probably start a new project.

Developing Java Programs in Eclipse

• We will be using Eclipse to edit and run Java programs.
• Eclipse is a professional Java (and other language) devleopment system.
• Eclipse takes a little while to get used to; it's not as simple as DrScheme.
• For Eclipse to run correctly, you need to set up your environment.
  • Edit your .bash_profile to put /opt/jdk1.5.0/bin at the front of your PATH
  • Edit your .bashrc to add the following aliase

    alias eclipse="/home/rebelsky/Eclipse/eclipse/eclipse"

Your First Java Program

package rebelsky.introjava;

public class First
{
  public static void main(String[] args)
    throws Exception
  {
    java.io.PrintWriter pen;
    pen = new java.io.PrintWriter(System.out, true);
    java.lang.String greeting;
    greeting = "Hello";
    pen.println(greeting);
  } // main(String[])
} // class First

Let's deconstruct this program

• package rebelsky.introjava;
  • The program belongs in the package rebelsky.introjava. Note the semicolon at the end of the line.
• public class First
  • I am defining a class named First that is available to others.
  • The open and close braces indicate the start and end of the class definition.
• public static void main(String[] args) throws Exception
  • We're defining the necessary main method.
  • More gobbledygook than you'd like. This is, however the standard way to write main.
  • That method can accept an array of strings as parameters: (String[] args)
  • That method returns no values: void
  • That method is not associated with any particular object: static
  • That method is accessible by anyone: public
  • Things might fail miserably: throws exception
  • The open and close braces indicate the start and end of the method definition.
• java.io.PrintWriter pen;
  • Declare a new variable, named pen, which refers to objects of class java.io.PrintWriter.
• pen = new java.io.PrintWriter(System.out, true);
  • Create a new java.io.PrintWriter which prints to the normal output location (the screen)
  • Use the variable pen to refer to that object.
• java.lang.String greeting;
  • Declare a new variable, named greeting, which refers to objects of class java.lang.String
• greeting = "Hello";
  • Make greeting refer to the string Hello.
  • Note that we use a different syntax for string objects.
• pen.println(greeting);
  • Tell the pen to print the greeing.