Outline of Class 3: More Java Basics

Held: Wednesday, January 21, 1998

Administrivia

• How did yesterday's lab go?
  • I've fixed the problem with the alternate program used in the back two rows.
  • Did you learn anything that you can generalize?
• The first assignment is now ready. It is due at the beginning of class next Wednesday.

Procedural Programming

• Although Java is primarily concerned with the creation of classes and objects and with communication between objects, the methods that objects execute in response to requests are defined procedurally.

• In a procedural (or imperative) language, programs are written as collections of what I term "basic actions" which are then sequenced with "control structures".
• Basic actions are typically of one of the following forms:
• Get a value from memory
• Store a value in memory
• Compute a value from other values
• Read a value from an input device
• Write a value to an output device
• We usually reserve and assign types to memory locations using variables. These are similar to the things you declare using let.
• There are a variety of control structures in imperative languages. The basic ones include
  • Sequencing
  • Conditionals
  • Loops
  • Function calls
• In imperative languages, instructions are often presented in sequences, and the instructions are then executed one-by-one. This corresponds to the block command in scheme.
• Conditionals select one of a number of options, based on a selector value. The most common conditional is the if statement. In most imperative languages, if selects between two alternative sequences of actions (or decides whether or not to execute a single alternative) based on the value of a boolean expression.
• Loops repeat a sequence of actions some number of times. The number of times can be fixed, or it can depend on a condition that is regularly checked. You may know loops form the do loop of scheme.
• Function calls are similar to those of Scheme. When you call another function, the body of that function is executed.

Java Basics

• In Java, you program by defining classes, constructing instances of (objects from) those classes, and doing things with those instances.
• Each class is stored in a separate file. (Okay, you can combine the source code for a number of classes into one file, but when compiled they are broken into separate files.)
• When building large projects, you often group classes into packages. We'll come back to these later.
• What are the components of a class? (Not in order.)
  • The class name
  • The protection level of the class (for now, we'll just use public)
  • The body of the class, which includes
    • attributes (also called fields), which are then customized for each instance of the class
    • methods, which may behave differently for each instance of the class
    • class attributes, which belong to the class as a whole, rather than to any individual members (we'll come back to these later)
    • class methods, which belong to the class as a whole, and are not associated with individual members
    • constructors, which describe how to build instances of the class
    • destructors, which describe how to get rid of instances of the class
• How do you define a class?
  • A class definition begins with the keyword class and the name of the class. Custom says that we capitalize the names of classes.
  • The body of the class begins with a left brace, and ends with a right brace.
  • Attributes are declared by writing the class (or primitive type) of the attribute, followed by the name of the attribute, followed by a semicolon.
  • Java allows you to restrict access to classes. To make a class generally accessible, you precede the keyword class with public.
  • Java allows you to base classes on other classes. We'll get back to this later.
  • Java allows you to indicate that your class will support particular sets of actions. We'll get back to this later.
  • Attributes can also have protection modifiers (like the public we use with the class).

• The "primitive types" mentioned above are the primary building blocks of objects. They are the basic kinds of values that the Java machine knows about, and include
  • boolean, for true/false values
  • char, for characters (unlike many other languages, Java officially supports more than just the basic American set; it has built-in support for full Unicode)
  • byte, for very small integers in the range -128 to 127 (integers are numbers without fractional portions)
  • short, for small integers in the range -32,768 to 32,767.
  • int, for integers in the approximate range -2 billion to 2 billion
  • long, for integers in a much bigger range
  • float, for numbers that may have a fractional component (e.g., 10.32533).
  • double, for better accuracy
  • See p. 227 of Flanagan for full list.
• The names are composed of letters, numbers, and underscores (and perhaps a few other things) and must begin with a letter or underscore.

• Here's a simple class definition of a class that has no methods.

  public class Complex 
  {
    double real_part;
    double imaginary_part;
  } 
  

• This says that class Complex has two fields, each of type double.
• As I suggested earlier, you should include a number of comments in your program. Hence, a more appropriate version would be.

  /**
   * A simple representation of Complex Numbers.
   * 
   * @author Samuel A. Rebelsky
   * @version 1.1 of January 1998
   */
  public class Complex 
  {
    /**
     * The real part of a complex number in standard format.  
     * The "x" in "x + y*i".
     */
    double real_part;
    /**
     * The imaginary part of a complex number in standard format.
     * The "y" in "x + y*i".
     */
    double imaginary_part;
  } // Complex
  

• Note that I may not include all these comments in my sample code, but you should plan to.

• How do you get a new object from this class? Traditionally, you can declare a new object with
  class-name variable-name = new class-name()
• For example,
  Complex c1 = new Complex()

• To define a method of a class, you provide
  • The return type of the method (you return values from methods with the return statement).
  • The name of the method
  • An open paren
  • The list of parameters to the method
  • A close paren
  • An open brace
  • The body of the method (a series of statements, each of which is terminated by a semicolon)
  • A close brace
• You can also preface the return type with a number of modifiers, which we'll come back to later.
• Standard methods can refer to the attributes associated with the class (and ancestor classes, but we'll get back to that later).
• To call the method associated with an object, you use
  • the object's name
  • a period
  • the method's name
  • an open paren
  • the paremeters to the method
  • a close paren
• Note that this is somewhat different than in a language like C or Pascal, in which the object would be one of the parameters.

• Here's our sample class, extended with three methods, one to set the parts, one to get the real part, and one to get the imaginary part.

  /**
   * A simple representation of Complex Numbers.
   * 
   * @author Samuel A. Rebelsky
   * @version 1.1 of January 1998
   */
  public class Complex 
  {
    /**
     * The real part of a complex number in standard format.  
     * The "x" in "x + y*i".
     */
    double real_part;
    /**
     * The imaginary part of a complex number in standard format.
     * The "y" in "x + y*i".
     */
    double imaginary_part;
    /**
     * Set the value of our imaginary number.
     */
    public void setValue(double rpart, double ipart) 
    {
      real_part = rpart;
      imaginary_part = ipart;
    } // setValue
    /**
     * Get the real part of this complex number.
     */
    public double getReal() 
    {
      return real_part;
    } // getReal
    /**
     * Get the imaginary part of this complex number.
     */
    public double getImaginary() 
    {
      return imaginary_part;
    } // getImaginary
  }  // Complex
  

• How does Java know where to begin executing your program, especially when you may have multiple classes, each with multiple methods? You must tell the Java interpreter which class to begin with, and that class must have a special main method, which is where the interpreter begins. main has type void and must be public and static. It takes one parameter, an array of strings.
• Here is a main routine for our sample class

  /**
   * Test various aspects of our complex class.
   */
  public static void main(String[] args) {
    // Set up an object for printing output
    SimpleOutput out = new SimpleOutput();
    // Set up a new complex variable
    Complex c1 = new Complex();
    // Print the initial values of the real number
    out.print("Initially, the real part is ");
    out.println(c1.getReal());
    out.print("Initially, the imaginary part is ");
    out.println(c1.getImaginary());
    // Set the value to a particular value and see if it's changed
    c1.setValue(1.0,3.4);
    out.print("Now, the real part is ");
    out.println(c1.getReal());
    out.print("Now, the imaginary part is ");
    out.println(c1.getImaginary());
    // Exit gracefully
    System.exit(0);
  } // main